Agents need a nervous system, not a bigger brain

Most of what I build doesn't look like a chatbot. It's a process that runs for minutes, sometimes days. Pull a submission, read the documents, extract the fields, price the risk, route it, wait on a human, then move. Insurance back-office work. The kind where a step can fail halfway and the money is real.

Here's what I keep running into. When one of these runs breaks, the fix is almost never a smarter model. The model did its job. The process crashed between two of its steps, or it fired the same side effect twice, or it lost the thread of a job it was three hours into. Those are systems failures. You don't fix them with a better prompt or a bigger context window. You fix them with infrastructure the model never sees.

That's the whole argument. The next real gains in agents come from the runtime, not the brain.

The metaphor is already going around. Ensemble VC wrote a piece last year called From Brains to Nervous Systems, and the framing is right even where I think the emphasis is wrong. They point at protocols, MCP and A2A, as the connective tissue. That's plumbing. Useful plumbing. But the nervous system I care about isn't how agents talk to each other. It's reflexes and memory: not losing your place, being able to replay exactly what happened, stopping to wait for a human without falling over.

What durability actually buys you

Say an agent is eight steps into a twelve-step run and the worker crashes. A deploy, an OOM, a bad node, doesn't matter. You have two options. Start over, or pick up where it left off.

Starting over sounds fine until step three sent an email. Now you re-run step three and send it again. In quoting, step three might bind coverage or push a number to a downstream system. Retry-from-scratch isn't just slow there, it's wrong. A crash that loses work is a bad day. A retry that duplicates a side effect is a phone call from a customer.

Durable execution is the thing that lets you resume instead of restart. The runtime records every step's result, so on replay it fast-forwards through the work that already happened and only runs what didn't. Temporal does this. So do Restate, DBOS, Inngest. The idea is older than any of them, it's just finally showing up where agents live.

The tax you pay for it

Durable execution isn't free, and the cost is a specific kind of annoying. To replay a run deterministically, the runtime needs your code to produce the same decisions given the same history. Which means the non-deterministic stuff (the current time, a random ID, a raw network call) can't live in the workflow itself. It gets recorded, not recomputed.

So this is a bug:

// inside a workflow: runs fine, replays wrong
const requestId = crypto.randomUUID();
if (Date.now() > deadline) {
  await escalate(requestId);
}

On the first pass it works. On replay, Date.now() returns a different value and randomUUID a different string, the branch flips, and the runtime throws a non-determinism error because the new history doesn't match what it recorded. The fix is to pull those out into the durable layer (activities, or the workflow's own deterministic clock) so the value is written down once and replayed, never recomputed.

You learn to feel where the boundary is. It's the single biggest adjustment going from "call the model in a loop" to "run the model inside a workflow."

The part nobody sells you

Durability gets the blog posts. Temporal published a good one arguing that reliability is half models and half infrastructure, and they're right, though you should read it knowing they sell the infrastructure. I run their stack, so read me the same way.

The part I find more interesting is the control loop. Most agent demos assume the agent finishes on its own. Mine don't. An underwriter has to approve. A number has to get a second look. Someone has to say yes before money moves. In a stateless system a human in the loop is a hack: you hold a request open, or you drop the state into a queue and pray the reconstruction is faithful.

With a durable runtime the human is just another step that takes a while. The agent hits the gate, the workflow suspends, its entire state sits on disk, and it waits. An hour. A day. Whatever it takes. When the approval lands, an event wakes it and it resumes with full context, like it never stopped. We route those events over NATS, so the thing that pauses the agent and the thing that resumes it are decoupled from the agent itself.

That's also why event sourcing keeps showing up in this world. Tian Pan has a clear writeup on treating agent state as an event stream instead of mutable memory. In a regulated domain you were going to need the append-only audit trail anyway. An examiner asks why a risk got priced the way it did, and "here's every event that led to the decision, replayable" is a much better answer than "the model felt like it."

But won't bigger models eat all of this

Fair question, and the honest answer is: some of it, yes. Longer context and better tool use will absorb orchestration scaffolding that only exists because today's models forget and fumble. If you're holding your breath waiting for that, parts of what I've described are temporary.

The parts that aren't temporary are the ones that were never about intelligence. Surviving a process crash isn't a reasoning skill, it's a systems guarantee. Same with firing a side effect exactly once, keeping a record an examiner can read, giving a human the power to say no. Model IQ doesn't buy you any of that. A smarter model that sends the duplicate email with more elegant reasoning still sent the duplicate email.

I'd push back on myself on one thing. Durable execution is heavy. For a lot of agents, a plain retry loop is genuinely fine, and reaching for event sourcing and replay is over-engineering you'll regret maintaining. The nervous system earns its cost when runs are long, when they touch money or a regulator, when a human has to step in, when a duplicate action is worse than a failed one. Short and stateless and cheap to redo? Skip all of this.

So when someone tells me the next leap is a bigger model, I believe them, and I don't think it changes my week. My week is checkpoints, replay boundaries, and approval gates. The teams that ship agents worth trusting won't be the ones with the smartest model. They'll be the ones whose agent still knows what it was doing after the power comes back on.