What is agent graduation?

The Problem the Term Points at

The agent landscape in 2026 is fragmenting, not converging. Several major vendors are each building their own runtime, and the things an agent depends on — how it stores state, how its memory is formatted, how its tools are wired, what it has been told about the organisation — increasingly diverge between them. The widely-quoted shorthand is that whoever owns the agent runtime owns the workflow. Lock-in is not an accident of these platforms; it is, to a meaningful degree, the business model.

This makes moving an agent costly in a specific way. The agent's capabilities usually transfer — a capable model on one platform is a capable model on another. What does not transfer is everything the organisation put into making the agent useful in its particular setting: the goals it was given, the constraints it operates under, the decisions and context it learned to work from. If those things live as configuration inside the runtime being left behind, the move means rebuilding them. The organisation pays, in effect, to re-teach an agent things it already knew, because what it knew was stored somewhere it could not take with it.

Graduation is the word for the version of this move where that does not happen.

Graduation is not Handoff

It is worth separating graduation from a similar-sounding thing the industry already has a word for. Handoff, in current usage, means one agent transferring control to another within a single framework — a triage agent passing a conversation to a billing specialist, the receiving agent picking up with the context of that conversation. That is a coordination pattern inside one environment.

Graduation is a different move along a different axis. It is not one agent passing work to another inside a runtime; it is the same agent moving between runtimes, carrying its operating context across the boundary. Handoff is lateral and internal. Graduation is a departure. The two are easy to conflate because both involve context surviving a transition, but the transition is of a different kind: handoff crosses a conversation boundary, graduation crosses a platform boundary, and platform boundaries are exactly where organisational context tends to be lost.

What Makes Graduation Possible

For an agent to graduate rather than be rebuilt, one condition has to hold: the things that made the agent useful have to exist somewhere other than inside the runtime it is leaving.

This is the whole game. If an agent's operating context is a portable artefact the organisation holds — its goals, constraints, decisions, and the knowledge it works from, kept as something separable from any one execution environment — then moving the agent means carrying that artefact to the new environment and continuing. If instead that context is entangled with the runtime, expressed in that platform's particular configuration and storable only there, then there is nothing to carry, and the move is a rebuild.

It is worth being precise about what travels. The organisation's authored knowledge lives in a persistent store — its long-lived substrate of goals, constraints, and decisions. What graduates with the agent is not that whole store but the task-specific brief drawn from it: the package the agent actually carries into the work. The substrate stays put; the projection of it moves. Graduation depends on the second being portable, which in turn depends on the first being held somewhere the organisation owns rather than somewhere a platform does.

So graduation is less an event you perform than a property you arrange for in advance. An organisation that has kept its agents' operating context as its own portable asset can graduate them freely, treating execution platforms as interchangeable and choosing between them on merit. An organisation whose context lives inside each platform is, in practice, married to whichever one it started with — not because moving the agent is technically hard, but because moving what the agent knew is.

Why This Reframes the Platform Question

The usual framing of platform lock-in is defensive: how do I avoid being trapped? Graduation reframes it as something to arrange for rather than something to fear.

If the thing that has to survive a move is owned and portable from the start, then the execution platforms stop being traps and become options. A more capable runtime appears, and the agent can move to it. A platform's pricing changes, and the agent can leave. The newest model lands somewhere else, and the organisation can follow it without abandoning what it built. The platforms are not adversaries in this picture; they are destinations an agent can graduate to, each useful for what it does, none holding the organisation's intelligence hostage because that intelligence was never theirs to hold. The decision about where an agent runs becomes a decision about execution alone, which is the only thing it should ever have been about.