Declarative vs Procedural Memory for AI Agents

Most AI agent memory systems today mostly solve declarative memory. They save facts, user profiles, conversation transcripts, and documents.

When an agent needs to act, it retrieves those facts. That is a helpful start, but it leaves out the part of memory that turns knowledge into skilled behavior.

Human cognition also relies on procedural memory: knowing how to do things.

If an AI agent only holds declarative facts, it acts like a person who has read a book about driving but has never touched a steering wheel. It can cite the rules of the road, but every turn requires slow, explicit reasoning.

To build reliable agents, we need both.

The Cognitive Split

Cognitive science separates knowledge into two distinct structures:

Memory Type	What It Holds	Human Example	AI Agent Example
Declarative memory	Facts, events, and explicit knowledge: the "what"	"Paris is the capital of France"	"User prefers brief email updates on Mondays"
Procedural memory	Habits, skills, and execution rules: the "how"	How to ride a bicycle	"When an API returns a 429 rate limit, back off and retry with scope X"

In Carnegie Mellon's ACT-R cognitive architecture, this split is foundational:

Declarative memory holds chunks: structured records of facts and experiences.
Procedural memory holds production rules: condition-action rules that can fire when the current state matches their conditions.

Why Agents Fail Without Procedural Memory

When builders rely on vector search over prompt history, they make the model re-derive action steps from context instead of recalling how the work is usually done.

Consider a customer support agent handling a refund escalation:

With declarative memory only: The agent retrieves the customer's purchase history and past chat summaries. It re-reads the raw text, re-evaluates the refund policy prompt, and tries to infer which tool call should come next.
With procedural memory: The agent matches the current state (Goal = refund, Customer tier = VIP, Order age < 30 days) to a learned production rule (Invoke instant refund tool, trigger email receipt, update CRM ticket).

Without procedural memory, agents tend to fail in three predictable ways:

Higher latency: The model re-reads long context and reasons through routine steps from scratch.
Execution drift: Small prompt changes lead to different tool choices for the same task.
Retry loops: When an error occurs, the agent repeats the failed step because it lacks a rule for handling that state.

Chunks and Production Rules in Practice

In an ACT-R-inspired memory system, declarative chunks and procedural production rules interact in a continuous loop:

text

               ┌───────────────────────┐
               │    Production Rules   │
               │   (Procedural Memory) │
               └───────────┬───────────┘
                           │
                           ▼
                   ┌───────────────┐
                   │    Buffers    │
                   │ (Active Goal) │
                   └───────┬───────┘
                           │
                      retrieval
                           │
                           ▼
               ┌───────────────────────┐
               │   Declarative Chunks  │
               │  (Declarative Memory) │
               └───────────────────────┘

Goal buffer: Holds the active task, such as resolving a billing dispute.
Retrieval: Pulls the most active declarative chunk, such as user account status.
Production selection: Matches the goal and retrieved chunk against procedural rules.
Action execution: Fires the selected production rule, updating state or triggering an external tool.

Building Procedural Memory into AI Systems

To add procedural memory to an AI agent stack, move beyond generic vector databases.

Separate facts from execution rules. Store user context and domain facts as declarative chunks. Store tool workflows, error handlers, and retry policies as condition-action rules.
Bind rules to goal state. Trigger procedural rules from active buffer state, not raw text similarity alone.
Reinforce successful workflows. Strengthen production rules when they complete tasks successfully, so the agent can prefer them in future runs.
Keep review in the loop. A bad rule can become a bad habit. Production rules need provenance, human review, and a way to decay or suppress stale behavior.

The Takeaway

Saving text in a database gives an agent a reference library. It does not give the agent skill.

Declarative memory answers what the system knows. Procedural memory determines how the system acts.

Agents become more reliable when those two forms of memory work together: facts available at the right moment, and learned rules for what to do next.