Theme: The Craft

Length: ~800 words

Hook: Most teams build agents but skip governance. We built both — and made them work together in the browser.

Every team building AI agents eventually hits the same wall.

You write the agent. It works in the demo. You show it to your team. Everyone's excited. Then someone asks: "How do we know it's safe to put in production?"

Silence.

You add some logging. Maybe a review checklist. A Slack channel for approvals. Some guardrails hardcoded into the agent itself. It's not governance — it's hope.

We've seen this pattern enough times to know: the gap between "agent works" and "agent is safe to deploy" is where most projects stall. Not because teams don't care about safety, but because the tools for defining agents and the tools for governing them live in different worlds.

So we built both.

AXON: Define the agent.

AXON is a typed domain-specific language for AI agents. Instead of writing 500 lines of Python with framework boilerplate, you write 30 lines of declarative code:

agent ResearchBot {
    model: @anthropic/claude-4
    tools: [WebSearch, DocStore.retrieve]
    memory: episodic

    fn run(query: Str) -> Result<Report, AgentError> {
        let results = await WebSearch.search(query)?
        Ok(Report { topic: query, findings: results })
    }
}

The compiler catches type errors before runtime. One .ax file compiles to Python, TypeScript, Go, Rust, and MCP servers. You write once, deploy anywhere.

But here's what makes AXON different from "just another framework": the agent definition is a contract. It declares what tools the agent can use, what model it runs on, what its inputs and outputs are. This contract is machine-readable — which means it can be evaluated by a governance system.

AgentOps Mesh: Govern the agent.

AgentOps Mesh is a control plane that sits between your agent definitions and production. It asks one question: should this agent be allowed to exist, use this data, call these tools, and move toward production?

Not with AI judging AI. With deterministic policies. Rules. Code. You define what's acceptable, and the mesh enforces it.

The governance workflow has 9 gates: intake, suitability, data access, evaluation, policy, approval, runtime controls, deployment, and launch readiness. Each gate is a checkpoint. Each checkpoint produces evidence. The evidence is tamper-evident and auditable.

The pipeline: define → compile → govern → deploy.

Here's where it gets interesting. AXON and AgentOps Mesh are designed to work together.

You write an agent in AXON. You compile it to your target language. Then you submit it to AgentOps Mesh for governance review — directly from the CLI or from the browser playground.

The mesh evaluates the agent's contract: what tools does it use? What data does it access? What's the cost ceiling? Are the permissions appropriate? Is there an evaluation suite? Has a human approved it?

If the agent passes all gates, it gets a launch readiness score. If it doesn't, you get a specific list of what needs to change.

You can try it right now.

We built a playground where you can experience the full pipeline without installing anything.

Open the playground URL in your browser. You'll see a code editor with an example agent loaded. Click "Parse" to see the intermediate representation. Click "TypeScript" or "Go" or "Rust" to see the compiled output. Click "Govern" to submit the agent to AgentOps Mesh for governance review.

No Python installation. No API key. No virtual environment. No Docker. Just a URL and a browser.

This was deliberate. We've watched too many developers star a repo, intend to try it, and never come back. The install funnel kills curiosity. So we removed it.

Why we open-sourced both.

We could have built AXON as a proprietary language and AgentOps Mesh as a SaaS product. We didn't, for two reasons.

First, agent governance is too important to be locked behind a vendor. If you're trusting a system to decide whether your agents are safe for production, you need to be able to read the code, audit the policies, and modify the rules. Open source is the only honest way to do this.

Second, the combination matters more than either piece alone. AXON without governance is just another way to write agents. Governance without a typed definition language is just another checklist. Together, they create something neither can do alone: a pipeline where the agent definition is the governance contract.

What we're not claiming.

We're not claiming this is finished. It's a prototype. The playground runs in mock mode by default — no real LLM calls unless you configure a provider key. The governance gates are templates, not production-ready enforcement. There's no database, no authentication, no multi-tenancy.

What we are claiming is that the direction is right. Agents need to be defined with contracts and governed with deterministic policies. The tools to do this should be open, accessible, and tryable in 60 seconds.

If you're curious, open the playground. Write a 10-line agent. Click "Govern." See what happens.

Then tell us what's missing. We're building this in the open.