Verified Mission Control

Goal Contracts for the Agent-Native Web

Comment

Verified Mission Control

Tagline: Goal Contracts for the Agent-Native Web

Live: https://verified-mission-control-webmcp.vercel.app

Code: https://github.com/chuangmenghuan-wq/verified-mission-control-webmcp

Short description

A WebMCP-native decision control plane that lets agents explore and repair plans autonomously while humans retain authority over meaningful trade-offs and irreversible actions. Mission Control is the reusable product; Sensor Fulfillment and Production Deployment are interchangeable demo adapters.

The problem

Giving an agent tools is not the same as giving it safe authority. Real goals often have competing constraints: cost, time, specification, risk, and irreversible commitment. An agent may find many technically possible actions, but the user should not have to review every micro-decision—and the agent should not silently relax the goal.

Verified Mission Control adds a goal-and-authority layer between the human and WebMCP tools. It is designed for enterprise operations and product teams that want agents to handle high-impact workflows without turning every micro-decision into a human approval bottleneck.

What it does

The human locks a machine-readable Goal Contract. The agent explores options, generates candidate plans, verifies them against the original constraints, and compresses the meaningful trade-offs into a small Human Decision Package.

A human decision creates a bounded authority envelope. The agent can then repair execution autonomously as long as the repaired plan stays inside that envelope. Final irreversible commitment is blocked until explicit human approval.

The final Evidence Receipt records the goal, plan compression, human decision, disruption, repair, final approval, and verified outcome. Completed missions are stored as hash-chained provenance runs that survive page refresh and can be integrity-checked and replayed read-only.

Why WebMCP is essential

WebMCP provides the typed action surface that makes this governance loop machine-readable and directly executable by agents. The app registers nine native tools with document.modelContext.registerTool(...), and the guided experience executes them with document.modelContext.executeTool(...) when WebMCP is available.

This is materially different from brittle UI automation: the agent gets explicit tools for reading the goal, discovering options, generating and verifying plans, requesting human judgment, repairing within authority, requesting final approval, committing, and reading evidence.

What humans and agents can do together

The agent can explore a large solution space and handle routine repair without repeatedly interrupting the user. In the deterministic judge path, 7 candidate plans become 3 meaningful trade-offs, and the complete workflow requires only 2 human decisions: one bounded trade-off authorization and one final irreversible approval. The human only decides the trade-offs that genuinely change authority—for example: keep the deadline, keep the exact specification, but allow a larger budget.

After that decision, the agent can continue on its own inside the approved envelope. If conditions change, it preserves valid progress and repairs only the remaining gap. The human is brought back only when a new judgment is required or when the workflow reaches an irreversible boundary.

Two domains, one engine

Supplier fulfillment is a demonstration scenario, not the product. The same generic Decision / Policy Engine also runs a production deployment scenario with completely different constraints: completion, downtime, change cost, and rollback safety.

Both scenarios use the same nine WebMCP tools, the same decision-frontier compression, the same authority model, the same bounded repair logic, and the same provenance system. Domain behavior lives in configuration, not duplicated control logic.

Implementation

Core modules:

  • decision-engine.mjs — generic constraint evaluation, decision-frontier compression, authority envelopes, and bounded repair selection.
  • scenarios.mjs — domain configuration for Sensor Fulfillment and Production Deployment.
  • app.js — WebMCP registration/execution, human-only authority actions, UI state, and evidence flow.
  • provenance-store.mjs — browser-persistent append-only runs with SHA-256 hash chaining, verification, and read-only replay.

The public repo includes dependency-free Node tests and a production acceptance harness that launches a temporary WebMCP-enabled Chrome profile and verifies the live site end-to-end.

Representative WebMCP enforcement

{ name: 'commit_plan', inputSchema: emptySchema, execute: toolCommitPlan }

await document.modelContext.registerTool(toolDefinition);

if (!state.finalApproved) {
  return { ok: false, error: 'FINAL_COMMIT_APPROVAL_REQUIRED' };
}

Human authorization itself is deliberately not registered as a WebMCP tool. The agent can request a human decision, but it cannot call a tool that grants itself authority.

Reproducible evidence

node --test tests/*.test.mjs currently passes 8/8 tests.

node scripts/verify-production-native-webmcp.mjs verifies the live Vercel deployment: nine native WebMCP tools, both human authority gates, both domains, bounded repair, GOAL_ACHIEVED, reload persistence, read-only replay, and provenance-chain integrity.

What is demonstrated vs. production hardening

The competition app uses deterministic scenario data so judges can reproduce the same authority and recovery path without credentials or side effects. It does not place real orders or deploy real infrastructure.

Provenance is browser-persistent and tamper-evident through a SHA-256 hash chain, but it is not externally signed or cross-device attested. A production deployment would add authenticated identities, server-enforced policy, enterprise adapters, and externally anchored evidence.

60-second judge path

  1. Open the live URL in WebMCP-enabled Chrome or ChatGPT's in-app browser.
  2. Run the decision demo and watch the native WebMCP execution trace.
  3. See seven candidate plans compress to three meaningful trade-offs.
  4. Authorize one bounded exception; watch the agent repair a later disruption without reopening every decision.
  5. Observe FINAL_COMMIT_APPROVAL_REQUIRED before the irreversible action.
  6. Approve the final commitment and inspect the Evidence Receipt.
  7. Refresh the page, then verify and replay the persisted provenance chain.
  8. Switch to Production Deployment to see the same engine and tools run a second domain.

Built With

  • webmcp
Share this project:

Updates