-
-
overview with active intent with backend active and WebMCP enabled
-
overview with active agent
-
users intent where users interact with the system
-
audit trail
-
activitylog showing activities that take place
-
WebMCP tool list showing the tools to be used eg, search_product, purchase_product
-
Agent page showing agents who can take part in the activities
-
security layer of the system
-
demostration lab for mirror
Inspiration
As AI agents like OpenAI and Anthropic become more capable, they can do more than answer questions. They can call APIs, use web tools, modify data, make purchases, send messages, and take other real-world actions.
This creates a simple problem:
An agent having access to a tool does not mean the human gave it permission to use that tool.
I built MIRROR as a zero-trust intent layer between AI agents and their tools.
The goal is to make sure every action stays within the limits defined by the human.
What it does
MIRROR turns a human instruction into an Intent Contract that defines what an agent can and cannot do.
For example:
"Research development laptops under $1,200. Compare them. Do not purchase anything."
MIRROR converts this into:
- Allowed:
search_products,get_product_details,compare_products - Denied:
purchase_product - Approval Required: actions that need human approval
Every tool request is checked before execution.
MIRROR returns:
ALLOW
APPROVAL_REQUIRED
DENY
It also records information such as:
Risk
Intent Drift
Reason Codes
Timestamp
How I built it
Backend: Python, Django, Django REST Framework
Frontend: React, TypeScript, Vite
Database: PostgreSQL, Supabase
Deployment: Cloudflare Pages, Render, Supabase
WebMCP: Used real WebMCP tool registration and discovery to expose executable web capabilities.
Challenges i ran into
Building a Real Authorization Boundary
The main challenge was making MIRROR an actual security layer rather than just a dashboard.
Tool requests are evaluated by the backend before the action is allowed to continue.
WebMCP Integration
I needed to connect real WebMCP capabilities with MIRROR's authorization system.
The application uses:
document.modelContext.registerTool(...)
and:
document.modelContext.getTools()
Keeping Security Decisions Clear
Different tools can have different risks.
I needed one clear decision format that could explain why an action was allowed or blocked.
Example:
{
"decision": "DENY",
"drift_score": 0.87,
"reason_codes": [
"INTENT_VIOLATION"
]
}
Accomplishments that i was proud of
- Built a working Intent Contract system.
- Added bounded authority for agents.
- Integrated real WebMCP tools.
- Added
ALLOW,APPROVAL_REQUIRED, andDENYdecisions. - Added intent-drift scoring and risk classification.
- Added activity and audit logging.
- Built a live security dashboard.
- Deployed the project publicly.
The main demonstration is simple:
Human:
"Do not purchase anything."
Agent:
purchase_product
MIRROR:
DENY
The current prototype demonstrates unauthorized requests being blocked in under 100ms.
What i learned
The biggest lesson was:
Capability is not authorization.
An agent can be capable of performing an action without being authorized to perform it.
I also learned that:
- Human intent needs to become structured policy before it can be enforced.
- Authorization should remain separate from the agent's own reasoning.
- Security decisions should be visible and explainable.
- WebMCP makes agent capabilities more structured and easier to control.
What's Next for MIRROR
MIRROR is designed as a foundation for a broader security control plane for autonomous web agents.
Future versions could extend the current intent-and-authority model with:
- Cryptographically Signed Intent Contracts - prevent unauthorized modification of an agent's approved intent.
- Fine-Grained Data Permissions - control not only which tools an agent can use, but which data fields and resources it can access.
- One-Time Approval Tokens - allow humans to authorize a specific high-risk action without granting permanent permission.
- Agent-to-Agent Authorization - enforce trust boundaries when one agent delegates work to another.
- Policy Simulation - preview how a proposed agent action would be evaluated before execution.
- Advanced Semantic Intent-Drift Detection - use semantic analysis to detect when an agent's requested action gradually diverges from the user's original goal.
- SDKs for Agent Frameworks - make MIRROR easy to integrate into different autonomous-agent stacks.
The long-term goal is to make MIRROR a reusable zero-trust security control plane for autonomous web agents, where an agent's capabilities are never treated as authorization by themselves.
Why WebMCP?
WebMCP gives agents structured access to web capabilities.
MIRROR adds the authorization layer around those capabilities.
WebMCP
"What can this website do?"
MIRROR
"What is this agent allowed to do?"
This makes WebMCP a natural fit for MIRROR because tools are explicit, discoverable, and machine-readable.
WebMCP defines capability. MIRROR defines authority.
Potential Impact
As agents gain the ability to:
purchase
book
send
submit
modify
transact
they also need stronger authorization controls.
MIRROR explores a model where users can give agents autonomy without giving them unrestricted power.
The human defines the boundaries.
The agent performs the work.
MIRROR enforces the boundaries.
Live Demo
Frontend:
Backend:
https://mirror-site-8gey.onrender.com
GitHub:
https://github.com/ssebinacharles/MIRROR-PAGE
Demo Video:
Built for the OpenAI WebMCP Challenge
MIRROR was built for the OpenAI WebMCP Challenge to explore safer interaction between humans, AI agents, and the web.
The project uses WebMCP as a real capability layer and adds a separate authorization layer based on human intent, bounded authority, and explainable decisions.
Capability is not authorization.
Log in or sign up for Devpost to join the conversation.