Steven Leysen · Personal Presentation · 2026
// Steven Leysen · What I've been building

影組

Kage-gumi · Shadow Crew

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

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.
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
Losing track of what each AI agent is working on
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
With Kage-gumi
Ask Mei, the WebCenter support operative, in plain language
Ren generates, versions, and stores scripts with diffs
Dashboard shows all operative tasks and status at a glance
Haku writes documentation automatically as builds happen
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

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 — answering the same questions I would, without me in the loop.

Real scenarios the crew handles:

Scenario 01
KG-01 Mei · 明
"How do I set a WebCenter attribute via SDK?"

Instead of hunting through docs, I ask Mei. It knows the full JSP call library: SetAttribute.jsp, GetAttributes.jsp, the right parameters, the XML response structure, and gives me working code immediately.

Scenario 02
KG-02 Ren · 錬
"Build a display script that shows me status progression of a project"

Ren builds Dashboard scripts, Rule Engine scripts, Workflow JavaScript node scripts. Built around WebCenter — each context has different APIs and constraints, and Ren knows them all. Scripts come back versioned and diffable, and Ren pushes them straight into WebCenter himself — no copy-paste step.

Scenario 03
KG-03 Haku · 博
"Document this workflow — and find what we already have on it"

Haku documents what was just built, but also surfaces what already exists: existing scripts, prior configurations, related workflows. She can read a live WebCenter artifact via Playwright and write a functional spec from what she actually sees. Output is clean, shareable, Azure DevOps–ready.

Scenario 04
KG-04 Ryū · 龍
Run overnight batch tasks

Ryū runs scheduled tasks while I sleep, processing queued scripts and delivering a morning digest of everything that happened.

Scenario 05
KG-05 Chō · 聴
"Capture this customer call and turn it into something I can use"

Chō listens to the meeting and transcribes it locally with faster-whisper — nothing leaves the machine — then returns a structured summary: decisions, action items, open questions. Meeting knowledge becomes reusable project text the rest of the crew can act on.

Scenario 06
KG-06 Sumi · 墨
"File that meeting under the customer, for good"

Once Chō has summarised, Sumi files it into a durable per-customer record. Tag the meeting to a customer and it's archived into a clean dossier that outlives the call — faithful and factual, never inventing an attendee or a date.

Scenario 07
Tōshi · 透
"What's actually on this page — and where do I go to edit it?"

The pain everyone who touches WebCenter knows — customers and developers alike: you're on a page with no idea which dashboards, saved searches and forms are nested inside it, so you go digging through the system to find out. Tōshi X-rays the page in one click — the whole nested structure laid out, every item a direct link to its editor. The searching just stops.

Current operative statuses:

明
KG-01 · MEI
Active
錬
KG-02 · REN
Building
博
KG-03 · HAKU
Idle
龍
KG-04 · RYŪ
Scheduled
聴
KG-05 · CHŌ
Listening
墨
KG-06 · SUMI
Filing
透
THE EYE · TŌSHI
Watching
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.

KG-01
明
Mei
Support Agent
Esko / WebCenter
"Bright": clarity, illumination
Knows the full WebCenter SDK: every JSP endpoint, every attribute, every error pattern. Ask in plain language, get working answers. Mei prepares the ground before anything else happens.
KG-02
錬
Ren
Builder
Scripts & Frontend
"Tempered": forged, refined
Built around WebCenter — Workflow, Rule Engine and Dashboard scripts, plus integration and migration specs and Workato recipes & diagrams. Each context has its own rules and Ren knows them all. And Ren doesn't stop at writing the code: he uploads scripts straight into WebCenter himself, no copy-paste step. Everything is saved, versioned, and diffable. Tempered by the work — refined until it holds.
KG-03
博
Haku
Deploy & Doc
Sync & Docs
"Sound of jewels": clarity, precision
Turns messy work into clean documentation, then pushes the work itself live. After Ren builds something, Haku writes it up (what it does, what it touches, how to use it) and deploys scripts straight into WebCenter via Playwright. Searchable, shareable, stored. The inspector's eye she first opened — Tōshi — has since grown into an operative of her own (see her card).
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ū.
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.
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 — a clean dossier that outlives the call. Tag a meeting to a customer and it's archived for good. Faithful, factual, never invents an attendee or a date.
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.
See Tōshi in action — the manual & feature guide ↗
Under the hood

Three layers, one system

There are three technologies that make this work. Each one has a distinct job and they stack cleanly.

LLM Large 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.

MCP Model 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.

CLI Command 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.

YOU Me → Dashboard give Mei a task
OPR Mei loads system prompt + memory KG-01
LLM Claude API thinks WebCenter knowledge active
MCP Reaches into real tools WebCenter / Miro / Azure DevOps
OUT Result surfaces in dashboard task complete
In practice

What it looks like

Real screenshots of the running system — not mockups, not demos.

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. Each version adds depth to an existing operative or introduces a new one. The crew grows deliberately, not all at once.

Last updated: 2026-06-11
v0.1 shipped
Core Dashboard + KG-01 to KG-04
Mei, Ren, Haku, Ryū, live in the dashboard. Real API calls, token budget enforcement, task chaining, memory panel, operative chat.
v0.2 shipped
Real data wiring + UI polish
Live task data, breathing room, typography, header, card refinements. The dashboard starts feeling like a real tool rather than a prototype.
v0.3 shipped
Crew Chat
claude CLI operative intelligence. Crew Chat routes your message to the right operative, spawns a real claude subprocess, and streams the response live into the dashboard.
v0.4 shipped
Ryū scheduler
Morning digest, overnight task runner, multi-schedule support.
v0.4.1 shipped
Roadmap page
In-app roadmap, live from docs/. The release plan renders directly inside KG web — Ryū's audit timestamps update it automatically on each nightly run.
v0.5 shipped
Ryū: Real Missions
Ryū's overnight runs get actual work. Mission briefing system, real context injection from the last 24 hours of tasks and logs, structured morning digest with warnings and recommendations. Optional WebCenter health ping.
v0.6 shipped
Haku: Playwright Documentation
Haku navigates to a live WebCenter artifact via Playwright, extracts its real structure, and writes a functional spec from what she actually sees — not from memory. Output in Azure DevOps format, saved to a doc library.
v0.6.1 shipped
Haku: Dashboard Script Sync
Haku pushes edited dashboard scripts directly into WebCenter via Playwright — no manual copy-paste. Every edit in the repo lands live on the server in a single automated step.
v0.6.3 shipped
Git Integration (Ren auto-push)
Ren commits and pushes generated scripts to the repository automatically after every task. Codebase and Claude Code stay in sync — no manual push step required.
v0.6.4 shipped
Chō: Meeting Listener — a new operative (KG-05)
Chō captures a meeting's audio, transcribes it locally with faster-whisper — nothing leaves the machine — and returns a structured summary (decisions, action items, open questions) via the claude CLI. Live capture panel in the dashboard. Meeting knowledge becomes reusable project text the rest of the crew can use.
v0.6.5 shipped
Sumi: Record-Keeper (KG-06) + operative-nested views
Sumi joins as a full operative — the ink to Chō's ear, filing finished meetings into durable per-customer records. The dashboard reorganised around the operative: Docs (Haku), Proposals (Ryū), Chō and Sumi now live as sub-tabs inside AGENTS, surfaced when you select the operative who owns them. The two personal operatives (Ichikawa, Tetsu) became numberless.
v0.6.6 shipped
Ryū: Proposals — the night-runner sets his own agenda
Ryū no longer just runs the queue — he proposes the work. The PROPOSALS panel lists overnight improvements he's surfaced (target, type, status). Click Launch and the proposal becomes a real, tracked dashboard task (T-PROP-…), mirrored in lockstep — launch → queued, applied → complete, skip → dismissed, un-launch → removed. No duplicates, fully reversible.
v0.6.7 shipped
Chō → Sumi: the meeting pipeline, closed end to end
The ear-to-ink loop now runs all the way through. A meeting's final summary links straight into Sumi's ledger, files to a per-customer dossier (private, never committed), and exports as a branded PDF you can hand over. Summaries are hardened for long calls, and meetings or customers can be managed and removed right from the panel.
v0.6.8 shipped
Ren: Playwright Deploy — scripts
The immediate necessity, live today: Ren pushes the two script types he writes most — Dashboard scripts and JavaScript Rule Actions — straight into WebCenter via the canonical Playwright sync, automatically after every edit. Generate → save → live, no copy-paste. Creates a new script if it doesn't exist yet, edits it in place if it does.
透 v0.6.9 shipped
Tōshi: Dashboard Inspector — Haku lifts the veil
A new eye for Haku. Tōshi ( — "seeing through") reads what any WebCenter page is actually built from. Scan inventories every dashboard, saved search, task page and attribute category on a page; Graph walks a dashboard's full reference tree — sub-dashboards, buttons, embedded searches — and flags anything that's been deleted. Point it at a page and the whole hidden structure shows — in the KG panel, or as a one-click Chrome extension that highlights any node on the page and reverse-locates from a click (透 II). Lift the veil.
聴 v0.6.10 shipped
Chō: back-to-back meetings + the silence cutoff
Two refinements for the ear. Back-to-back capture — while a meeting's summary is still being written, Chō detaches it to finish in the background so you can start recording the next meeting straight away; a chip tracks the previous summary until it lands in Sumi. The silence cutoff — leave her running and walk out: if no one speaks for a set stretch (default 30 minutes), she wraps up on her own — graceful stop, summary, saved. It's measured from the last spoken word, so ambient noise or hold music never keep her awake. She knows when the room has gone quiet.
v0.7 planned
Ren: Playwright Deploy — full coverage
Extend the deploy beyond scripts to the rest of the surface — workflows & task types, users & groups — and wrap it in a one-click in-dashboard loop: generate → review → confirm → deploy, all from KG web. The codebase and WebCenter update together, with rollback-by-copy before any destructive edit.
v1.0 horizon
VPS deploy + remote access
Docker + nginx + Let's Encrypt. Check in on Ryū's overnight runs from a phone. Single-user remote access — no multi-user complexity needed, no login UI. The system works exactly as intended for one operator.
v3.0 horizon
Mei-in-a-Box: customer support bot
After a build, hand the customer their own Mei — a single-operative, customer-branded deployment that answers their team's WebCenter questions in plain language, grounded in that customer's own solution plus the support playbook. The rest of the crew stays internal; each instance is isolated with its own auth. Support that ships with the build, no consultant in the loop.
// Parallel track 工房
Kage-gumi Studio — a separate release track launching alongside the main plan

Studio 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 can join with their own Claude tokens. The design-to-deploy loop, fully automated. See the Studio section below →

// Important: what Haku doesn't do automatically
The underlying knowledge still needs a human every release.

Haku can write documentation beautifully, but only from what she's given. The deeper layer (the skill files, the WebCenter SDK patterns, the prompt context that makes Mei and Ren actually good at their jobs) has to be maintained by hand.

Every time WebCenter ships a new release, every time a new script pattern is discovered, every time an edge case is solved, that knowledge needs to be written into the system deliberately. It doesn't flow in automatically.

The crew is only as good as what they've been taught. Keeping that current is an ongoing commitment, part of the job, not a one-time setup.

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ū.

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.
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
v0.1 next
Work Item Foundation STUDIO tab, work item board, status tracking, item drawer
v0.2 planned
Design Mode Ren helps break down and plan each item before execution
v0.3 planned
Operative Execution Dispatch → build → review → deploy in a single task flow
v0.4 planned
Ryū Overnight Build Batch queue execution while you sleep, morning digest integration
v0.5 horizon
Colleague Access Shared token pool or own API key, per-user caps, activity feed
On the horizon

Densho

A densho is the scroll a school keeps to record its techniques and pass them to the next generation. Densho is the crew's own version — a living library of every reusable WebCenter solution we've forged: the design notes, the working script, how to test it, where it fits. Browse it, pull a solution straight into a build, or file a new one.

The crew's accumulated craft, owned outright and written in our own voice — growing every time an operative builds something worth keeping.

01 · Forge
Build it
An operative builds a reusable solution — a script, a workflow, a config — as part of real work.
→
02 · File
Into the scroll
It's documented and filed into Densho — design notes, the working code, how to test it, where it fits.
→
03 · Reuse
Pull it back
Next time the need comes up, lift it straight from Densho into the next build.
Browse & pull
Search by category, use level or version. Open an entry to its design notes, code and acceptance criteria — and lift it straight into the next build.
Author & contribute
Add a new solution through a simple form. Operatives file what they build, so the library grows itself — no separate catalog to maintain.
Ours, end to end
Lives inside Kage-gumi — not a customer system. Seeded by what we've genuinely built. A later step can publish an entry out into a WebCenter on demand.
影組

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."

// Architect
Steven Leysen
Mei · WebCenter Support Ren · Builder Haku · Deploy & Doc Ryū · Overnight Chō · Listener Sumi · Records Tōshi · Inspector Tetsu · Wrench
影組
// Task log · KG-03 HAKU · status: complete
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.