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.
Stateless one-shot agents that forget → a standing team of agents with memory.
| 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.
- 01Assign roles
Five agents are set up, each a named specialist with its own kind of work rather than one agent doing all of it.
- 02Coordinate
The agents work together on a task, dividing it across their roles instead of duplicating each other.
- 03Remember
What happens gets saved to a shared local store, so context survives after a session ends.
- 04Resume
On the next run, the agents read that memory and pick up where the last one left off instead of starting cold.
- 05Compound
Because each session builds on the last, the system accumulates context and gets more useful the more it's used.
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.