StagedOps

An agent-native endpoint change lab where AI detects policy conflicts, simulates impact, and stages safe remediations - while humans authorize execution and rollback.

Comment

Inspiration

Managing endpoint policies is rarely difficult because of a missing button. It is difficult because administrators must understand overlapping assignments, affected devices, exceptions, and potential side effects before making a change.

AI agents can help investigate this complexity, but giving an agent unrestricted write access creates a new risk. We built StagedOps to explore a safer model: the agent analyzes and prepares changes while the human remains responsible for authorization.

WebMCP makes this collaboration possible inside the same live application instead of separating the user interface from the agent's context.

What it does

StagedOps is a human-guided endpoint change lab built around a realistic simulated device fleet.

An agent can:

  • Inspect fleet health and compliance
  • Find affected devices
  • Explain policy conflicts
  • Simulate a proposed remediation
  • Calculate the expected impact and blast radius
  • Stage a change for review
  • Apply an authorized change
  • Inspect the audit trail
  • Roll back the last change

The administrator sees every agent action reflected immediately in the dashboard. Before execution, StagedOps presents a clear change plan containing the configuration diff, affected devices, expected compliance improvement, and remaining risks.

A staged change cannot be applied until the human explicitly authorizes it in the interface. This creates a genuine handoff between agent reasoning and human accountability.

How we built it

StagedOps is a client-side web application built with React and TypeScript. It contains a deterministic fleet model with devices, groups, policies, assignments, conflicts, staged changes, and audit events.

The user interface and WebMCP tools share the same state and domain logic. This means an action performed by the agent behaves exactly like an action performed through the regular interface.

The WebMCP integration uses document.modelContext.registerTool() with narrow JSON Schemas, explicit tool descriptions, read-only annotations, structured results, and clear error responses.

Read-only tools are always available. Write capabilities follow the application's workflow: the agent can prepare a change, but the execution capability is only made available after the user authorizes the staged plan. Tool availability therefore reflects the current application state.

StagedOps does not require its own AI backend. The website provides safe, well-defined capabilities while the browser agent supplies the reasoning. Browsers without WebMCP can still use the complete human interface.

How we use WebMCP

WebMCP is not an extra chat box added to StagedOps. It is the primary collaboration layer between the application and the agent.

It provides:

  • Structured discovery of application capabilities
  • Reliable inputs through JSON Schema
  • Direct access to the current page state
  • Visible state changes in the human interface
  • Separate read and write operations
  • Dynamic capability changes during authorization
  • Verifiable results and audit events
  • Safer execution than interpreting buttons and forms through DOM automation

The central workflow—an agent staging a remediation, a human reviewing it, and the agent applying it after authorization—would be significantly less reliable without WebMCP.

Challenges we ran into

The main challenge was designing tools rather than merely wrapping interface buttons.

Each tool needed a narrow purpose, useful structured output, and enough context for an agent to choose the correct next action. We also had to keep WebMCP actions and manual UI actions synchronized through one source of truth.

The authorization workflow required special attention. We wanted human approval to be part of the actual application state, not just a sentence in a prompt. We therefore modeled staging, authorization, execution, and rollback as distinct states with corresponding audit events.

Accomplishments that we're proud of

We are especially proud that StagedOps demonstrates a complete and understandable product workflow rather than an isolated tool-calling demo.

The agent can investigate a problem, produce a measurable remediation plan, hand control to the administrator at the critical moment, execute the approved change, and verify the result. Every step remains visible and reversible.

What we learned

WebMCP works best when tools expose product intent rather than implementation details.

A small set of carefully designed tools can give an agent a more accurate understanding of an application than a large collection of generic actions. Shared visual state also builds trust: users can see what the agent discovered, what it proposes, and what actually changed.

Most importantly, human-in-the-loop design does not have to reduce agent usefulness. A well-designed approval boundary allows the agent to do more while keeping consequential decisions under human control.

What's next for StagedOps

Future versions could connect to real endpoint-management platforms, introduce role-based approvals, support signed change records, compare multiple remediation strategies, and run changes through deployment rings.

The same staged-authorization pattern could also be applied to cloud infrastructure, identity management, security operations, and other environments where agents can help—but should not act invisibly.

Built With

Share this project:

Updates

Submission history