Inspiration
Inspiration
Modern DevOps teams have powerful monitoring tools, dashboards, CI/CD systems, cloud consoles, logs, and AI assistants, yet incident recovery is still fragmented.
When production fails, engineers jump between alerts, logs, GitHub, Kubernetes, deployment dashboards, runbooks, and communication tools while downtime continues.
DevPilot AI was originally built to compress this workflow into a human-approved AI incident recovery platform.
The WebMCP Challenge gave me the opportunity to take the next step: make DevPilot not only usable by humans, but directly understandable and operable by AI agents.
Instead of forcing an agent to visually navigate a complex DevOps dashboard, DevPilot WebMCP exposes structured tools that clearly describe what an agent can inspect and what actions it can request.
The goal is a web application where the developer and their AI agent can investigate and resolve production incidents together.
What it does
DevPilot WebMCP is an agent-native DevOps control plane for detecting, diagnosing, and recovering from production incidents.
The existing DevPilot platform already brings together infrastructure alerts, deployment failures, logs, incident memory, AI diagnosis, remediation planning, GitHub workflows, and human-approved recovery actions.
For the WebMCP Challenge, DevPilot is being extended with structured WebMCP tools for agent interaction.
The WebMCP interface is designed around capabilities such as:
- Analyze application and infrastructure incidents
- Inspect service and deployment health
- Diagnose likely root causes
- Retrieve incident context and historical information
- Generate structured remediation plans
- Explain why a deployment failed
- Prepare recovery actions
- Verify system health after remediation
This means a developer can work with an AI agent through natural language while the agent interacts with DevPilot through explicit structured tools instead of guessing how to click through the interface.
A workflow can look like:
- A production problem is detected.
- The developer asks their AI agent to investigate it.
- The agent discovers DevPilot's available WebMCP tools.
- DevPilot returns structured incident and infrastructure context.
- The agent requests a diagnosis and remediation plan.
- DevPilot presents the proposed action to the human.
- The human reviews or approves the action.
- DevPilot verifies recovery and records the result.
The human remains responsible for high-impact actions while the agent handles investigation, information gathering, and repetitive operational work.
Why WebMCP
DevOps applications are an especially strong fit for WebMCP because their interfaces can contain dozens of dashboards, tables, alerts, logs, buttons, and operational workflows.
A traditional browser agent has to interpret these visual interfaces and infer what each element means.
WebMCP lets DevPilot expose the underlying capabilities directly.
Instead of an agent searching the screen for an incident and guessing which controls to use, it can discover a structured tool such as an incident-analysis or service-health capability with a defined schema.
This makes agent interactions more reliable, explainable, and efficient.
Most importantly, WebMCP allows the human-facing application and the agent-facing interface to exist together.
Humans keep the rich visual operations cockpit.
Agents receive precise structured tools.
Together they can perform workflows that would otherwise require engineers to manually gather information from many different systems.
How I built it
DevPilot is a full-stack AI DevOps platform.
The frontend is built with Next.js and React and provides the operations cockpit used by developers.
The backend is built with Python and FastAPI and handles incident workflows, AI analysis, authentication, persistence, and external integrations.
Neon PostgreSQL provides persistent storage.
OpenAI is used for AI-assisted diagnosis and remediation workflows.
GitHub integration supports development and remediation workflows, while the platform also contains production monitoring, CI/CD checks, Docker support, and infrastructure-oriented recovery capabilities.
For the WebMCP Challenge, I am extending the web application using the WebMCP API so the browser can register DevPilot capabilities as structured agent tools.
Each WebMCP tool is designed with:
- A clear tool name
- A precise description
- Structured input schemas
- Restricted operational scope
- Predictable outputs
- Human approval for sensitive actions
The challenge-specific implementation is being developed after the WebMCP Challenge start date and documented separately in the repository and commit history.
Human + Agent Collaboration
DevPilot is intentionally not designed to remove engineers from incident response.
The agent handles tasks that are expensive for humans but safe to automate:
- Gathering context
- Reading health information
- Correlating incident signals
- Identifying likely root causes
- Retrieving previous incident knowledge
- Preparing remediation plans
The human remains in control of consequential infrastructure actions.
This creates a workflow where the AI agent acts like an extremely fast operations investigator while the engineer acts as the decision maker.
WebMCP is the bridge that makes this collaboration reliable.
Challenges I ran into
One of the biggest design challenges is deciding what should become an agent tool and what should remain a human-controlled action.
DevOps systems can affect real infrastructure, so simply giving an agent unrestricted operational access would be unsafe.
The WebMCP layer therefore needs narrowly scoped tools, explicit schemas, predictable responses, and approval boundaries.
Another challenge is converting information that was originally optimized for visual dashboards into structured results that agents can reason about reliably.
The final challenge is preserving the existing human experience while introducing a second, agent-native interaction layer without duplicating the entire application.
Accomplishments that I'm proud of
I am proud that DevPilot already functions as more than a chatbot.
It is a working DevOps control plane connecting incident signals, AI diagnosis, remediation planning, monitoring, deployment workflows, and human approval.
The WebMCP extension evolves that architecture further by allowing AI agents to interact with the same operational capabilities through a purpose-built machine interface.
Rather than redesigning the application only for AI, the project explores a web where humans and agents have interfaces designed specifically for each of them while sharing the same underlying application.
What I learned
Building DevPilot has taught me that useful AI systems need more than model responses.
They need structured context, predictable tools, observability, permissions, validation, and clear human control.
WebMCP introduces another important principle: websites should not require AI agents to reverse-engineer their interfaces.
If applications can explicitly describe what agents are allowed to do, agent interactions can become significantly more reliable.
What's next for DevPilot WebMCP
The next step is expanding DevPilot's WebMCP interface into a complete agent-native operations API for the browser.
Future capabilities could include:
- Repository and CI/CD investigation
- Kubernetes health analysis
- Deployment rollback planning
- Infrastructure drift investigation
- Security incident triage
- Cost anomaly analysis
- Multi-agent incident collaboration
- Persistent incident memory
- Organization-level policy and approval controls
The long-term vision is for DevPilot to become an operations environment where engineers and AI agents continuously collaborate to keep software reliable.
What it does
How we built it
Challenges we ran into
Accomplishments that we're proud of
What we learned
What's next for DevPilot WebMCP
Built With
- actions
- api
- docker
- fastapi
- github
- javascript
- neon
- next.js
- openai
- postgresql
- python
- react
- render
- rest
- typescript
- vercel
- webmcp
Log in or sign up for Devpost to join the conversation.