Shared state for humans and agents

One state.
Two participants.

MUTUA is a WebMCP-native decision workspace where humans and AI agents explore changes, simulate consequences, and commit decisions together. The agent doesn't work around you. It works in the same reality you do.

Launch demo View source

No account, no setup, ninety seconds. Desktop, 1280px and up.

01The problem

Agentic products keep asking you to choose between an agent that only talks, and one that acts without you.

Advisor

Application
    ↑
  Human
    ↑
   Chat
    ↑
  Agent

It can explain what should change, but it never touches the work. You translate its advice into the application by hand.

Operator

  Human
    ↓
  Agent
    ↓
  Tools
    ↓
Application

Powerful, and opaque. Consequential actions happen somewhere behind the interface, and you learn about them afterwards.

Collaborator

SHARED APPLICATION STATE
    ┌─────┴─────┐
  HUMAN       AGENT
    │           │
   UI        WebMCP
    └─────┬─────┘
        COMMIT

The interface becomes the common workspace. The agent proposes inside it, you decide inside it, and neither of you loses sight of the other.

02Four primitives

A collaboration model that would be hard to build cleanly without WebMCP.

Shared state

One store backs the interface and every WebMCP tool. There is no agent-side copy of reality that can quietly drift out of date.

Proposal state

Agent changes are explicit, reversible operations applied to a cloned plan. Exactly one capability can touch what's real, and it is gated.

Human locks

Lock a commitment and it cannot be rescoped, delayed, reassigned or resized. A plan built before the lock is flagged as a conflict, never rewritten behind your back.

Dynamic capability surface

The registered tool set is a function of workflow phase. Comparison doesn't exist before simulation. Commit doesn't exist before approval.

03The moment

Capabilities aren't functions a page exposes. They're permission to participate in its current state.

Before you approve a plan, the agent does not have the ability to commit it. Not disabled, not guarded by a confirmation dialog — not registered. Approving is a state transition only a human can make, and the WebMCP surface changes the instant it happens.

Registration is guidance. Enforcement is separate: the commit handler independently re-validates approval, simulation freshness, state version and hard constraints, so an agent that calls it out of turn is refused rather than obeyed.

Try it — the control is real.

Agent capabilitiesphase: simulated

Available now

get_workspace_state
get_active_scenario
inspect_constraint
list_conflicts
modify_proposal
compare_scenarios
discard_proposal

Context locked

commit_proposalRequires your explicit approval

The agent cannot commit. Not hidden in the UI — not registered.

04Deterministic by construction

The agent chooses operations. The application computes consequences.

No model calculates a deadline, a workload or a cost in MUTUA. The engines are pure functions over the workspace, which is why the demo replays identically every time — and why the test suite can assert these exact figures.

Launch recovery outcomes after one engineer becomes unavailable
Metric	Current	Proposal A	Proposal B
Launch	At risk · +2 days	Sep 30	Sep 30
Extra cost	—	+$12,000	+$4,000
Peak overload	34%	4%	9%
Scope loss	—	1 feature	None
Human locks	—	Conflict	Respected

One QA engineer becomes unavailable four weeks before a September 30 launch. Proposal B exists because a human locked the Analytics dashboard — the lock doesn't filter operations, it changes which recovery is possible at all.

05Beyond the demo

The launch workspace is the proof, not the product.

Shared state, reversible proposals, constraint enforcement, dynamic capability registration, human authorisation and an audit trail are domain-general. Software launch recovery was chosen because it's legible in seconds.

Incident response
Procurement
Staffing
Infrastructure operations
Financial planning
Compliance
Engineering design

One state.Two participants.