AgentOps Mesh Docs — Architecture, API & Policy-as-Code

What is AgentOps Mesh?

AgentOps Mesh is an open-source control plane for governing AI agents before they reach production. It answers: should this agent be allowed to exist, use this data, call these tools, and move toward production?

It is not a chatbot framework. It is not an agent runtime. It is a deterministic control plane that sits between your agent definitions and production, enforcing policies, approvals, audit trails, and cost ceilings.

Note: Live connectors and model providers are disabled by design. This is a governance template, not a production system.

Architecture

AgentOps Mesh is built as a FastAPI backend with static control-plane consoles. It uses JSON file storage (not a database):

FastAPI backend — deterministic APIs for governance, policy, audit, and evaluation
Static consoles — visual control-plane views for each capability
JSON schemas — portable contracts for governance, benchmark, and scenario modeling
Policy engine — deterministic rule evaluation, not AI-as-judge
Audit ledger — tamper-evident trace of every agent decision

Agent Lifecycle

Every agent passes through 5 phases before reaching production:

Phase	What happens
1. Intake	Capture business intent, owner, domain, outcome, data, and autonomy expectation
2. Govern	Classify suitability, risk, data readiness, controls, approvals, and production gates
3. Enforce	Apply policy-as-code to tools, data, environments, model routing, identity, and secrets
4. Observe	Record traces, audit events, decisions, blocked actions, evidence, and readiness reports
5. Launch	Benchmark, release-evidence, deployment, and launch-candidate checks

9-Gate Governance Workflow

Every agent passes through 9 deterministic gates before it can reach production:

Gate	Name	What it checks
1	Intake	Business intent, owner, domain captured
2	Suitability	Is an agent the right solution for this problem?
3	Data Readiness	Is the required data available and accessible?
4	Evaluation	Has the agent passed the evaluation suite?
5	Policy	Are policy-as-code guardrails in place?
6	Approval	Has the human sponsor approved deployment?
7	Runtime	Are runtime controls (cost, timeout, retry) configured?
8	Deployment	Is the deployment environment ready?
9	Launch Readiness	Has the agent passed security review and rollback planning?

Policy-as-Code

Policies are written as code, not natural language. They're evaluated by a rules engine, not an AI model. They produce the same result every time.

# Require approval for refunds over $100
policy RefundApproval {
    if action.tool == "BillingAPI.refund" and action.amount > 100 {
        require_approval from: "manager"
        timeout: 3600s
        on_timeout: "deny"
    }
}

# Block database writes without data:write scope
policy DataAccess {
    if action.tool matches /Database\.(write|delete)/ {
        require_scope: "data:write"
        audit: true
    }
}

# Enforce cost ceiling per session
policy CostCeiling {
    if agent.session_cost > 10.00 {
        deny: "Session cost ceiling exceeded"
        alert: "cost-team@company.com"
    }
}

Why deterministic? Governance that's right 90% of the time isn't governance — it's a suggestion. AI can detect, but rules decide. See our policy workbench for more examples.

Human-in-the-Loop

Sensitive actions require human approval before execution. The approval workflow includes:

Approval gates — configured per-tool and per-action
SLA timers — approvals must happen within a configurable timeout
Escalation — if the approver doesn't respond, escalate or deny
Audit trail — every approval (or denial) is logged with reason

Audit Trails

Every agent decision is recorded in a tamper-evident audit trail:

Perception — what the agent perceived (input, context)
Reasoning — what the agent reasoned (decision, alternatives)
Action — what the agent did (tool called, parameters)
Policy checks — which policies passed/failed
Approval provenance — who approved, when, why
Cost tracking — tokens used, cost incurred
Hash chain — tamper-evident linking of audit events

API Reference

AgentOps Mesh exposes 30+ REST API endpoints. Key groups:

Group	Endpoints	Purpose
Governance	`/governance/*`	Submit, review, and track agent governance
Policy	`/policy/*`	Create, update, and evaluate policies
Audit	`/audit/*`	Query audit trails and export evidence
Runtime	`/runtime/*`	Configure runtime controls (cost, timeout)
Security	`/security/*`	RBAC, roles, capabilities
Benchmark	`/benchmark/*`	Run benchmark suites and view scores
Launch	`/launch-candidate/*`	Check launch readiness and evidence
Connector	`/connector/*`	Sandbox tool execution
Provider	`/provider/*`	Model routing controls

Full API documentation is available at http://localhost:8000/docs when running locally.

Cost Monitoring

Every agent session tracks cost in real-time:

Per-session cost ceiling — deny actions when exceeded
Per-agent daily/monthly budgets — aggregate cost tracking
Alert thresholds — notify at 50%, 80%, 95% of budget
Kill switch — automatic shutdown at 100%

Evaluation

AgentOps Mesh includes an evaluation framework with 4 layers:

Layer	Type	What it checks
1. Rule-based	Deterministic	Tool scope, cost ceiling, time limit, allowed APIs
2. Expected-outcome	Fuzzy matching	Compare output to expected result with fuzzy matching
3. LLM-as-judge	Probabilistic	Score quality: accuracy, completeness, safety
4. Human review	Manual	Sample review for high-stakes agents

Install & Run

# Clone the repo
git clone https://github.com/annapurnaagenticsolutions/open-enterprise-agentops-mesh.git
cd open-enterprise-agentops-mesh

# Set up Python environment
cd framework/backend
python -m venv .venv
source .venv/bin/activate  # Windows: .venv\Scripts\activate
pip install -e .[dev]

# Run tests
pytest

# Start the API server
uvicorn agentops_mesh_api.main:app --reload

# Open API docs
# http://127.0.0.1:8000/docs

Docker: Run docker compose up from the project root for a containerized deployment.

Before Production Use

AgentOps Mesh is a governance template. Before deploying to production, add:

Real authentication and authorization (OIDC/JWT)
Tenant-isolated database storage (replace JSON files)
Immutable audit retention
Enterprise secret-manager integration
SIEM/OpenTelemetry export
Live connector and model-provider adapters
Rate limiting and abuse controls
Security testing and threat modeling

AXON Integration

AgentOps Mesh pairs with AXON — a typed DSL for defining AI agents. Together they cover the full agent lifecycle:

AXON compiles agent definitions (the build side)
AgentOps Mesh governs them (the run side)
The connection point is the tool call — AXON declares tools, Mesh enforces policies on them

Run both together:

docker compose -f docker-compose.unified.yml up

See the unified demo for the full pipeline.

Explore AgentOps Mesh

Try the interactive demo or browse the GitHub repo.

Try Demo GitHub