AgentOps Command Center

Steady state before the incident: error rate 0.32%, p99 110ms, five services green.
Root cause, traceable to data: deploy dep_0006 cut DB_POOL_MAX from 50 to 5.
The console during a SEV-2: environments on the left, live evidence in the centre, the incident record and available actions on the right.
The smoking gun, one tool call away: "pool exhausted: 5/5 connections in use, 250 waiters."
What the agent reads rather than guesses. p99 steps from flat to 3.13s, error rate to 16%, CPU pinned at 100%.
Nothing changes without a human. The agent proposes the rollback, cites its evidence, and waits for Approve or Deny.

Inspiration

Modern incident response is still highly human-driven. When production breaks, engineers jump between dashboards, logs, traces, deployment systems, runbooks, and incident-management tools to understand what happened and decide what to do next.

We wanted to explore a different model: what if an AI agent could actually operate an observability application, while humans remain in control of high-impact decisions?

AgentOps Command Center was inspired by the idea that WebMCP can turn the web from something an AI merely reads into something an AI can meaningfully operate.

What it does

AgentOps Command Center is an AI-native incident response and SRE platform designed for collaboration between humans and AI agents.

When an incident occurs, an agent can use WebMCP tools exposed by the application to:

Monitor service health and production metrics
Investigate logs and traces
Analyze recent deployments
Identify likely root causes
Retrieve relevant runbooks and service ownership information
Recommend remediation actions
Request human approval for high-impact operations
Execute approved actions such as rolling back a deployment
Update incident status and generate a postmortem

Instead of forcing an agent to navigate a complex UI like a human, WebMCP gives it structured, intentional capabilities.

The human remains the decision-maker while the agent handles the investigation, reasoning, and execution.

How we built it

We built AgentOps Command Center as a web-based simulated production environment with an observability dashboard, incident center, deployment history, logs, runbooks, and remediation workflows.

The key innovation is the WebMCP tool layer.

We exposed application capabilities as structured tools that an AI agent can discover and invoke directly, including tools for:

Service health
Metrics and logs
Incident investigation
Deployment analysis
Runbook retrieval
Deployment rollback
Incident updates
Postmortem generation

The application maintains a realistic incident scenario so the entire investigation and remediation flow can be demonstrated deterministically.

The architecture separates read-only investigation capabilities from state-changing actions, allowing us to demonstrate a human-in-the-loop safety model.

Challenges we ran into

The biggest challenge was deciding what an AI agent should be allowed to do autonomously versus what should require human approval.

We designed the system around three levels of interaction:

Observe → Recommend → Act

The agent can freely investigate the environment, but potentially destructive actions such as deployment rollback require explicit human approval.

Another challenge was designing WebMCP tools around meaningful business actions rather than simply exposing individual UI buttons. We wanted each tool to represent an intentional capability an agent could reason about.

We also had to make the simulated production environment realistic enough that the agent could correlate metrics, logs, deployments, and runbooks to arrive at a defensible root-cause hypothesis.

Accomplishments that we're proud of

We are proud that AgentOps Command Center demonstrates WebMCP as more than an integration layer.

The agent doesn't simply retrieve information from the website. It can investigate a live operational scenario, reason across multiple sources of evidence, recommend a remediation, obtain human approval, and execute the approved action through the web application.

We are particularly proud of the human-agent interaction model:

Agent investigates → Agent explains → Human approves → Agent executes → System recovers

This creates a practical example of how WebMCP could enable a new generation of agent-native web applications.

What we learned

We learned that the most powerful agent experiences aren't necessarily about giving an AI unrestricted autonomy.

The real opportunity is designing clear boundaries between what an agent can observe, what it can recommend, and what it can execute.

We also learned that WebMCP changes the role of the website itself. Instead of being only a visual interface for humans, the website can become a structured operational environment that both humans and AI agents can interact with.

The best tools are not necessarily the ones that expose the most functionality. They are the ones that expose the right capabilities with clear intent and safe boundaries.

What's next for AgentOps Command Center

Our next step is to connect AgentOps Command Center to real observability and infrastructure platforms.

Future versions could integrate with:

Grafana and Prometheus
OpenTelemetry
Kubernetes
Cloud monitoring platforms
CI/CD systems
Incident management platforms
Enterprise runbooks and knowledge bases

We also want to introduce multi-agent collaboration, where specialized agents handle detection, diagnosis, security validation, remediation planning, and executive communication.

Ultimately, our vision is an agent-native operations control plane where humans set the intent and guardrails, while AI agents continuously investigate, coordinate, and safely operate complex production environments.