A standing team of AI agents that remember across sessions
Five specialized agents that remember
Five AI agents, each with its own job and a memory that lasts — so they pick up where they left off and build on past work instead of starting cold every time.
Most AI agents are solo and forgetful — you ask, they answer, they forget — so nothing they do ever builds on what came before.
Five role-specific agents sharing a memory that lasts, so they coordinate across sessions and build on their own past work instead of starting cold.
| Before | After | |
|---|---|---|
| Memory | none — each session starts cold | persists in a shared store across sessions |
| Number of agents | one, doing everything | five, each a specialist |
| How work continues | every interaction from scratch | picks up where the last run ended |
| Over time | no accumulation — nothing compounds | context builds, and it gets more useful |
| Character of the system | a tool you query | a team that remembers |
Agents go from disposable tools to a standing team. Memory plus role specialization is what turns 'ask and forget' into a system that piles up context and gets more useful over time. This is a small testbed for that idea, not a production product — but it makes the principle concrete: the leverage is in the loop, not the one-shot answer.
What I built
A five-agent system where each agent is a named specialist and the whole group shares a memory that survives between runs. "Stateless," the usual way agents work, means they keep no memory — every conversation starts from a blank slate. This flips that: the agents remember.
- Five specialists, not one generalist. Each agent has a defined role and handles its own kind of work, so the group divides a task instead of one agent trying to do everything. (Getting several agents to work together is what "multi-agent orchestration" means.)
- A shared memory that lasts. The agents read from and write to a shared local store — a simple on-device database — so context from one session is still there in the next.
- It picks up where it left off. Because the memory persists, the agents resume prior work rather than starting cold every time you come back.
- It compounds. Each session builds on the last, so the system accumulates context and gets more useful the more it's used.
This is a Claude-native experiment — it runs as AI routines rather than separate deployed software — in durable, role-based collaboration. It's a testbed, not a product.
Why it matters
The promise is an agent system that actually gets better the more you use it. Once agents remember and specialize, they stop being disposable tools you re-explain every time and become a standing team that carries context forward — which is what makes them genuinely useful for ongoing work, not just one-off questions.
That's the same idea behind the best systems I build for clients: the real leverage isn't a single sharp answer, it's the loop — every interaction feeding back in to make the next one better. This experiment applies that principle to the agents themselves, as a small, hands-on way to see how far memory and role specialization can take a team of agents.
The default AI agent is a goldfish: it answers, then forgets. That's fine for one-off questions and useless for anything that should build up over time. The interesting question was what happens when you give agents roles and memory at once — a small team that remembers. The hard part is the memory itself: a shared store (a simple local database) that lets five agents save context and read each other's, so the system survives across sessions instead of resetting. The honest open question is how much remembering actually helps before it starts to clutter — knowing where that line sits is part of what the experiment is for.
Persistence changes the character of agent systems entirely: once they remember and specialize, you get real compounding — every session makes the next one better. It's a small, honest testbed for the principle that the real leverage is in the loop, not the one-shot answer.
Still being explored: how much shared memory genuinely helps a group of agents versus how much it just clutters them — finding the line where remembering more starts to get in the way.