Procedural Memory: The Missing Leap in AI Agents

Harness and loops are required in any agent system today. Almost no one argues otherwise. The model reasons, the harness governs it, the loop executes and verifies without you having to hover over it.

But for us as a lab there is a third pillar that matters just as much, if not more. Memory.

Today, when people talk about memory in agents, they talk about two things. Short-term memory, the context of the conversation. And long-term memory, the facts the system remembers across sessions. On top of that there is a third category we don't even call memory: the workflows a person builds for the AI to execute.

That space is crowded. Workflows that people design and agents run. Systems that learn reusable routines from past trajectories and hand them back to the agent as guidance for its next generation. But they all share one thing. The LLM is still in the middle, interpreting and executing every step, burning tokens on decisions it has already made hundreds of times.

What if we could replicate what the human brain does?

The brain doesn't think about walking

Cognitive science described this more than 40 years ago. It's called Knowledge Compilation, and it's part of John Anderson's ACT-R architecture, one of the most studied theories of how human cognition works.

The idea is simple. When your brain does something for the first time, it thinks through every step consciously and effortfully. That is declarative memory. In AI agents, that means calls to the LLM. And therefore, token consumption.

But there comes a point when the human no longer has to think. They do it using procedural memory. It's like walking. You don't think "I have to move my leg, put one foot in front of the other." Or blinking. Or chewing when you eat. Your brain compiled that sequence into an automatic routine that fires on its own, and freed your conscious mind for what truly needs it.

That process of compiling expensive reasoning into automatic execution is exactly what AI agents are missing. Procedural memory is not just remembering a workflow. It is knowing when a workflow is stable enough to stop prompting and start executing.

Procedural Memory in production

That's what we have running in FusionAI today. We call it Procedural Memory. The muscle memory of your agents.

When a procedure is compiled, those steps run as deterministic runtime procedures. There are zero LLM calls on compiled steps: no inference and no token consumption on the specific steps the system has already learned. On compiled paths the LLM exits the loop entirely. It is only invoked again when a task escapes the learned procedure — when conditions change or the system encounters uncertainty it has not compiled away. The model is freed up for what actually requires reasoning, just like your mind when you walk.

And the best part: you don't have to build it yourself. FusionAI creates it based on your day-to-day work with it. It observes the repetitive patterns in real production behavior, runs several reviews, and determines whether that sequence is stable enough to be compiled into an executable routine that runs on its own. Just like your brain doesn't ask your permission to automate walking. It simply does it once you've learned.

Governance: what production actually requires

In a lab, "the agent learned a procedure and now executes it autonomously" is exciting. In a bank, it is an alarm — unless every part of that sentence is governed. Automating operations without controls is not infrastructure; it is risk. Procedural memory becomes enterprise-credible only when the lifecycle of a compiled procedure is as auditable and reversible as any other production system.

That is why compilation in FusionAI is wrapped in explicit controls:

• Versioning of compiled procedures. Every compiled routine is a versioned artifact. When the underlying behavior shifts, a new version is produced rather than silently mutating the running one, so you always know exactly which procedure executed a given operation.
• Confidence thresholds before compilation triggers. A pattern is not compiled the first time it repeats. Compilation only fires once the observed sequence clears a confidence threshold across enough real executions — stability is earned through evidence, not assumed.
• Human approval gates for sensitive workflows. Read-only or low-impact procedures can activate automatically. Anything that moves money, touches a customer of record, or carries real-world consequence passes through a human approval gate before it is allowed to run without the LLM in the loop.
• Audit trails. Every compiled execution is logged end to end: which procedure version ran, on what conditions it matched, what it did, and what it returned. The fact that the LLM was not involved on a step does not mean that step is invisible — it is fully traceable.
• Rollback capability. If a compiled procedure starts producing unexpected results, it can be deactivated and rolled back instantly, returning that path to full LLM reasoning while the procedure is reviewed.

Procedural memory without governance sounds like an agent that automates itself. Procedural memory with governance is controlled, intelligent automation — the kind regulated industries can actually put into production.

The frontier

We're not the only ones looking this way. AWM from CMU and MIT, NeSyPr at NeurIPS, Microsoft's Conductor. The best labs in the world are converging on this direction, and that confirms the path is right.

AWM is the clearest example of where this is heading. It induces reusable workflows automatically from past trajectories and provides them back to the agent to guide future generations. That is a real advance, and it is the ladder that makes the next step possible. But guiding the next LLM generation is the first step, not the destination. The workflow still lives as memory the model retrieves and interprets; the LLM remains the executor. The next leap is procedural compilation: when a workflow becomes stable enough, it should stop being prompt context and become an executable runtime procedure.

That is the distinction. AWM stores reusable workflows as memory and guidance, and the LLM still interprets and runs them. FusionAI compiles observed production patterns into executable runtime procedures that run directly — the LLM exits the loop on the steps the system has already learned.

	AWM (CMU/MIT)	FusionAI
What it learns	Reusable workflow patterns	Observed production sequences
Where it lives	Memory — guidance for the LLM	Executable runtime procedure
How it executes	LLM interprets and runs it	Runs directly, LLM exits the loop
LLM's role	Still the executor	Removed from compiled steps
Enterprise positioning	Research → production bridge	Governed production infrastructure

AWM opened the door. FusionAI crosses it into production. The difference comes down to two things. We run it in production, not on a benchmark. And the system compiles the procedures on its own, by watching you work, then governs their full lifecycle — without you having to design them.

A model working with harness, loop and procedural memory is a different class of system.

This is the category we are building: not procedural memory as a concept, but governed, executable enterprise infrastructure — agent experience turned into routines that are versioned, audited, approved, and reversible, running directly in production. We're at the frontier of memory, harness and loops. And we're just getting started — the leap ahead is ours to take.