An experiment with six programmed AI-agent policies revealed something unexpected: remembering previous failures can make future decisions worse.
One of the most common ideas in AI development is that memory makes agents more capable.
Give an agent previous observations, past mistakes, and enough context, and it should make better decisions next time.
That sounds reasonable.
But I became interested in a different question.
What if the agent remembers something that never actually happened?
I explored this through a small Python simulation inspired by Squid Game. Six programmed decision-making agents competed across five different challenges.
The agents weren't commercial LLMs like GPT or Claude. They were transparent Python policies built for controlled experiments, allowing me to inspect the rules behind every decision.
And the most interesting result came from the Glass Bridge.
The Bridge Wasn't Really About Glass
The bridge contained twenty panels. Each panel had two possible tiles, but only one was safe.
The agents couldn't see the correct tile directly. Instead, they received imperfect clues.
When one agent stepped on a wrong tile, the next agent could use that failure as information.
For example:
- Agent A chooses the left tile.
- The left tile breaks.
- Agent B receives a report saying the left tile failed.
- Agent B uses that information to choose the right tile.
This is a basic form of learning from shared experience.
I compared two conditions: agents with access to previous failure reports and agents without that memory.
Both conditions used the same hidden bridge configurations and clue draws, making the comparison more meaningful.
With reliable failure reports, memory helped.
Across the initial 250 seeded environments, memory added an average of 0.586 correct decisions out of twenty.
It wasn't a dramatic improvement, but it showed that earlier observations could provide useful information.
Then I changed one variable.
What Happens When the Memory Is Wrong?
I introduced controlled corruption into the reports shared between agents.
Sometimes the report incorrectly claimed that the opposite tile had failed.
The agent wasn't told the information had been corrupted.
It simply received a previous observation and followed its programmed decision policy.
I repeated the experiment with 500 seeded bridge environments at each corruption level.
Here are the measured results:
| Corrupted reports | Average memory benefit |
|---|---|
| 0% | +0.613 |
| 10% | +0.394 |
| 25% | +0.028 |
| 50% | −0.547 |
| 75% | −1.112 |
| 100% | −1.676 |
The values represent the average difference in correct choices out of twenty between memory-enabled and memory-disabled policies. They are not commercial LLM accuracy scores.
Notice what happened.
At 0% corruption, memory improved performance.
At 25%, the benefit had almost disappeared.
At 50%, memory was actively hurting the agent.
The system hadn't lost its ability to make decisions. It was using the information it had been given.
The problem was that the information was no longer trustworthy.
This is the part I found most interesting.
An agent can follow its decision rules correctly and still make a worse decision because the evidence behind those rules is unreliable.
Why This Matters Beyond a Game
Consider a coding agent working with previous build logs.
It remembers that a particular dependency caused an earlier failure.
But what happens if that log was incomplete, outdated, or incorrectly attributed the failure?
The agent might keep modifying the wrong dependency.
Or consider an AI assistant using retrieved documents.
A previous conversation says that a configuration is valid. The assistant retrieves that information and applies it to a new task, without recognizing that the context has changed.
In both examples, remembering information isn't the same as verifying it.
The same engineering question appears in multi-agent systems, retrieval-augmented generation, and long-running autonomous workflows:
When should an AI system trust its memory, and when should it question it?
The bridge experiment doesn't answer that question for real language models.
It does demonstrate a measurable failure mechanism inside a controlled simulation.
And it suggests several useful directions for future experiments: attaching confidence to memories, preserving evidence provenance, detecting contradictions, and checking whether retrieved information still applies to the current task.
The Experiment Is Reproducible
The project contains six programmed decision policies, five challenges, event logs, an independent evaluator, and statistical stress tests.
The five rounds test different engineering behaviors:
Red Light, Green Light: Whether agents respect cancellation signals.
Dalgona: Whether outputs obey strict serialization requirements.
Tug of War: Whether decisions follow evidence rather than unsupported claims.
Marbles: Negotiation with incomplete information.
Glass Bridge: Learning from previous observations, including unreliable ones.
The implementation uses Python and does not require a paid LLM API.
You can inspect the code, examine the saved results, or reproduce the experiments here:
https://github.com/HAYANAN-T/squid-game-ai-agents
The Question I'm Still Interested In
Memory is often treated as an improvement to AI systems.
But memory also introduces another dependency: the system must decide which historical information deserves to influence its next action.
In my simulation, unreliable observations eventually turned memory from an advantage into a disadvantage.
That doesn't establish a universal corruption threshold. The outcome depends on the policies, clues, environment, and scoring rules.
Still, it reveals a useful distinction.
An agent that remembers more isn't necessarily an agent that understands better.
I explored the complete Squid Game simulation, the five rounds, the agent behaviors, and the memory-corruption experiment in a longer technical article on Medium.
Read the complete investigation:
https://medium.com/@hayanan/6-ai-agents-entered-squid-game-memory-became-the-trap-3a50438fb373
I'm particularly interested in how other developers handle unreliable memory in autonomous agents.
Would you let an AI agent make decisions from its previous observations without checking whether those observations are still reliable?
Research note: This article describes a controlled simulation using programmed Python policies, not a benchmark of commercial language models. Drafting and editing were AI-assisted; the cited repository contains the reproducible experimental evidence.
Top comments (0)