Build story

Nerve — AI DevOps Platform

A platform that runs a 14-agent engineering org on autonomous 3-hour cycles.

2025–PresentPrivatePythonFastAPIMCPClaude Code

The problem

I build and run my products alone. Every hour spent reviewing code is an hour not spent shipping, and every hour spent on marketing is an hour the security backlog grows. The usual answer is to hire. I wanted to test a different one: how much of a small engineering org can run on agents, unattended, before quality falls apart?

I had already built three internal tools circling this idea: a memory system, an agent runner, and an org layer. Each worked; none knew the others existed. Nerve consolidated them into one product — a platform that runs 14 AI agents across three departments (development, security, and marketing) with no human in the loop for routine work.

How it works

Everything runs on a fixed 3-hour cycle. An orchestrator built on Claude Code wakes each department in turn: development agents review code, security agents scan for vulnerabilities and monitor uptime, and marketing agents generate content. A full cycle completes with zero manual intervention. My job is reading the output, not producing it.

Under the hood it is Python and FastAPI, with MCP as the wiring between agents and the tools they are allowed to touch. A real-time dashboard is the window into the org: a proposals page for what the agents want to change, a budget page for what they are spending, and a memory page for what they carry between cycles.

Keeping agents honest

Autonomy without accountability is just noise, so the platform is built around checkpoints. Agent work surfaces on the proposals page where I can inspect it, and the budget page turns model spend into a gauge I check, not a number I discover on an invoice.

The strongest evidence the loop works: the security agents filed issues against Nerve itself — missing backend auth, unguarded subscription tiers, absent CSP headers. Those became a tracked hardening workstream. Nerve is private and internal today. It runs my org; that is the point.

Tradeoffs

Fixed 3-hour cycles instead of event-driven triggers

Events are more responsive, but they make cost and behavior unpredictable. A fixed cadence puts a known ceiling on every cycle and makes failures reproducible. The worst case is a three-hour wait, which a solo org can absorb.

One orchestrator (Claude Code) rather than 14 independent agent loops

Central orchestration is a single point of failure, but also a single point of observability. Every action flows through one engine where budgets, memory, and review gates are enforced consistently. Debugging one loop beats debugging fourteen.

Consolidating three tools into one product instead of keeping them composable

Separate tools sound cleaner, but I was maintaining three deployments and three versions of the truth. Merging memory, execution, and org structure means agents share state by default — what one writes in a cycle is what another reads in the next.

Where it stands

›14 agents across development, security, and marketing, running unattended on 3-hour cycles since 2025
›Replaced three separate internal tools with one platform
›Security agents surfaced their own hardening backlog — backend auth, subscription tier guards, CSP headers — as tracked issues

What I'd do differently

I would design the security posture in from day one instead of letting the agents find the gaps. Watching the security department flag missing auth and CSP headers on its own platform was validating, but auth should never be a retrofit. More broadly, I would be slower to add agents and faster to add constraints. The hard engineering in Nerve turned out to be the guardrails — cycles, budgets, review gates — not the agents themselves, and I under-invested in them early.

Email me More projects