Pending: Human

• 

  The deterministic T+60 result compares the approved response with the do-nothing baseline.

• 

  Choose one of three deterministic crisis missions and invite a WebMCP-enabled AI teammate.

• 

  A live flash-flood response with graph-based vehicle movement, named roads, and human-impact forecasting.

• 

  The AI reads structured city state while the human controls dispatch, routes, priorities, and approval.

• 

  Full game view: live roads, facilities, incidents, city metrics, and synchronized AI activity.

Inspiration

Browser agents are usually asked to operate interfaces designed only for human eyes. That becomes fragile when an application contains a live model with more meaning than its visible controls can express. A crisis dashboard may show a blocked road, a failed power station, and an overloaded hospital, but the causal chain connecting them is difficult to reconstruct from pixels or DOM labels.

We wanted to explore a different relationship: not an agent that simply clicks faster than a person, but a human and an agent operating the same complex system through complementary interfaces.

What it does

Pending: Human turns a sixty-minute urban crisis into a shared decision exercise. The deterministic simulation creates cascading infrastructure failures and tracks exposed residents, injuries, untreated critical cases, fatalities, hospital load, road travel time, emergency vehicles, and incident resolution.

The AI teammate uses WebMCP to investigate structured city state, trace root causes, forecast the cost of doing nothing, compare three compound response plans, and stage one candidate for review. The player chooses the mission doctrine, dispatches vehicles and routes, can build an independent counterproposal, and makes the final decision.

Simulating is never executing. A proposal remains pending until the human presses the visible approval control. There is deliberately no WebMCP approval tool.

Why WebMCP

Pending: Human is built around state that is richer than its visible dashboard. WebMCP gives the agent a semantic contract over the same facts used by the simulation engine: named roads and facilities, passability, power dependencies, hospital pressure, response routes, at-risk populations, and deterministic future outcomes.

This avoids guessing from color, screen position, animation, or fragile markup. It also creates a stronger safety boundary. The agent receives deep investigative and counterfactual capabilities without receiving final authority to act.

The tool surface changes with the stage. It begins with one entry capability, then exposes only what is useful at the current checkpoint. One integrated assessment call reads the evidence and issues three exact revision-bound previews; a second call lets the agent exercise judgment by selecting one. Short guidance tools explain and highlight the next human control without clicking it, and an event-wait tool keeps the shared session synchronized.

A better human + agent experience

The simulation, agent, and human have distinct powers:

• The simulation owns the facts. Every live and forecasted consequence comes from deterministic TypeScript rules.
• The agent compares possible futures. It connects evidence across infrastructure systems and explains trade-offs.
• The human owns the decision. The player sets values, accepts social costs, and authorizes consequential action.

City time freezes while the agent analyzes and while a proposal awaits approval, so model latency cannot cause extra simulated deaths. Findings are mirrored into the page transcript, and the approval card shows benefits and costs before the player decides. The human can disagree by building a separate plan without erasing the AI proposal.

Together, people and agents can identify a cross-system root cause, establish a shared no-action baseline, compare policy futures under human-selected values, and verify the result against the same rules. Doing this reliably through a human-only interface was previously slow and brittle.

How we built it

The project is a client-side React and TypeScript application. The road graph, casualty model, scenarios, incident clearance, vehicle travel, forecasts, and scoring all live in one deterministic simulation engine. A shared store manages the live clock, event queue, plan previews, human approval boundary, and teammate transcript. WebMCP tools are registered directly by the page and routed by the current simulation phase.

The live workflow uses enter_pending_human_stage, analyze_crisis, propose_emergency_plan, post_next_guidance, focus_next_control, wait_for_city_event, and analyze_turning_point. Granular district, road, facility, hospital, power, routing, forecast, and simulation tools remain available for semantic diagnostics.

There is no external AI API inside the application. The WebMCP-enabled browser supplies the agent. There is also no database, login, map API, or hidden backend simulation.

Challenges

The hardest design problem was keeping a continuous co-op experience responsive when an agent model could take tens of seconds to reason. We introduced time freezing, phase-aware tools, event waiting, and a two-call decision path that batches structured investigation while still requiring the agent to choose among candidates.

Another challenge was visual causality. Response vehicles originally felt decorative. We rebuilt movement around the same road graph exposed to WebMCP, made congestion and closures change travel speed, anchored arrivals to visible nodes, and let on-scene units progressively resolve incident markers.

Accomplishments

• Live play and forecasts share one source of truth.
• Simulating a plan never mutates the live city.
• Stale previews cannot execute after the city revision changes.
• AI and human plans remain visible together.
• High-impact actions cannot bypass human approval.
• Three difficulty-scaled missions are deterministic and replayable.
• Forty-two automated tests cover the engine, routing, approval boundary, and agent flow.

What we learned

WebMCP is most compelling when it exposes meaning that cannot be reliably recovered from the human interface. It is also useful for defining what an agent cannot do. A good agent experience is not the largest possible toolbox; it is a clear sequence of meaningful capabilities, shared state, and explicit authority boundaries.

What's next

Future work could add a scenario authoring system, richer field observations, and deeper doctrine negotiation while preserving deterministic evaluation and human approval. The current version intentionally prioritizes one complete collaboration loop over an open-ended city model.

Pending: Human is a fictional training and interaction-design prototype. All people, casualties, incidents, and outcomes are simulated.

Built With

• cloudflare
• codex
• css
• react
• tailwind
• typescript
• vite
• webmcp