Seigyo

• 

• 

• 

• 

• 

• 

• 

• 

Inspiration

Production incident response is fragmented. Operators jump between monitoring dashboards, logs, deployment records, service maps, runbooks, and customer reports while an outage continues to affect users.

AI agents can help investigate this information, but recovery introduces a serious safety problem. An agent should not make a production change simply because it found a likely cause. A human must understand and approve the exact intervention.

Seigyo explores a better collaboration model: the agent investigates and verifies, while the human keeps control of consequential actions. Seigyo is the Japaese word for control.

What it does

Seigyo is a human-governed incident investigation and recovery console powered by WebMCP.

A browser agent can use structured tools exposed directly by the application to:

• List and inspect incidents
• Query service metrics
• Search operational logs
• Review deployments
• Map service dependencies
• Correlate evidence and identify likely causes
• Prepare a specific recovery proposal
• Execute an approved intervention
• Verify recovery against the customer path
• Reverse an intervention when necessary

Every tool call is shown in an animated Agent Console using clear activity labels such as “Searching logs” and “Verifying recovery.”

Before a recovery action can run, Seigyo presents the human with the exact action, target, evidence, expected effect, risk, and expiry. Approval grants permission only. The agent must still call the execution tool and then verify the result.

MyShop is a connected storefront used to demonstrate the complete customer impact loop. A faulty checkout release creates a real incident in Seigyo. After the agent investigates and the human approves the recovery, the storefront becomes healthy and the customer can complete the same purchase.

The storefront is only one example. The same interaction model can support infrastructure operations, security response, data systems, internal platforms, and other environments where agents need structured access with human control.

Why WebMCP

WebMCP allows the visible application and its agent interface to exist together.

Instead of making the agent interpret screenshots or rely on hidden automation, Seigyo exposes explicit tools with typed inputs and structured results. The operator can continue using the normal interface while the agent works through the same live environment.

This makes the interaction clearer for both sides:

• The agent receives reliable operational data.
• The human can see what the agent is doing.
• Approval happens inside the relevant application.
• Recovery remains bound to the exact incident and action.
• The agent can verify whether the customer-facing problem was actually fixed.

This kind of live, browser-native collaboration would be difficult to deliver through a traditional dashboard alone.

How we built it

The Seigyo and MyShop interfaces are built with React, TypeScript, Vite, and Tailwind CSS.

The operations API runs on Cloudflare Workers. Persistent environment state is stored in a SQLite-backed Cloudflare Durable Object, which provides a serialized boundary for incidents, services, deployments, metrics, logs, approvals, executions, carts, and orders.

WebMCP tools are registered through document.modelContext.registerTool. Each tool has a defined input schema and an asynchronous execution callback connected to the operations API.

Shared TypeScript contracts and Zod schemas keep the browser tools, interfaces, and backend aligned. WebSockets distribute operational changes so Seigyo and an already-open storefront remain synchronized.

Recovery approvals are short-lived and bound to the operator session, proposal, action, and current causal state. Execution is idempotent, stale approvals are rejected, and completed interventions produce verifiable recovery records.

The environment models connected services and causal behavior. Correct interventions restore the affected customer path, while unrelated actions do not magically resolve the incident.

Challenges we faced

The hardest challenge was designing human approval without turning it into a decorative confirmation button. Approval had to authorize one precise action while keeping execution and verification under the agent’s control.

We also had to keep multiple browser surfaces synchronized, preserve the customer’s cart during an outage, prevent stale or replayed approvals, and make repeated demonstrations deterministic without deleting operational history.

Another challenge was presenting service dependencies clearly across different screen sizes. The topology now calculates every connection from the measured card positions instead of relying on fixed SVG coordinates.

Accomplishments

We built an end-to-end incident story that starts healthy, introduces a checkout regression through a new release, exposes the resulting customer failure, supports evidence-based agent investigation, requires exact human approval, executes a reversible recovery, verifies multiple healthy samples, and ends with a successful customer purchase.

The normal interfaces remain usable without WebMCP, while WebMCP adds a structured collaboration layer for agents.

What we learned

The strongest use of WebMCP is not simply giving an agent more buttons. It is giving the agent a precise operational contract while keeping important human decisions visible and enforceable.

We also learned that recovery should be measured from the customer path, not merely from whether a command returned successfully.

What's next

Next, Seigyo could connect to real monitoring, deployment, ticketing, and change-management systems. The same approval and verification model could also support security response, database operations, infrastructure maintenance, and other high-impact workflows.

Built With

• cloudflare
• css
• durable
• hono
• motion
• objects
• playwright
• react
• recharts
• router
• sqlite
• tailwind
• typescript
• vite
• vitest
• webmcp
• websockets
• workers
• zod