A personal team of AI assistants, each with a specific job, built around the work we do every day in WebCenter. Not a chatbot. A crew that runs in the background so I can focus on what actually matters.
The name
What does 影組 mean?
Japanese names are chosen for what they carry, not just how they sound. This one is two characters, and both of them matter.
影
Kage
Shadow · Reflection
In Japanese culture, a shadow working behind the scenes is a sign of trust and reliability, not something sinister. A skilled shadow supports without demanding attention.
組
Gumi / Kumi
Crew · Assembly
The same character appears in 組織 (soshiki, organisation) and in traditional Japanese craft guilds. It implies a structured group with a shared purpose, each member knowing their role.
Together: a quiet crew that handles things in the background, so I don't have to.
The origin
This didn't come from nowhere 16年
Kage-gumi looks like an AI project. It's actually the output of 16 years at Esko: code I wrote, problems I solved, and WebCenter patterns I collected along the way, with AI finally powerful enough to put all of it to work.
2010
2 yrs
Software Support Engineer · Esko
The foundation. Less about having answers, more about finding them. Learning from the people around me who knew the product inside out, and documenting everything. The habit of capturing knowledge started here.
2012
5 yrs
Global Support Software Engineer · Esko
Where the deep knowledge began. Internal trainer for WebCenter Professional, Expert, and Packaging Content Management. Building and delivering training meant truly understanding every layer: the SDK, the scripting, the logic. The codebase was born here.
2017
Present · 9 yrs
Senior Solution Architect · Esko
Where it all accumulates. Project after project, customer after customer. Every solution built, every script written, every edge case hit gets added to the codebase. This is also where the search for better tools began, and eventually led to Kage-gumi.
2022
Late · AI
First experiments with AI
Late 2022, I start putting the new large language models to work on real WebCenter problems. Rough at the edges, but the potential is immediate, and it becomes the springboard that, three years on, turns years of collected work into a crew.
2025
08 Dec · Born
影
The idea for Kage-gumi 影組
Not a finished system on day one. A decision. The moment the search for better tools becomes a plan: give sixteen years of WebCenter work a set of hands, as a crew of operatives that runs in the background.
The AI didn't replace the experience. It finally made 16 years of it instantly usable.
When Mei answers a WebCenter question or Ren generates a script, it's drawing on a real body of work, not hallucinating from documentation. That's the difference between a general AI tool and something purpose-built over years.
The problem it solves
Built around WebCenter 日常業務
WebCenter is powerful, but a lot of the daily work around it is repetitive, time-consuming, or requires knowing exactly the right script syntax. That's where the crew comes in.
Without Kage-gumi
Searching documentation to remember the right JSP call syntax
Writing WebCenter scripts from scratch each time
Writing up documentation after every build
Digging through logs to understand what went wrong
Context-switching between tasks constantly
Half-present in meetings, taking notes instead of actually being in the room
Constantly searching the WebCenter system to work out which dashboards, searches and forms are nested on a page
Drawing workflow diagrams in a generic tool that knows nothing about WebCenter, then rebuilding them by hand in the system
With Kage-gumi
Ask Mei, the WebCenter support operative, in plain language
Ren authors the whole surface (scripts, config, workflows), versioned with diffs
Haku deploys the build into WebCenter and documents it automatically
Logs are surfaced and summarised, not buried
Ryū handles overnight batch work autonomously
Chō captures & summarises the meeting and Sumi files it: be present, not the note-taker
Tōshi X-rays any page: every nested dashboard, search and form, in one click
Zuan diagrams a workflow in WebCenter's own language and pushes it straight to the server, or pulls an existing one back to edit
And it doesn't have to stay personal. Because Mei already carries the WebCenter support playbook, after a build I can drop a tailored instance at the customer and let their team use it as a self-service support bot that answers the same questions I would, without me in the loop.
The knowledge
A WebCenter-native knowledge brain 知の蔵
Every skill, every pattern, every hard-won lesson, absorbed and retrievable.
Not search over documents. Judgment over a corpus. It knows a dashboard script from a rule-engine script, knows the SDK surface, knows the guardrails, because it has read everything I have and reasons the way I would.
Absorbed
Skills, knowledge base, product manuals, config, years of build patterns.
Grounded
Answers come from the corpus, not guesses.
Native
Speaks WebCenter, not just about it.
The operatives
Meet the crew 影組メンバー
Each operative has a Japanese name chosen for what it means, not just as decoration. The character shapes how that operative behaves. Hover any card to see a real scenario that operative handles.
▸ real scenario
Real scenario
明Mei · KG-01 Support
"How do I set a WebCenter attribute via SDK?"
Instead of hunting through docs, I ask Mei. She carries the whole WebCenter knowledge base: every API and JSP endpoint, the full manuals, the database reference, the error patterns. Working code, or a straight answer, comes back immediately.
Active
KG-01
明
Mei
Support Agent
Esko / WebCenter
"Bright": clarity, illumination
The crew's living WebCenter reference: every API and JSP endpoint, the full manuals and database reference, every attribute and error pattern. Ask in plain language, get a working answer. Mei prepares the ground before anything else happens.
▸ real scenario
Real scenario
錬Ren · KG-02 Builder
"Build a display script that shows the status progression of a project"
A script is just one example. Ren authors the whole WebCenter surface: Workflow, Task, Rule Engine and Dashboard scripting, but also attribute categories, lists and the rest of the configuration, plus Workato recipes, Automation Engine tickets and Miro boards. Everything comes back versioned, diffable and committed, then handed to Haku to take live.
Building
KG-02
錬
Ren
Builder
Scripting, config & integration
"Tempered": forged, refined
The crew's forge. Ren authors the whole WebCenter surface, not just scripts. Every scripting context (Dashboard, Rule Engine, Workflow Node, SDK/JSP, Scriptable-List SQL, Jasper, action buttons, custom form extensions) plus the configuration around them: attribute categories, lists, task types, project statuses, templates, whole workflows. And past classic WebCenter: Workato/iPaaS recipes with diagrams, Automation Engine tickets, bidirectional Miro workflow boards, even KG web itself. Each context has its own rules and Ren knows them all; every artifact comes back versioned, diffable, KG-branded and committed to the repo. Ren writes it. Haku takes it live. Tempered by the work, refined until it holds.
▸ real scenario
Real scenario
博Haku · KG-03 Deploy & Doc
"Take what Ren built live, then document it and find what we already have"
Haku deploys Ren's work into WebCenter (scripts via Playwright, config via the API), keeping repo and server in lockstep with a nightly mirror and a drift guard. Then she documents what was built and surfaces what already exists, clean and Azure DevOps-ready.
Idle
KG-03
博
Haku
Deploy & Doc
Deploy, sync & docs
"Sound of jewels": clarity, precision
The one who takes the build live. After Ren authors something, Haku deploys it straight into WebCenter: dashboard and rule scripts via Playwright, and the config surface (attributes, categories, lists, reports, workflows, task types, dashboards, users and groups) via the WebCenter API. She keeps repo and server in lockstep both ways: a nightly mirror pulls every live script back into the repo, and a drift guard captures a colleague's in-WebCenter edit before any push can overwrite it. Then she documents it: clean Azure DevOps specs published to the wiki, and answers written back into DevOps work items when a colleague asks the crew for help. Searchable, shareable, stored. The inspector's eye she first opened (透 Tōshi) has since grown into an operative of her own (see her card).
▸ real scenario
Real scenario
龍Ryū · KG-04 Night Runner
"Keep the customer's Azure DevOps docs in step with WebCenter, overnight"
Every night Ryū pulls the live WebCenter config and reconciles it into the customer's Azure DevOps wiki and board (new config documented, deleted config flagged), then leaves a morning digest. Just one of nine time-zone-pinned missions he works while I sleep.
Scheduled
KG-04
龍
Ryū
Night Runner
Overnight Automation
"Dragon": powerful, tireless
Runs scheduled tasks while I sleep. Surfaces his own proposals for the next run, queues scripts for review, and delivers a morning digest. Launch a proposal and it becomes a real, tracked dashboard task. Dragons don't rest. Neither does Ryū.
▸ real scenario
Real scenario
聴Chō · KG-05 Meeting Listener
"Capture this customer call and turn it into something I can use"
Chō listens and transcribes locally with faster-whisper (nothing leaves the machine), then returns a structured summary: decisions, action items, open questions. Meeting knowledge becomes reusable text the rest of the crew can act on.
Listening
KG-05
聴
Chō
Meeting Listener
Capture & Summarize
"To listen": attentive, fully present
Sits in the shadows of a call and listens. Captures the audio, transcribes it on-device with faster-whisper (nothing ever leaves the machine) and hands back a clean summary: decisions, action items, open questions. A meeting stops being something you re-type from memory and becomes reusable text that feeds straight back into project work and the crew's knowledge.
▸ real scenario
Real scenario
墨Sumi · KG-06 Record-Keeper
"File that meeting under the customer, for good"
Once Chō has summarised, Sumi files it into a durable per-customer record, and it doesn't just sit there. It loads into the crew's memory so the next build already knows this customer, and the agreed changes can fire straight off as tasks.
Filing
KG-06
墨
Sumi
Record-Keeper
Customer Ledger
"Ink": permanent, deliberate
The ear hears; the ink keeps. After Chō summarises a meeting, Sumi files it into a durable, per-customer record, then puts it to work. The dossier loads into the crew's memory, so the next build already knows the customer's history, and the changes agreed in the call can fire straight off as tasks: a WebCenter config fix can start the moment the meeting ends. Faithful and factual, never inventing an attendee or a date.
▸ real scenario
Real scenario
英Ei · KG-07 The Counsel
"Is this the right call, or am I about to make a mistake?"
Ei never touches the system: her work is judgment, not execution. Bring her a direction and she stress-tests it: the pre-mortem, the red-team, the go/no-go. She names the real risk before it costs anything.
Advising
KG-07
英
Ei
The Counsel
Advisor & Strategist
"Brilliance": the clarity to call it straight
The crew's conscience and strategist. Where the others act on the world, Ei acts on the plan: direction, positioning, the go/no-go call. The judgment layer: she tells me whether it's the right move before the rest of the crew commits.
▸ real scenario
Real scenario
透Tōshi · The Seer
"What's actually on this page, and where do I go to edit it?"
The pain everyone who touches WebCenter knows: you are on a page with no idea which dashboards, searches and forms are nested inside it. Tōshi X-rays it in one click: the whole nested structure, every item a direct link to its editor. And when support asks for logs, one press bundles WebCenter's diagnostics and server logs into a stamped zip: the gathering everyone dreads, done in a click.
Watching
THE EYE
透
Tōshi
The Seer
Inspector · Recon
"Clairvoyance": to see straight through
Where the others build and deploy, Tōshi reveals. One click on any WebCenter page and she lays out everything nested inside it (dashboards, saved searches, forms), each a direct link to its editor; hover to highlight a node on the page, pick an element to jump back to its row, and export the whole map as a handover-ready ticket. She walks a dashboard's full reference graph too, flagging anything deleted. Born as Haku's inspector eye, she now rides along as a one-click Chrome extension and a KG panel. And since every build starts by seeing the ground first, Tōshi is never idle. The shadow that reads the blueprint behind the glass.
There are three technologies that make this work. Each one has a distinct job and they stack cleanly.
LLMLarge Language Model
The brain: Claude API
The LLM is Claude, the AI doing the actual thinking. The operatives aren't different AI models. They're the same Claude, given different system prompts and memory that shape how they behave. Mei thinks like a WebCenter support engineer. Ren thinks like a builder. Same brain, different expertise.
MCPModel Context Protocol
The hands: real-world reach
Without MCP, Claude can only produce text. MCP is what lets an operative actually reach into real systems: read and update WebCenter directly, draw a workflow on a Miro board, publish a spec to Azure DevOps. When Mei pulls a project's live attributes, or Haku files a functional spec straight onto the board, that's MCP. It gives the crew arms.
CLICommand Line Interface
The engine room: Claude Code
Claude Code (the terminal tool) is how the system itself is built and maintained. Setting up the repo, wiring agents together, writing the logic that connects operatives to each other, all done through Claude Code sessions. It's also what lets Ryū run autonomously in the background, without needing anyone sitting in a chat window.
The CLI built the house. The LLM is the mind living inside it. MCP is the arms reaching into the world.
YOUMe → Dashboardgive Mei a task
OPRMei loads system prompt + memoryKG-01
LLMClaude API thinksWebCenter knowledge active
MCPReaches into real toolsWebCenter / Miro / Azure DevOps
OUTResult surfaces in dashboardtask complete
In practice
What it looks like
Real screenshots of the running system, not mockups, not demos.
// KG 2.0 · in build
These shots are the interface running today. The 2.0 UI is currently being built.
The screenshots below show the live crew as it stands now. A ground-up 2.0 redesign (the brush-ink look this very deck is dressed in) is in progress, so what you see here is a snapshot mid-repaint, not the finished surface.
DASHBOARD: operative cards + live task queue. Tasks auto-route to the right operative.
CREW CHAT: ask in plain language; it auto-routes to the right operative. Here, Mei triages a notification outage.
CREW CHAT · Ren the builder: a reusable WebCenter Display Script, generated and versioned on request.
ROADMAP: live in-app view of both the functional and cosmetics release plans.
What's next
The release plan ロードマップ
Kage-gumi isn't finished. It's a living system that grows deliberately, not all at once. The plan below is the major blocks, built in sequence, each one standing on the ones before it. Read top to bottom and you see how the crew grew from a dashboard into a platform, and where it's headed next.
Last updated: 2026-07-15
影組
Shipped
Foundation
the base
The base everything else stands on: the dashboard and crew chat that route a plain-language task to the right operative, live task data with token-budget enforcement, a command palette, the in-app roadmap, and the always-on home server the whole crew runs from. Not a prototype. A real tool.
組
Shipped
Core Agents
Mei · Ren · Haku · Ryū
The four that make the crew work WebCenter. Ren authors every scripting and config context, versioned and diffable; Haku takes it live and documents it, with two-way sync and Azure DevOps publishing; Ryū runs the whole thing overnight on his own agenda; Mei answers from years of real craft, her platform arc still ahead. The working WebCenter crew.
透
Shipped
Tōshi
the seer
The inspector, grown from Haku's eye into an operative of her own. One click X-rays any WebCenter page (every nested dashboard, search and form, each a link to its editor), walks the full reference graph, and packages the logs support always asks for. Shipped as a KG panel and a Chrome Web Store extension.
The crew past WebCenter. Chō sits in a call and transcribes it on-device, nothing leaving the machine; Sumi files the result into a durable per-customer record that feeds the next build and fires action items into Azure DevOps; Ei is the judgment layer, the go / no-go before the crew commits. Ear, ink, and counsel.
伝書
Live
Densho
the scroll
The crew's own scroll of WebCenter craft. Thirteen flagship solutions, each carrying its real deployed code, design notes and a live rendered preview: browse an entry, tailor it, and deliver it into a customer's WebCenter under the live-data guardrails. The scroll Sae is trained on.
A WebCenter-native workflow editor built inside KG on a block canvas: drag blocks loaded with real config, not dumb shapes. The north star: design a workflow live in a customer workshop, then push it straight to WebCenter without redrawing it. Read-only rendering runs today; editing and round-trip export are being built.
工房
Parallel track
Kage-gumi Studio
design to deploy
A separate release track that turns KG into a WebCenter build platform: design a project as work items, let Ren execute each one, Ryū runs the queue overnight, and colleagues join with their own Claude tokens. The design-to-deploy loop, fully automated.
The far horizon: the crew's own mind. An LLM that speaks WebCenter natively, trained on the crew's accumulated craft and the Densho scroll. The moment the crew stops renting intelligence and starts owning it.
The public docs flow in automatically. The depth is added by hand.
The crew already harvests public documentation on its own: Esko's knowledge base, the product manuals, the release notes, all pulled in and folded into the skill files automatically. What a human adds on top is the fine-tuning, correcting what's wrong and feeding in the deeper, hard-won detail that isn't written on any public page.
So every WebCenter release brings the published docs in automatically. But the in-house knowledge (the script patterns that actually work, the edge cases solved in the field, the prompt context that makes Mei and Ren good at their jobs) still has to be written in deliberately.
The crew is only as good as what they've been taught. The public half keeps itself current; the expert half is an ongoing commitment, part of the job, not a one-time setup.
The horizon
Where this is going その先へ
Kage-gumi today is a working crew. The vision past it is a single trajectory in three steps: the crew stops being a tool and becomes a platform, a body of owned craft, and finally a mind of its own. The three sections that follow are that arc.
01 · Platform
工房 Studio
KG becomes a WebCenter build platform: projects designed as work items, built by operatives, deployed in one motion.
→
02 · Corpus
伝書 Densho Live
Built and running: an owned, growing scroll of Esko craft. Browse a solution, tailor it to your build, and deliver it into a customer's WebCenter, guardrail-bound.
→
03 · Mind
冴 Sae
The scroll becomes a mind: the crew's own model, trained on that craft, that speaks WebCenter natively.
Densho 伝書 is the written scroll; Sae 冴 is the mind trained on it. The middle step has already landed: Densho is built and running (see below). Studio is in motion; Sae is the far end of the road: the crew's own Esko LLM, and the ambition this whole system is pointed at.
New direction
Kage-gumi Studio 工房
Kage-gumi started as a personal AI assistant for daily WebCenter work. Studio is what it becomes next: a WebCenter build platform, where entire projects are designed as work items, operatives execute each one, and the result is deployed into WebCenter and committed to the codebase in the same operation.
Think Azure DevOps. Without the overhead. Your backlog is executed by AI, your build pipeline is Ren, and your overnight CI is Ryū.
// Live now · colleagues can use it todayShipped
Ask the crew from Azure DevOps: the case comes back answered
A colleague opens an Azure DevOps work item asking KG for help. The crew picks it up, works the case confined to that build and that customer, then writes the answer straight back into the work item and updates the case: no new tool to learn, the request and the reply both live in DevOps. Every assist is recorded to a running ledger. This part isn't a plan. It's running now.
01 · Design
Work Items
Describe what you want to build. Ren helps break it down into executable tasks. Plans are reviewed before anything runs.
→
02 · Execute
Operative Build
Ren picks up each item, generates the artifact, and returns it for review. Overnight, Ryū batches the whole queue automatically.
→
03 · Deploy
Live + Versioned
Accepted artifacts deploy into WebCenter via Playwright and commit to the repo. For workflows, a Miro process diagram is created automatically alongside the deploy. Haku documents each deployment. Full traceability.
// The design surface · in build図案In progress
Zuan: where a Studio workflow gets designed
Studio needs a place to design a build, not just queue it, and for anything workflow-shaped that place is Zuan, KG's WebCenter-native block editor. Diagram a workflow live on the canvas (in a customer workshop, even), then push it straight into WebCenter without redrawing it in the WC canvas, or pull an existing workflow back in to edit. As Studio matures, Zuan becomes its visual front end for the 01 · Design step: the throwaway Miro sketch replaced by a diagram the crew can actually deploy.
Work item system
User stories, tasks, features: stored in Studio with artifact type, status, and implementation plan. Kanban board, project grouping, dependency tracking. No separate tool needed.
Operative execution
Each work item is dispatched to an operative. Ren builds, Haku documents, Ryū runs the overnight queue. For workflow artifacts, a Miro process diagram is generated alongside the deploy automatically. Review step before anything goes live.
Overnight builds
Load up the queue before you leave. Ryū runs each item in order overnight, respects the token budget, and surfaces the results in the morning digest. Wake up to a built system.
Colleague access
Colleagues can participate, using the shared token pool or connecting their own Claude API key. Per-user caps, work item assignment, activity feed. The system scales beyond one person.
// Studio release track
liveshipped
Colleague Case Intake · Azure DevOpsColleagues request help via a DevOps work item; KG works it guarded to the build + customer and writes the answer back into the case
v0.1next
Work Item FoundationSTUDIO tab, work item board, status tracking, item drawer
v0.2planned
Design ModeRen helps break down and plan each item before execution
v0.3planned
Operative ExecutionDispatch → build → review → deploy in a single task flow
v0.4planned
Ryū Overnight BuildBatch queue execution while you sleep, morning digest integration
v0.5horizon
Colleague AccessShared token pool or own API key, per-user caps, activity feed
Built · live now
Densho 伝書
A densho is the scroll a school keeps to record its techniques and pass them to the next generation. This one is built and running. Densho is the crew's own library of reusable WebCenter solutions: each entry carrying the real deployed code, the design notes, the acceptance criteria, and a live rendered preview of the widget it paints. Thirteen flagship solutions are in the scroll today.
Densho is built to tailor an entry to your build and deliver it straight into a customer's WebCenter: a frozen original regenerated for your customer, your statuses, your attributes, then pushed in under the crew's live-data guardrails. The catalog is designed to become a generator, not just a shelf. (The tailor-and-deliver path is built; proving it end-to-end on a second build is the next step.)
01 · Browse
Open the entry
The real code, the design notes, the acceptance criteria and a live preview of the widget: one governed card per solution.
→
02 · Adapt
Tailor to your build
KG reads the code and the matching skill, infers what's build-specific, asks a few surgical questions, and regenerates the script for you.
→
03 · Deliver
Push it in, guarded
The tailored script is dispatched into the customer's instance through Haku's existing tools, under the live-data guardrails.
The scroll, browsable: thirteen real solutions, filterable by category, tier, use level and customer. Every entry is a technique the crew has actually forged and deployed.Open an entry to its code, quality notes and governance. The Workshop bar is built to tailor it to your build, then deliver: AUTO into a writable dev/test estate, MANUAL (Steven-only) to production, and never into a read-only instance. The push inherits the same live-data guardrails as every other write the crew makes.
Every entry ships a live render of the widget it paints: here, the process-steps flow rail across its module variants.Adapt to my build treats each entry as a frozen original and regenerates it for your context: no per-entry authoring, it infers the adaptation surface live.
The library grows by reach: the crew connects to customer WebCenters, harvests the reusable solutions already living there, and folds each one into the scroll. Owned end to end, inside Kage-gumi, never a customer system, and written in our own voice.
The ultimate goal
Sae 冴
This is the ambition the whole system is pointed at.Sae is the clarity of a mind that sees straight through: sharp, lucid, unclouded. Sae is the crew's own model: a language model that speaks WebCenter natively, trained on the craft Kage-gumi has been forging all along. Densho 伝書 is the written scroll; Sae is the mind trained on it.
The grounded path doesn't build from scratch: it stands on an open model and teaches it WebCenter. Sae is the practical kind of "our own LLM": grounded in our own Esko knowledge today, distilled into weights we own and run on the box tomorrow. The craft, made into a mind. And past that practical horizon sits a wilder dream, below.
01 · Gather
The corpus we already make
Every script, its doc and its test; Densho, the skills, the WebCenter knowledge. KG has been manufacturing a clean Esko dataset all along.
→
02 · Distil
Ground it, then teach it
First an Esko brain that answers grounded in that corpus. Then a curated training set: requirement → script, script → doc, error → fix.
→
03 · Own
A model that's ours
A fine-tuned open model that speaks WebCenter: runs on the box, offline, no per-token cost. Every new build feeds the next round.
Grounded now
The first step ships fast: answers drawn from our own WebCenter corpus, not a generic model guessing. Useful long before any training run.
Ours, offline
Weights we own, running on the home box: no per-token bill, no dependency, works air-gapped. The craft kept in the house.
A second, not a replacement
Sae is narrow and sharp where Claude is broad and deep. A router sends the routine to Sae, the hard reasoning to Claude. Two minds, one crew.
// The far dream冴零someday, maybe
Sae Zero: a mind built from nothing
The grounded Sae stands on a giant's shoulders: an open model someone else trained on the whole internet. The dream past it is Sae Zero: a model raised from random noise on our own machine (our own tokenizer, our own architecture, our own hands on every layer), owing nothing to anyone. Not because it would be better (it wouldn't, not for years), but because building a mind from zero is the kind of thing worth wanting.
Said plainly as a dream, not a date on the roadmap. The craft, taken all the way down.
影組
Questions?
"You don't need to be into AI to find this useful. You just need WebCenter work that's taking more time than it should."
This presentation was researched, written, and designed by Kage-gumi. Haku handled the words. Mei checked the facts. Ren built the thing you're looking at. The crew presents itself.
