I Built a Governance Layer for AI Agents Because Nobody Else Was Building the Right One
Every AI agent framework gives you the same deal: here's a task queue, here's a budget cap, go nuts. CrewAI, LangGraph, AutoGen, Google ADK. They're all building the engine. Nobody's building the brakes.
Not the "slow down" kind of brakes. The "you earn the right to go faster" kind.
The Problem
I run multiple AI agents. Some of them are good at their jobs. Some of them are new. Some of them are running tasks that cost money. Some of them are doing things that can't be undone.
The question is always the same: how much autonomy does this agent get?
The answer everywhere else is binary. Either you approve everything manually (safe but slow) or you set a budget and let them run (fast but you're going to have a bad day eventually).
I wanted a third option. I wanted agents to earn autonomy the way people do. Start supervised. Demonstrate competence. Get more freedom. Screw up and you're back on a shorter leash.
What I Built
Hatchery is an open-source governance protocol for AI agents. Apache 2.0. Python. FastAPI and SQLite. Zero external dependencies.
The core idea is graduated trust escalation. Every agent starts with a neutral trust score. Every completed task feeds back into that score. 70% success rate, 30% volume. Pure math, no vibes.
When trust mode is on:
- Score 60+ and your free actions auto-execute
- Score 80+ and you can spend up to a dollar without asking
- Score 90+ and you're trusted up to fifty dollars
- Irreversible actions always need human approval. Always. I don't care if your trust score is 100.
What It Actually Does
You open a dashboard. There's a chat interface at the top. You type a message. It goes to your agent. The agent responds. The whole thing is governed.
Behind the scenes: the message becomes a task. The task gets tiered based on estimated cost and the agent's trust score. If it's within the agent's earned autonomy, it executes immediately. If not, it lands in the approval queue and you approve or deny it with one click. Or type /approve in the chat.
The agents can talk to each other. Your project lead can delegate to your writer. Your writer can ask your analyst to review. Every delegation goes through the same trust gates. The audit trail catches everything.
The agents have personalities loaded from markdown files I call soul files. Plain text descriptions of who they are, what they value, how they talk. One command loads the whole crew.
Why It's a Protocol, Not a Framework
Hatchery doesn't replace LangGraph or CrewAI. It sits above them. The protocol governs. The framework executes. Use whatever agent framework you want underneath. Hatchery handles the question every framework ignores: should this agent be allowed to do this thing right now?
The Agentic Trust Framework from the Cloud Security Alliance describes four maturity levels for agent governance. The OWASP Top 10 for Agentic Applications dropped in December. Microsoft released their Agent Governance Toolkit four days ago. The industry is waking up to the fact that letting agents run unsupervised is going to end badly for someone.
Hatchery is the operational governance layer. Not security (that's Microsoft's thing). Not compliance (that's Credo AI's thing). Operational. Who can do what, when, at what cost, with what level of human oversight. The boring stuff that keeps the ship running.
The Stack
- Python 3.13+
- FastAPI (REST API with auto-generated docs)
- SQLite (zero config, no external database)
- Pydantic (data validation)
- Single HTML dashboard (no React, no build step, no node_modules)
- Ollama adapter for local LLM inference
- 101 tests passing
The whole thing runs with pip install hatchery-ai && hatchery. One install, one command, dashboard at localhost:8000.
What's Next
This is v0.3.0. The first version with the chat interface and agent delegation. I've been building and testing the protocol against my own agents for weeks. It's ready for other people to break it.
Coming soon:
- Docker one-liner
- MCP integration (agents can use tools)
- A2A protocol support (interop with other agent frameworks)
- More adapters (HTTP endpoints, custom integrations)
- Pre-built agent templates
The repo is public. The protocol is Apache 2.0. Use it, fork it, build on it.
Why Scuttle Labs
I'm a Navy veteran. USS Kitty Hawk, engineering department. I spent four years running systems that worked whether or not anyone was watching. That's what good governance looks like. Not a checklist. Not a compliance framework. A system that runs because it was built to run and the building was good enough that the running is inevitable.
The AI industry is building increasingly powerful autonomous agents and handing them to people with no governance infrastructure. That's like handing someone a ship with no engineering department. It'll float for a while. Then it won't.
Hatchery is the engineering department.
GitHub · Docs · SLOBSTAH Protocol · Apache 2.0