Agent DNA: what your agent inherits, or rebuilds from scratch every time

Agent DNA: what your agent inherits, or rebuilds from scratch every time

An agent fails. An engineer reads the trace, finds the cause, edits the prompt, and the agent passes. A week later the same class of failure returns in a slightly different shape, and a different engineer opens the trace and starts again. The fix lived in one person’s head and one diff. The agent learned nothing.

This is the normal way to build agents today, and it is why they do not get better on their own. We are at the start of a decade of agents, and almost none of them have a way to keep what they learn. The ones that win the decade will carry every failure forward as something permanent. Call it the agent’s DNA.

Fixing in place was the right move, until it was not

Hand-tuning made sense when you had one agent and a handful of failure modes. Editing the prompt in place was the fastest path to a passing run, and there was nothing to inherit yet, so nothing was lost. That breaks the moment the agent takes on real surface area. Failures multiply, and every fix that lives only in a prompt edit is a fix you will make again. The correction is real, but it is stored nowhere the agent can reach. Effort does not accumulate. It resets.

An agent that runs unsupervised needs a way to inherit

An agent that operates without a human watching every step cannot depend on a human remembering every past fix. The fixes have to live inside it. Reliability here is not uptime. A deterministic service is reliable when it stays up. An agent is reliable when a failure it has already seen cannot quietly come back. That is closer to biology than to infrastructure. A trait survives because it is written into the DNA and passed on. A fix that is not written into the agent is a trait the next version does not get.

So where does an agent actually store what it has learned?

Agent DNA is the spec, the dataset, and the evaluations, together

An agent is defined by three things in combination:

• The spec, the criteria that say what correct behavior is.
• The dataset, the real cases the agent is measured against, including the ones it failed.
• The evaluation sets, the tests that decide pass or fail on those cases.

Those three together are the genome. They are the actual definition of the agent, the part that says who this agent is and what it is allowed to get wrong. The model is the substrate the genome runs on.

Once you see the agent this way, a failure stops being a fire to put out and becomes material. Every failure resolves into one of three things: a new criterion in the spec, a new row in the dataset, or a new evaluation. The moment it is captured there, that failure cannot silently return, because every future cycle measures against it. The agent now carries the lesson whether or not the engineer who found it is still in the room.

Agent DNA = spec + dataset + evaluation sets

  a failure ─► captured as ─► one of:
                                • a new criterion in the spec
                                • a new row in the dataset
                                • a new evaluation

  each cycle:  evaluate → diagnose → optimize → validate
                         └─── deposits into the DNA ───┘

  swap the model underneath ▸ the DNA carries over

This is where the compounding lives. The loop runs, evaluate then diagnose then optimize then validate, and what it deposits each turn is DNA. The spec gets sharper. The dataset gets harder. The evaluations get stricter. An agent that has run this loop for six months is not running on a better prompt. It is running on six months of accumulated, inherited failure, every one of which it now passes by construction.

And because the DNA lives in the spec, the dataset, and the evaluations rather than in the model, it is model-agnostic. You can replace the model underneath with whatever ships next quarter, and the genome carries over intact. The thing you spent six months building does not evaporate the day a new model arrives. It is the most durable asset the agent has.

What this asks of you tomorrow morning

Stop fixing failures in place. When an agent fails, do not just edit the prompt and move on. Decide which strand the failure belongs to, write it into the spec, the dataset, or the evaluations, and let the next cycle inherit it. Build the agent so that its failures compound into something it keeps rather than something you re-solve.

This is the layer we are building at Mutagent, the place where an agent’s DNA accumulates and grows every cycle. But the idea stands on its own, with or without us. An agent with no DNA starts every week from zero. An agent with DNA gets harder to break the longer it runs.

The question is no longer how good your agent is today. It is how much of what it has already learned it will still have a year from now.