Your Agent Framework Was Specified in 1990 (And Is Missing the Same State)

Mostafa Dhouib·September 5, 2026·7 min read

Your Agent Framework Was Specified in 1990 (And Is Missing the Same State)

The short answer. The word agent is being used as though it were coined in 2023. It was formally specified in 1990, by Cohen and Levesque, in a definition of persistent goal: an agent believes the goal is not yet true, wants it to become true, and maintains that commitment until it believes either that the goal has been achieved or that it can never be achieved. That second exit is the terminal state every framework in production today is missing. It is not a new insight waiting to be discovered. It has been sitting in the field's flagship journal for thirty-six years.

There is a particular frustration in watching an industry rediscover, expensively, something that was written down carefully before most of the people rediscovering it were born.

This is that case. And the gap between what was specified and what shipped is not academic: it is the reason your agent reports success when it ran out of budget.

What was actually specified

The 1990 definition of a persistent goal has three parts, and the third is the one that matters.

An agent holds a persistent goal when it believes the goal is not currently achieved, it wants the goal to be achieved at some point, and it maintains that commitment until one of two beliefs becomes true: that the goal has been achieved, or that the goal is unachievable.

Read the third clause again, because everything follows from it. Commitment is not unconditional. It is held until one of two exits, and the definition names both of them explicitly. Achieving the goal is one way to be finished. Concluding it cannot be achieved is the other, and it is equally a terminal state rather than a failure of the agent.

That is a formal specification of giving up, published in 1990.

What shipped instead

Every current framework has two terminal states. Done, and killed.

When a run exhausts its iteration budget, it stopped for the second reason in the 1990 definition: it did not achieve the goal, and it has no remaining path to achieving it within its constraints. That is precisely the specified case.

But the function still has to return something, and the type system offers two options: a result, or an error. It did not error. It ran out of budget while making perfectly reasonable progress.

So it returns a result.

"Stopped because I gave up" and "stopped because I am done" are different facts about the world, and they arrive at the caller as the same type carrying the same shape. Every layer downstream believes the second one, writes it to a database, sends it to a customer, or feeds it into step six of a chain where it becomes a foundation.

The framework did not fail to implement something difficult. It failed to implement something that had been specified for it, precisely, decades earlier.

This is not one paper

If it were a single overlooked paper, the omission would be forgivable. It is a body of work, and the neighbouring results are, if anything, more directly useful.

Plans exist to foreclose deliberation

Bratman's 1987 argument for why agents have plans at all is that a plan is a commitment that stops you re-deciding. Its function is to remove options from consideration so you can act rather than continuously re-evaluate.

Which produces a sharp test for anything calling itself an agent: an agent that reconsiders its intentions every single turn does not have intentions. It has opinions.

That describes the default loop of every framework in the audit. Each turn re-reads the whole context and re-decides from scratch. There is no commitment, so there is nothing to abandon, so there is no moment at which abandoning becomes the right call.

And somebody ran the experiment

In 1991, Kinny and Georgeff did not merely theorise about this. They ran it, across two axes: how fast the world changes, and what deliberation costs.

Bold agents commit to a plan and rarely reconsider. They win when the world changes slowly, because reconsidering costs more than it gains.

Cautious agents reconsider constantly. They win when the world changes fast, because a stale plan is worse than the cost of re-planning.

Now place a modern LLM agent on that chart. It reconsiders the entire plan on every step, which is maximally cautious behaviour. It does so at the highest deliberation cost of any system on the chart, because each reconsideration is a forward pass you pay for in money and latency. And it typically operates in a slowly changing environment: your codebase is not moving while the agent thinks.

Maximum deliberation cost, maximum reconsideration frequency, slowly changing world. That is the corner of the chart the 1991 experiment identified as the worst place to be, and it is where the default configuration puts you.

Why the rediscovery keeps happening

It is worth being fair about this rather than smug, because the reason is structural.

The 1990 work is in the agent literature, which grew out of symbolic AI and planning. Modern agent frameworks grew out of language modelling, which has almost no overlap in citation graph, conferences, or vocabulary. The word "agent" is the same and means something related, but the two communities genuinely do not read each other.

That is the same pattern as the stopping rule itself: seven fields arriving independently at the requirement for a model of the task, none citing the others. Independent rediscovery is strong evidence that a requirement is real. It is also expensive, and reading across is much cheaper than rediscovering.

What to take from a thirty-six-year-old paper

Three things, all implementable this week.

Implement the second exit. Your agent needs a terminal state meaning "I believe this is not achievable within my constraints", distinguishable at the return type from success. Not a field inside a success object, which every caller will forget to check, because the type told them they did not have to.

Give it something to be committed to. If the loop re-decides everything each turn, it has no intentions to abandon. A plan the agent holds across steps, and revises deliberately rather than continuously, is what makes abandonment a meaningful event rather than an accident.

Match reconsideration frequency to your world. If your environment changes slowly, and most do, re-planning on every step is buying nothing at the highest available price. Reconsider on a trigger, such as a failed precondition or new information that contradicts the plan, rather than on a clock.

The definition is thirty-six years old, it is precise, and it is free. Being the first team on your floor to implement it is not a research project.

FAQ

What is a persistent goal in agent theory? A formal definition from Cohen and Levesque in 1990: an agent believes the goal is not yet achieved, wants it achieved, and maintains that commitment until it believes either that the goal has been achieved or that it is unachievable. That second condition is an explicit terminal state for abandoning a goal.

Why does my agent report success when it ran out of budget? Because it has only two terminal states, done and killed, and exhausting a budget is neither an error nor a completion. The function still has to return, so it returns a result, and every downstream layer reads that as a finished answer. The missing third state was specified in 1990.

What is the difference between a bold and a cautious agent? A bold agent commits to a plan and rarely reconsiders; a cautious agent reconsiders constantly. Kinny and Georgeff showed in 1991 that bold wins when the world changes slowly and cautious wins when it changes fast. An LLM agent reconsiders every step, at maximum cost, usually in a slowly changing environment, which is the worst corner of that chart.

Does an agent that replans every turn have intentions? On Bratman's account, no. A plan exists to foreclose deliberation, meaning to stop you re-deciding. An agent that reconsiders everything each turn has never committed to anything, so it has opinions rather than intentions, and there is no commitment for it to meaningfully abandon.

Why didn't modern frameworks implement this? The 1990 work sits in the symbolic agent and planning literature, while modern frameworks grew out of language modelling. The two communities share the word but not the citation graph, the conferences, or the vocabulary, so the result was independently rediscovered rather than read.