Can your agent's memory prove it did anything? Mine had to, on a clock, and I wasn't sure it would survive the test.
I've been building AFTERMATH: Recovery Block, a multi-agent society simulation, for the Global AI Hackathon Series with Qwen Cloud (Agent Society track). Survivor NPCs — a courier, a mechanic, a medic, a scavenger — live in a post-crisis town and negotiate scarce resources with each other across multi-round dialogue. A deterministic Game Master decides whether any trade actually happened: the agents can say whatever they want, but the economy can't be talked into existence. What they *can* carry forward is how the last deal went.
"Agent memory" is a phrase I've learned to distrust, including in my own code, because it's trivially easy to build something that looks like memory and does nothing. Here's the version most people ship: you keep the conversation transcript, you paste the last N turns into the next prompt, and you call it memory. Now watch what that does to two of my NPCs, rook and jax, after a parts deal between them falls apart. The next day they meet again — and jax opens at the exact same price, with the exact same friendliness, as if the walkout never happened. The transcript was *in the prompt*. It changed nothing, because nothing in that setup requires jax's behavior — his price, his wariness, his willingness to deal — to be a function of what rook did to him yesterday. That's not memory. That's a longer prompt.
Real memory has to survive a harder test: point to a specific decision that came out differently *because* of what was remembered. So I stopped storing transcripts and built the memory as its own loop, four steps:
Then I ran it for eight in-game days against the live Qwen integration — 46 Qwen calls, every focal decision on qwen-plus, no fallback shortcuts — and went looking for the one thing that would tell me it worked: the same two agents treating each other differently on day eight than on day two, for reasons I could trace.
rook and jax gave it to me. On Day 2 they tried to trade parts and it collapsed — no deal at 9 credits, both walked. The nightly consolidation wrote it down: rook's trust in jax dropped from neutral to -1, and jax's in rook to -1 too. On Day 3 they met for parts again, and this is the moment the whole project was built to produce: before offering anything, jax *inspected the goods first* — a wariness he'd never shown before — and then said, in his own generated dialogue, *"I'll take them at 7 — can't go higher, Rook, remember last time we walked away?"* rook answered *"9's my floor — remember Round 2? You walked out, and trust's still -1."* That "remember" isn't flavor text I wrote; the decision engine's memory trace for that turn cites the exact prior episode — jax-2-market-walked_out_on-2 — it was recalling. The deal failed again. Trust fell to -2.
It didn't stay a standoff, and that's the part I like most. On Day 4 the same pair finally closed — parts at 8 — because jax needed them urgently and the numbers finally worked. The grudge didn't blow up the economy; it just made the negotiation harder and warier while it lasted. Trust held at -2 through the middle of the run, and by Day 8 it had eased back to -1. A grudge that formed, deepened, survived a real trade, and slowly started to heal — six in-game days, all of it traceable to specific episodes.
The forgetting matters as much as the remembering, and it's easy to skip. By Day 4 the memory system had actively decayed the Day-1 rations trade out of the agents' working set — it stopped surfacing in what they cited when deciding. A memory that only accumulates isn't modeling a relationship; it's a hoarder that eventually can't tell what's still relevant. Letting old episodes fade is what keeps the recalled context about *now*.
Here's the honest part, because it's more useful than the highlight reel: my first version couldn't hold a grudge at all. The earliest live eval was relentlessly, boringly cooperative — every relationship drifted toward +1, nobody ever refused, nobody walked. I dug into why, and it wasn't the model or the prompt. It was the world: the economy guaranteed a zone of agreement always existed, so every negotiation closed, and there was no way for an agent to act in bad faith, so there was nothing to remember badly. I fixed the *situation*, not the wording — real scarcity so deals can genuinely fail, negative episode types like walked_out_on and short_changed and overcharged, and a recall rule that makes a burned agent open more carefully with whoever burned them. The grudge above is what those changes produced. That's the difference between prompting an agent to *sound* like it remembers and building a world where remembering *changes what it does*.
None of this is expensive by design: at most three focal NPCs get an LLM call per phase, every call capped at 140 output tokens, and with no API key at all the simulation still runs on deterministic rules instead of falling over. It's MIT licensed.
If you're building agents and you've been burned by "memory" that turned out to be a bigger context window, run the test I ran on myself: force a bad outcome between two agents and see if you can point to the exact later decision that changed because of it — with a citation, not a vibe. I published the full eight-day eval log so you can check mine: every day's trades, the belief-score diffs, and the cited memory traces behind each line of dialogue are in the eval report here. I'll keep building this past the hackathon; if that's useful to you, follow along.