sugra.blog

Blog

Forty years of theory, one good compiler: agent architecture patterns

BDI was formalized in 1995, cognitive architectures are older still, and goal decomposition came from game AI. What changed is the runtime. On beliefs, desires and intentions finding their file extensions - AGENTS.md, specs, and skills - and how the old diagrams finally map onto a working agent loop.

Arman Obosyan - Founder and CEO of Sugra Systems
Founder & CEO

Arman Obosyan

Published
  • #engineering
  • #ai
  • #agents
  • #architecture
ShareXLinkedInFacebookTelegramRedditEmailCopy linkMarkdown
Forty years of theory, it finally compiles: the BDI cycle as a ring - teal beliefs fed by retrieval and tools, goals, amber intentions emitting actions, a memory stack of episodic, semantic and procedural slots in the center, and a dashed feedback loop labeled the world answers.

The agent boom feels new. The architecture is not. The philosophy of practical reasoning is from the 1980s, its formalization from the 1990s, goal planners from the game industry of the 2000s, memory models from cognitive science older than all of it. What never existed was a runtime that could read an unstructured world and write back into it. Now it exists, and the effect is strange to watch: the patterns did not change. They finally compile.

Beliefs, desires, intentions: the 1987 core

The BDI model starts with Michael Bratman’s 1987 work on practical reasoning and lands in engineering with Rao and Georgeff’s 1995 paper, “BDI Agents: From Theory to Practice.” The three primitives map onto today’s stacks with almost no translation.

Beliefs are the agent’s model of the world - not what is true, but what the agent currently holds true. In 2026 terms: everything retrieval and tool calls bring in, plus the standing knowledge of the project. Beliefs are volatile by design; updating them must not require redeploying anything.

Desires are declarative goals - descriptions of states the agent should bring about. This is the intent contract from the previous post in this series: not steps, destinations.

Intentions are the part everyone forgets: the plan the agent has committed to right now. The whole point of BDI is the balance Bratman called commitment with revision - an agent that reconsiders everything at every step never acts, and an agent that never reconsiders is a script with extra latency. Intentions persist until their goal is reached, becomes impossible, or the beliefs that justified them change. No reprogramming in between.

Goal decomposition: DDD for objectives

The second pattern decomposes goals into subgoal trees with automatic re-planning on failure. Its lineage runs through hierarchical task networks and GOAP, the goal-oriented action planning that game AI has shipped since the mid-2000s - the domain where “the plan broke, make a new one from the current state” was a frame-budget problem long before it was an enterprise one.

For engineers raised on Domain-Driven Design the analogy is direct: goal contexts instead of bounded contexts, subgoals instead of aggregates. And it scales the way organizations already scale: system architects hold the enterprise-level goals; tech leads do the same architectural work at service scale, with less business context and more local metrics - responsiveness, robustness, cost per request. One honest caveat: unlike BDI, this is a family of practices rather than a single canon. The discipline is in the decomposition contract and the reconfiguration rules, not in any framework’s class names.

Cognitive architectures: memory is the architecture

The most complete pattern adds the full thinking loop, and its map is the CoALA paper - Cognitive Architectures for Language Agents (Sumers et al., 2023), which transplants the Soar and ACT-R lineage into the LLM era. The load-bearing idea is the memory split: working memory versus long-term memory, with long-term divided into episodic (what happened), semantic (what is known), and procedural (how things are done). Generative Agents (Park et al., 2023) supplied the missing verb - reflection, the periodic compression of raw episodes into higher-level beliefs, forgetting the noise and keeping the lesson.

The practical translation is almost embarrassing: short-term memory is the context window. Semantic memory is the knowledge base behind retrieval. Episodic memory is distilled run logs. And procedural memory - the how - is exactly what last year’s standards turned into files.

The standards that shipped the theory

The 1995 diagram with file extensions: beliefs map to AGENTS.md, retrieval and MCP tools; desires map to specs with WHY, WHAT, HOW and goals as states; intentions map to SKILL.md, procedural memory and the loop

Beliefs, desires and intentions, mapped to the standards that shipped in 2025.

Specs are desires made durable. Spec-driven development moves the unit of work from code to a self-contained document - WHY, WHAT, HOW - from which the agent derives verifiable tasks and executes them stepwise. Kiro made specs first-class objects in the IDE last July; GitHub’s Spec Kit (September) formalized the specify, plan, tasks, implement cycle as plain markdown over thirty-odd agents.

AGENTS.md is the project’s standing beliefs. One markdown file with the conventions, the architecture, and the prohibitions, read by any agent that enters the repository. Born inside OpenAI’s Codex work, formalized in August 2025 with Google, Cursor and Factory, and in December donated to the Agentic AI Foundation under the Linux Foundation alongside MCP - with more than 60,000 repositories and twenty-plus tools on board.

Skills are the intention library. Anthropic’s Agent Skills (October, an open standard since December 18) package procedural knowledge as folders with a SKILL.md: instructions, resources, scripts, loaded through progressive disclosure so the context window pays only for what the task actually needs. MCP hands the agent its tools; a skill encodes when and how to use them - procedural memory, checked into git.

Say it as one map: beliefs live in AGENTS.md and retrieval. Desires live in specs. Intentions live in skills and the loop that executes them. The 1995 diagram now has file extensions.

Take home

Pick the pattern by what varies. If the world changes fastest, invest in beliefs - retrieval and context hygiene. If objectives change fastest, invest in specs. If procedures change fastest, invest in skills. Architecture is deciding where the volatility lives.

Memory is an architecture decision, not a feature. The episodic-semantic-procedural split determines what your agent can learn without retraining and what it will repeat forever. Systems that skip it re-derive the same conclusions on every run, at full token price.

Standards beat frameworks. Everything above - the specs, the beliefs file, the skills - is markdown in a repository, not an SDK to be locked into. The agent stack is converging on files, and files are the most portable dependency there is.

Agent architecture is not new. What is new is that the theory’s diagrams and your repository finally share a file system.

Reading

Integrate with one key across every product direction.

Get API keyDocsFamily