AchiralAchiral

Concepts · Humans and machines

A deployment goes wrong, a workaround succeeds, and then the process changes. How Achiral’s ACT-R memory uses past experience without getting stuck in it.

Published2026-10-290 reads

Review pending. Report issues to editor@achiral.ai.

How Achiral's ACT-R Memory Remembers and Forgets

Achiral's ACT-R memory is a memory layer that reuses past experience when it applies and lets it fade when it no longer does.

Imagine an AI agent helping a team deploy a service. A release stalls. An engineer finds a stale lock left behind by the deployment runner, the tool that runs the release. After checking that no deployment is active, the engineer clears the lock and retries. The release succeeds. Next time this happens, the agent should have a better idea of where to look.

A week later, the same runner stalls again. A month later, the team replaces it with one that handles locks differently. The old fix has gone from useful to inappropriate, even though the incident report is still perfectly accurate.

That’s the problem we want Achiral’s ACT-R memory to handle: learn from what happened, then change when the lesson no longer applies. This made-up deployment follows our approach to emergent memory through remembering, reuse, correction, and forgetting.

What should the agent take away?

“Clear the lock” is a dangerous thing to learn from this incident. It leaves out the runner, the error, and the check that made clearing the lock safe.

The agent needs those details together. It should be able to recall what happened and use that experience to decide what to check next. The ACT-R and AI Memory chapter discusses how experience can supply both content to learn and examples of decisions made under particular conditions.

Saving a report is a start. But if the agent approaches the next identical failure exactly as it did the first, the report hasn’t helped yet. We want the experience to leave a lasting change in how the system works. That’s what we mean by memory: past experience changes future behavior, responses, or internal dynamics.

A database, knowledge graph, or vector store can hold the evidence and help retrieve it. The question is what changes through using that evidence. Our article on memory and storage goes further into that distinction.

The same error shows up again

The next stalled release gives the agent something to go on. Same service, same runner, same error. Those cues should help bring the earlier incident back into consideration. A question about an unrelated service should have much less reason to do so.

ACT-R gives us a way to describe this. It represents declarative knowledge as structured units called chunks. A chunk’s activation affects how readily it can be recalled. Recent and repeated use contributes to activation, as does the current context. Retrieval requires enough activation to cross a threshold.

With retrieval noise enabled, recall is probabilistic. The same request can sometimes retrieve a chunk and sometimes fail, even though the chunk is still stored. Daily and colleagues describe these retrieval mechanisms.

For our agent, the point is practical. The earlier incident should help it recognize a familiar problem and propose the safety check before anyone touches the lock. The deployment is an illustration of how we want to use these mechanisms, not a report of a measured result.

A fix that worked can become a habit

Suppose the team confirms the same fault again. The engineer checks for an active deployment, clears the stale lock, and verifies that the release completes. Now there’s another successful use of the workaround under the same conditions.

In ACT-R, recent and repeated use can make a memory easier to recall. For an AI system, we also want to know whether the recalled advice actually helped. Suggesting a fix, trying it, and confirming that it worked are three different events.

Otherwise, the agent can get stuck repeating itself. It suggests clearing the lock because it suggested that yesterday, then treats today’s suggestion as more evidence for tomorrow. A bad idea becomes familiar without becoming any better.

We need to check the outcome. If the agent starts finding the right cause sooner while keeping the safety check, the experience is helping. An activation score going up doesn’t tell us that on its own.

Then the team replaces the runner

The new runner manages its own locks. The old manual workaround is no longer approved.

We still want the agent to explain last month’s outage. We just don’t want it recommending last month’s fix for the new tool. It needs to connect the process change to the earlier experience and stop applying that workaround where it no longer belongs.

That’s revision. The old incident stays available as history, while the new procedure guides current work. If another service still uses the old runner, the workaround might remain appropriate there. “Use the newest document” is too crude a rule to handle both cases.

This is why the conditions mattered from the beginning. A lesson tied to a particular runner can be corrected when that runner changes. A loose instruction to clear locks is much harder to use safely.

The old fix can fade without disappearing

Eventually, the team stops using the old runner. Its workaround has less reason to come up in daily work.

ACT-R models one part of this through decay: as time passes, earlier uses contribute less to a chunk’s base-level activation. It may fall below the retrieval threshold while remaining stored. The ACT-R research linked above describes how decay affects recall. A later investigation can supply cues that make an old incident accessible again.

So forgetting needn’t mean erasing the report. An experience can lose its influence on ordinary decisions while remaining available for a historical question.

There are limits to relying on that. If someone loses permission to read an incident, access must be blocked explicitly; making it unlikely to be recalled is not enough. And a rarely used disaster-recovery procedure may be vital. Keep a maintained runbook that the agent must consult rather than hoping frequency of use will reflect importance.

Try it on the next deployment

We can test the story with cases involving the old runner, the new one, and an unrelated fault. Compare what the agent does before the first incident, after successful reuse, and after the process changes. Because recall can vary, repeat the trials and record the settings.

Does the agent recognize the familiar failure? Does it keep the safety check? When the runner changes, does its advice change too? Can it still explain the old incident when someone asks about it?

Those questions tell us more than how many records the system retained. We also need to be able to inspect which experience influenced a recommendation, where it came from, and how to correct it.

The language model’s weights can stay fixed through these changes in recall. Experience can also feed a separate training process, as we discuss in Organic AI Memory. If it does, changing the memory record won’t automatically undo training already performed on it.

At the next release, the agent should check which runner it’s dealing with before proposing a fix. The team shouldn’t have to teach the same lesson again—or keep reminding it that the lesson has changed.

FAQ

What is Achiral’s ACT-R memory?

It’s Achiral’s ACT-R-inspired approach to memory that changes through experience. Past use and current cues affect what the system recalls; corrections change how earlier lessons apply. Our Emergent Memory Systems essay explains the broader idea: experience leaves a persistent change that affects future behavior, responses, or internal dynamics.

Does forgetting mean deleting information?

Not always. Something can become harder to recall while its record remains stored. Deletion removes the information; decay reduces its accessibility. Access restrictions still need to be enforced directly.

Why not keep every experience?

Keeping extensive records can be useful. The trouble starts when outdated or unrelated experiences keep steering current work. Retaining a report and letting it influence today’s decision are different choices.

How does ACT-R make recall probabilistic?

ACT-R uses activation, a retrieval threshold, and configurable noise. With noise enabled, a chunk can be recalled on one attempt and missed on another. Use history, elapsed time, and context affect its activation. Easy recall doesn’t make a memory true.

How is this different from RAG?

Retrieval-augmented generation brings retrieved material into a model’s answer. Here, we’re asking how experience changes what gets recalled and what the system does later. RAG can be part of that process. The RAG vs ACT-R Memory for AI comparison explains the distinction.

Does memory require updating model weights?

No. Recall can adapt while the language model’s weights stay fixed. Training on selected experience is another way to learn, and the two can work together. Correcting a memory record doesn’t automatically change weights trained on it.