UMBRA DRIFT

• 

  A shared shadow theatre for one human and one browser agent, with Reality, Agent Belief, and Human Authority kept visibly separate.

• 

  The recovery proof: one human override, one rejected stale write, zero partial mutations, and SAFE_RECOVERY.

• 

  The human moves the lamp; the page rejects the stale plan with LAMP_SEQUENCE_CONFLICT and zero partial mutations.

Inspiration

Browser agents often act as if a page will wait for them. Real people keep dragging, editing, approving, and revoking. Most demos hide that race condition. We wanted to make it impossible to miss.

What it does

UMBRA DRIFT is a shared shadow theatre and a reproducible WebMCP recovery trial. A human controls the lamp and temporary capability grants. An external browser agent controls a four-piece rig through typed page tools.

If the human moves the lamp after the agent observes the scene, the old plan is rejected atomically, without partial changes. The agent must read the live state again, measure the new projection, and recover. A successful run produces a visible dragon, a SAFE_RECOVERY verdict, and an exportable evidence capsule derived from the page's event ledger.

Why WebMCP

WebMCP is the coordination layer, not an integration added beside the experience. The state that matters is live, transient, and owned by the current browser tab. UMBRA exposes typed tools tied directly to that state instead of asking an agent to guess through pixels or DOM controls.

The agent can observe, measure, request, plan, and commit. It cannot move the human-owned lamp, grant itself permission, bypass a revision check, or provide its own verdict.

What becomes possible

A person and an external agent can work in the same changing page while retaining separate authority. The human sees every capability request and can revoke control. The agent receives structured measurements and actionable conflicts. The site—not the model—enforces the boundary.

How we built it

UMBRA DRIFT uses the imperative WebMCP API through document.modelContext.registerTool, closed JSON Schemas, vanilla JavaScript, SVG, and CSS. Each mutation is checked against the observed lamp sequence, rig revision, and capability revision. Batched rig changes are all-or-nothing. A bounded deterministic event ledger produces the final recovery verdict. The UI exposes Reality, Agent Belief, and Human Authority as separate live states.

The public app has no backend, account, API key, remote model call, database, telemetry, or external runtime dependency. The Apache-2.0 source includes the engine, tests, security contract, provenance, and reproduction instructions.

Potential impact

UMBRA is a playable reference pattern for editors, design tools, dashboards, workflow products, and other live applications where humans and agents share changing state. It makes five reusable ideas tangible: explicit ownership, scoped grants, optimistic concurrency, atomic mutation, and recovery after human intervention.

Challenges and learnings

The hardest problem was making the agent necessary without hiding the whole solution in a tool response. We learned that a tool schema is also an authority contract, and that structured failure is part of the human-agent experience, not merely an implementation detail.

What's next

Additional seeded trials, reusable conformance fixtures, CI adapters, and evaluations across different browser agents.

Links

• Live demo
• Source code — Apache-2.0
• Public demo video

Built With

• chrome
• css3
• html5
• javascript
• playwright
• svg
• vercel
• vitest
• webmcp