Guild Mission Control

A VS Code extension that is a single pane of glass for the Guild.ai agent platform — see your entire universe of workspaces at a glance, drill into any agent to understand what it's doing, and put a number on the ROI.

Built entirely on the Guild CLI (guild … --mode json): no extra services, no API keys beyond your existing guild auth login.

What you get

🌌 Universe view (the landing page)

One card per workspace across your whole account: running/error badges, recent-session counts, and 7-day activity sparklines. Workspaces that are quietly burning failed runs show up red before anyone thinks to look. Click a card to drill in.

📊 Workspace dashboard

• Agent grid with live-session indicators, per-agent 7-day run sparklines, and search.
• Activity feed of recent sessions — click through to a full session timeline.
• Flows — one row per agent that reads as a sentence: what triggers it → the agent → what it produced (runs/errors over 7 days, sparkline, last run status). Dormant agents are visibly dormant.
• Failing-trigger detection — a schedule whose recent runs all errored gets a red banner with one-click deactivate, plus a status-bar warning.

🔍 Session detail

Event-type-aware timeline (user / trigger / agent / runtime / LLM / console / error rows, each in its own visual language), live tail while a session runs, an in-panel composer to message the session, interrupt button, and raw JSON for debugging.

🤖 Agent detail

Versions with validation status, build logs, "latest run in the agent's own words" (statuses can say DONE while the agent said REJECTED — the message is the truth), an hour-of-week activity heatmap, systems the agent touches (reads vs. writes per integration), recent sessions, and run stats.

💰 ROI

Give any agent a value model — minutes of human work saved per successful run — and get:

• an ROI card on the agent (hours + dollars over 30 days, at your configurable hourly rate),
• a universe-level rollup (total savings, top agents),
• Guild: Export ROI Report — a shareable markdown table.

Session history is backfilled across all workspaces on startup, so the numbers reflect what actually ran — not just what VS Code happened to observe. Token cost has a reserved slot for when the platform starts reporting token_usage.

Agents that end their final message with a fenced ```guild-metrics block (one flat JSON object of business counters) get business-impact tiles: aggregated metrics on the agent detail page, impact chips in the universe ROI rollup, and a Business impact section in the exported ROI report.

🧾 Accountability: who ruled on what

ROI measures what an agent produced. It cannot see whether a human did anything with it — a run that succeeds and lands in a channel nobody reads has a real value of zero and still shows as $75. The receiver layer records the missing half.

Every finished session gets a human ruling — Acted, Monitoring, Not material, or Disagree — from one click on the session-end notification, from the session detail panel, or from the pending queue. Rulings are appended as one JSON line each to a ledger file you designate (guild.ledgerPath). Nothing is written anywhere until you set that path, and with no path set the extension behaves exactly as it did before.

Three figures then appear on the ROI card, the universe rollup, and both exports:

• Realization — of successful runs, the share a human ruled acted. The honest number: what share of what the fleet produced was actually used.
• Independent realization — the same rate counting only rulings where the person ruling was not the person who started the run. A solo developer ruling on their own agent is legitimate, so it is flagged, never blocked — this is the figure that says how much of the record is independently checked.
• Coverage — the share of successful runs carrying any ruling at all. Coverage always travels with realization, because a low rate at 20% coverage and a low rate at 95% coverage are opposite findings.

The greyed "not yet reliable" tag. Below guild.realizationCoverageFloor (default 0.5) the realization rate renders greyed and tagged rather than as a confident figure — in the UI and in the exports both, so a number that is not trustworthy on screen cannot become trustworthy by being pasted into a document. It means: too few of your successful runs have been ruled on for this percentage to mean anything yet. Rule on more of them and the tag clears.

Alongside it:

• Owner — guild.agentOwners names one accountable human per agent, shown on the agent and session panels. Agents with nobody accountable are badged unowned, and failure alerts route to the owner (guild.intake sets that owner's own floors) as well as to anyone subscribed via guild.watchAgents.
• Validation state — declared (the platform status alone), validated (the agent's own final message does not contradict it), verified (a human ruled on it).
• Ledger location — the ROI card says plainly whether rulings are visible to anyone else, verified from git rather than self-reported: Shared, Shared · 2 unpushed, Shared · never pushed, or a standing warning that the ledger is local (or ignored) and cannot do the job a ledger is for.
• Skips — "stop alerting on this class" is itself a ruling, so it records who, why, and when it lapses. There is no "never"; a lapsed skip raises one notification rather than silently resuming.

Commands: Guild: Disposition This Session, Guild: Disposition Pending Outcomes (walks the queue; Escape ends the walk), Guild: Stop Alerting on This Class, Guild: Set Agent Owner, and Guild: Export Decisions Report — one row per ruling plus realization, coverage, orphan rate, and every active and lapsed skip.

Known limitation. The "validated" badge rests on a keyword heuristic for an agent contradicting its own declared success, so it produces false positives (and misses): an agent that says "could not reach the cache, used the fallback" reads as a contradiction when it is not. Treat validated as a prompt to look, never as a verdict. Receipts therefore store the agent's verbatim final words rather than the conclusion drawn from them — when the heuristic improves, every historical receipt re-derives with it. Where those words could not be read at all, the receipt says so instead of recording silence.

🛠 Act, don't just observe

Re-run a finished session with its original input, Debug with AI (assembles the failure context into a prompt for your editor's AI chat), diagnose failed sessions by clustering shared error reasons, and get alerted on missed schedules (a trigger that silently stopped firing) and week-over-week success-rate regressions.

✍️ The authoring inner loop

Clone any agent with full git history (VS Code's native timeline/diff views show version changes), run it once with a prompt, then save & publish a new version — all without leaving the editor. Pin ★ / hide ✕ workspaces to curate a large universe, and a native getting-started walkthrough onboards new users.

🔔 Live operations

Adaptive polling (3s while sessions run, configurable at rest), completion/failure notifications that include the failure reason, Guild: N running status-bar item, workspace picker, and an onboarding flow when the CLI is missing or logged out.

Install

Install Guild Mission Control from the VS Code Marketplace (search guild-mission-control, publisher SeawolfAI), or:

code --install-extension seawolfai.guild-mission-control

Prefer a specific build? Grab the .vsix from Releases and:

code --install-extension guild-mission-control-<version>.vsix

Prerequisites: the Guild CLI on your PATH (or set guild.cliPath) and guild auth login completed.

Settings

Build from source

npm install
npm run compile     # typecheck + esbuild bundle
npm test            # pure-logic unit tests (node --test)
npm run package     # produce the .vsix

Press F5 with this folder open to launch an Extension Development Host. CI runs typecheck/tests/build on every push; tagging v* publishes a GitHub Release with the packaged .vsix.