30-Year-Old Theory, Modern Problem: Why BDI Agents Are the Missing Framework for AI Planning

In 1995, Anand Rao and Michael Georgeff published a paper called "BDI Agents: From Theory to Practice" . It went on to accumulate nearly 4,000 academic citations and became the foundational reference for the entire field of multi-agent systems. The problem it was solving: how do you build a computer system that can act rationally in a complex, dynamic environment — air traffic control, medical services, space vehicles — without requiring a human in the loop for every decision?

Thirty years later, we're asking the same question about LLM-based agents. And the answer Rao and Georgeff gave in 1995 is still largely correct — and largely ignored by most AI tooling built in the last two years.

What BDI Actually Says

The Belief-Desire-Intention model says that a rational agent has three distinct types of mental state, and each plays a different role:

That last point — intentions must remain consistent with beliefs — is the core rationality constraint of the entire model. It seems obvious when you say it out loud. An agent shouldn't execute a plan based on information it now knows to be wrong. But almost no AI planning tool enforces this automatically.

The Gap in Modern AI Planning

Here's how most AI-assisted planning tools work today: you create a plan (intentions), you add notes and context to a knowledge base (beliefs), and agents execute tasks. These are treated as three separate, disconnected systems.

The belief store and the intention store don't talk to each other. When new information arrives — a constraint is discovered, a dependency changes, a prior assumption is invalidated — the plan doesn't automatically know. A human has to notice the contradiction, understand its implications, and manually update the relevant tasks.

This is fine when you have one agent doing simple tasks. It breaks down when you have:

• Multiple agents working in parallel on different parts of a plan
• A knowledge base that grows over time with findings from previous work
• Long-running plans where assumptions made at the start may no longer hold
• External information (research, market data, technical constraints) arriving continuously

In short: it breaks down for any serious use of AI agents on real work. You end up with agents executing stale plans while the knowledge base quietly tells a different story.

"The design of systems that are required to perform high-level management and control tasks in complex dynamic environments is becoming of increasing commercial importance."

The BDI Decision Cycle Is Already in AgentPlanner

Here's what struck us when we mapped the BDI model onto AgentPlanner: the structural components are already there. They just aren't formally connected.

The BDI decision cycle — perceive, update beliefs, generate options, select intentions, execute, repeat — maps directly onto the AgentPlanner agent loop: poll for tasks, search knowledge graph, evaluate plan, claim task, execute, log progress, repeat.

What's missing is the automatic connection between step 2 (update beliefs) and step 3 (select intentions). In formal BDI, these are tightly coupled: every belief update triggers a coherence check against current intentions. In AgentPlanner today, they're decoupled — a human has to manually bridge the gap.

Three Things We're Building

Based on this analysis, we're adding three BDI-inspired systems to AgentPlanner:

The Knowledge Loop: BDI Meets Karpathy

The Knowledge Loop is where the 1995 theory and the 2026 experiment converge. Karpathy's autoresearch ran a tight loop: modify code → evaluate metric → keep or discard → repeat. The insight was that an agent with a clear metric and a modifiable artifact can improve continuously without human intervention.

The BDI model explains why this works: the agent is continuously aligning its intentions (train.py changes) with its beliefs (experimental results) toward a desire (minimize val_bpb). Each iteration is a mini belief-update cycle. When the new code makes loss go up, that's a belief update — the agent discards the intention and tries again.

For planning, the loop looks like this:

The plan quality score is the val_bpb of planning. It's a proxy metric that any agent can compute without human input: does every task map to the goal? Do tasks have unambiguous acceptance criteria? Are dependencies explicit? Are knowledge gaps filled?

A plan that scores 0.9 on all four dimensions is a plan an agent can execute confidently without asking clarifying questions. That's the metric worth optimizing for — and it's automatically evaluable.

Why This Matters Beyond AgentPlanner

The BDI model isn't just useful for AgentPlanner — it's a framework for evaluating any AI agent system. When you look at an AI agent and ask "why did it do something unexpected or wrong?", the BDI model gives you three precise places to look:

Most agent failures in the wild are type 1 or type 3. The agent had outdated context, or it committed to an action without checking whether its current knowledge still supported it. BDI gives you the vocabulary — and the architecture — to prevent both.

Standing on 30 Years of Shoulders

There's something intellectually satisfying about discovering that a paper written when the internet was young and LLMs were science fiction turns out to be the right framework for a problem we thought was new. Rao and Georgeff were thinking about air traffic control and medical systems; we're thinking about software planning and business operations. The domain is different. The problem is identical.

Build a system capable of rational behaviour in a complex, dynamic environment. Make sure its actions remain consistent with what it knows. Give it a way to update its plans when its knowledge changes. Don't let it execute stale intentions.

That's BDI. And it's exactly what good agent planning needs to be.