Theme: The Craft
Length: ~800 words
Hook: Practical — show how two open-source tools solve the full agent lifecycle
This week we open-sourced two projects. AXON — a programming language for AI agents. And AgentOps Mesh — a governance control plane for AI agents.
We didn't build them separately by accident. We built them separately because they solve different halves of the same problem.
The problem: agents have a build side and a run side. Nobody solves both.
The build side: How do you define an agent? How do you declare its tools, memory, RAG pipelines, and multi-agent flows? How do you catch type errors before runtime? How do you compile to both Python and TypeScript from one source?
The run side: How do you govern an agent in production? How do you enforce policies on what it's allowed to do? How do you require human approval for sensitive actions? How do you audit every decision, track costs, and evaluate quality?
Every framework today picks a side. LangChain builds agents but doesn't govern them. Guardrails validates outputs but doesn't define agents. You stitch them together with glue code and hope the seams hold.
We wanted to solve both sides. With purpose-built tools that connect at the seams.
AXON: the build side.
AXON is a typed DSL where agents, tools, memory, RAG, and flows are first-class language constructs. You write .ax files. The compiler checks types, validates flows, and catches errors before the agent ever runs.
agent ResearchBot {
model: @anthropic/claude-4
tools: [WebSearch, DocStore.retrieve]
memory: episodic
fn run(query: Str) -> Result<Report, AgentError> {
let plan = await spawn Planner().plan(query)?
let results = await pool(size: 3, target: Worker).investigate(plan)?
Ok(await spawn Summarizer().summarize(results)?)
}
}One source file. Compiles to Python MCP server or TypeScript module. Mock mode runs without an LLM API key. 1100+ tests. 16 examples. MIT licensed.
AgentOps Mesh: the run side.
AgentOps Mesh is a governance control plane that sits between your agents and production. It enforces:
- Policy — what is this agent allowed to do?
- Approval — does this action need human review?
- Audit — what did the agent do, and why?
- Cost — how much is it spending?
- Evaluation — is it getting better or worse?
- Launch readiness — has it passed security review?
- Compile-time safety + runtime governance. AXON catches type errors before the agent runs. AgentOps Mesh catches policy violations while the agent runs. Two layers of safety, two different kinds of errors, zero overlap.
- Declare once, govern always. When you declare
tools: [WebSearch, Database.write]in AXON, the compiler knows what the agent can do. AgentOps Mesh takes that declaration and enforces rules on each tool — allow WebSearch, require approval for Database.write, deny anything else. - Mock mode meets evaluation. AXON's
--mockmode lets you run agents without API keys. AgentOps Mesh's evaluation framework lets you score agent quality over time. Together: test the definition for free, evaluate the behavior in production. - One source of truth. The AXON source file is the single declaration of what the agent is. The AgentOps Mesh policy file is the single declaration of what the agent is allowed to do. No scattered config, no framework-specific abstractions, no glue code.
Deterministic, not probabilistic. Rules and code, not an AI judging another AI. 160+ Python modules. Full API. Docker + docker-compose. MIT licensed.
Where they connect.
AXON compiles agents. AgentOps Mesh governs them. The connection point is the tool call.
When AXON compiles an agent to a Python MCP server, every tool call the agent makes can be routed through AgentOps Mesh's policy engine. The agent declares its tools in AXON. The policy engine enforces what those tools are allowed to do at runtime.
This means:
Why this matters.
Most teams building AI agents today use 3-5 tools stitched together: a framework for definitions, a separate tool for governance, another for evaluation, another for monitoring. Each integration is custom. Each seam is a place where things break.
We built AXON and AgentOps Mesh to reduce the seams. Not to one tool — that would be too much in one system. But to two tools, each excellent at their half, connected at a natural boundary.
Both are MIT licensed. Both are on GitHub. Both are built by a small family business in India.
If you're building AI agents, try them. Separately or together. Tell us what's missing.
AXON: https://github.com/annapurnaagenticsolutions/axon
AgentOps Mesh: https://github.com/annapurnaagenticsolutions/agentops-mesh