Actalume

Inspiration

Agent systems are increasingly capable of taking actions, but the human is often left reconstructing the chain of custody afterward. What was actually requested? Which boundary applied? What changed? What proves it? Who accepted it as project truth?

Actalume began with one non-negotiable idea: an agent's claim that work is complete is not the same as a human decision that the work is canonical.

What it does

Actalume is a human-governed system of record for agent work. A project starts with an explicit contract describing its purpose, public-data boundary, allowed actions, prohibited actions and completion rule. An agent can then propose one bounded brick, attach typed evidence receipts and request human review.

Six WebMCP tools expose that workflow directly to an agent: list projects, inspect the contract, propose a brick, submit evidence, request review and inspect canonical history. There is deliberately no approval tool. Approval requires a named human and a second confirmation inside the interface. Only then is the decision sealed into immutable, evidence-linked history.

All supplied demo content is fictional and public-safe. The app has no accounts, telemetry, network writes or publishing integration.

Why WebMCP

Without WebMCP, an agent must infer controls from the interface and the human must trust an unstructured summary of what happened. With WebMCP, Actalume exposes a narrow, typed and inspectable work protocol while keeping the consequential decision outside the agent's authority.

People and agents can now share one legible custody chain: the agent can inspect scope, create bounded work and submit proof; the human can review that exact evidence and decide what becomes project history.

How we built it

Actalume is a local-first React 19 and TypeScript application built with Vite. Browser persistence uses localStorage, with deterministic fictional fixtures and JSON import/export. The WebMCP layer registers six imperative tools using document.modelContext.registerTool, each with narrow schemas and explicit read-only or review-request semantics.

The ledger reducer enforces state transitions separately from the UI. Automated tests prove that an agent cannot approve work, approved bricks cannot be mutated, evidence is required before review and all six tools register when the native browser surface is present.

The challenge build was verified in Chrome 151 with WebMCP testing enabled. Chrome discovered all six tools and executed safe reads, evidence submission and a human-review request. An attempted agent approval was rejected, and canonical history stayed unchanged.

Challenges we ran into

WebMCP is experimental, so ordinary-browser fallback behavior had to remain honest without being mistaken for native proof. We separated the visible demo harness from native verification and only claimed WebMCP success after Chrome's getTools and executeTool APIs discovered and exercised the live registrations.

The harder product challenge was making governance feel like a workflow rather than a policy page. We designed the interface around one custody line: contract, bounded brick, evidence, human decision and canonical history. Amber surfaces actions awaiting judgment; green is reserved for history already verified by a person.

Accomplishments that we're proud of

• Six working WebMCP tools with no agent approval surface.
• A named-human, two-step approval gate.
• Immutable canonical history with evidence counts and deterministic digests.
• Ten automated governance, registration and deliberate-approval tests.
• Zero dependency vulnerabilities at submission preparation.
• A complete responsive product experience rather than an inert technical demo.

What we learned

Agent safety becomes easier to understand when it is spatial and operational. A visible boundary, a typed tool surface and a blocked transition communicate more than a long policy document. WebMCP is especially powerful when it exposes not only what an agent can do, but also what it cannot do.

What's next for Actalume

The next version would add pluggable receipt adapters, signed export bundles and optional team roles while preserving the same core rule: agents may propose and prove; named humans decide what becomes true.

Attribution

Created and directed by Deen Storkey. Implemented with Codex assistance under the entrant's direction.

Built With

• css3
• html5
• localstorage
• openai
• react
• typescript
• vite
• vitest
• webmcp