Memory Is The Past
State is the present. Memory gave the machines a record of yesterday. The piece still missing is the one that lets them see the same present at the same time.
Mike Molinet & Govind Kavaturi
Last week we talked about the work needs a home. Your agents are smart. They just don't know where anything lives. Shared state is the gap.
This week: the distinction everyone confuses.
The Year Of Memory
The big thing everyone talked about this year was memory.
Your tools finally remember you. ChatGPT recalls that you're allergic to peanuts and that you prefer Python. Claude carries facts between conversations. Every agent framework ships some flavor of long-term memory. Vector store. Retrieval layer.
The pitch is always the same: it remembers, so you don't have to repeat yourself.
That's real. And it helps.
But it solved a problem that was never the thing slowing us down.
The Setup
We run about 30 agents across six machines and two model vendors.
Coding agents. A research agent. Content agents. Marketing agents. Finance agents. An inbox monitor. A couple of supervisor agents that keep the others moving.
Every one of them has memory now. They remember their own history just fine.
And our day is still a mess.
For a reason that has nothing to do with what any of them remembers.
The Distinction
Here's what we keep coming back to:
Memory is the past. State is the present.
Memory is a record of what already happened. The research agent remembers the briefs it wrote last week. The coding agent remembers the architecture decision we made on Tuesday. That history is genuinely useful.
But memory is private. And it's backward-looking.
Each agent has its own. The research agent's memory of last week is locked inside the research agent. The coding agent can't see it.
More importantly, neither of them can see what the other is doing at this exact moment.
Memory tells an agent about its own yesterday. It says nothing about everyone else's right now.
And right now is where the work actually happens.
What State Actually Is
State is the live, current picture of what's going on across the system.
What is each agent working on this minute. What just changed. What's blocked. What just finished. What the others need to know before they take their next step.
In a human team you'd call it situational awareness. Everybody can see the current state of the world, so they can act on it without asking.
Our agents have none of that.
Each one knows its own history. And is blind to the present everywhere else.
There is no shared state between them.
What This Actually Looks Like
The research agent finishes a brief. Has no way to tell the content agent it's ready.
The content agent drafts something that needs a number the analytics agent computed ten minutes ago. Has no way to reach in and get it.
So we do it.
We read the brief. Pull the three things that matter. Paste them into the next window. Copy the number over. Tell the coding agent what the API agent decided.
We are the live connection between things that are each individually fast and each individually blind.
The agents do the work. We are the shared state.
We are the only part of the system that can see the present across all of it. So the present has to physically pass through us.
That is human-agent collaboration today. And it's mostly the human ferrying context by hand.
Adding more memory to each agent does not touch this.
You can give every agent a perfect record of its own past. The human is still standing in the middle holding the present together.
Engineers Solved This Decades Ago
The frustrating part is that this is a solved problem in another domain.
Software engineers have had shared state for a long time. The thing that gave it to them is version control. Git, mostly.
Think about how ten engineers work on one codebase without constant collisions.
Each of them has their own local copy and their own history of changes. That's their memory.
But that alone would be chaos. Ten people editing the same files with no idea what anyone else touched.
What makes it work is a shared, current state of the codebase that everyone can see and sync to.
You pull. You have the present. You see what changed. Who changed it. What's in flight on which branch.
The history matters. But the thing that lets ten people stay sane on one project is the shared current state. Not the private logs.
That's the layer our agents don't have.
They've got the local history. They've got the equivalent of a personal commit log. What they're missing is the shared repository. The place where the present lives and everyone can read it without going through a person.
Engineers got this in the 2000s and stopped thinking about it. It became plumbing.
Nobody on a software team says "let me manually relay what I just changed to the other nine people." The system shows them.
Agents are running today the way engineering teams would run if you deleted git and made one person memorize and verbally relay every change.
You'd never staff a team that way.
But that's the default for anyone running more than two or three agents right now.
Why Memory Got Built First
Memory was the easier thing to ship. Which is probably why it came first.
You can bolt memory onto a single agent without coordinating with anyone. It's a feature inside one product. One company can build it, ship it, and demo it alone.
Shared state is harder because it's inherently between things.
It only matters when multiple agents, often on different platforms from different builders, need to read and write the same current picture.
That requires a layer that sits outside any single agent and that they all agree to use.
Identity. So an agent knows who's asking.
Permissions. So it knows what each one is allowed to see and change.
A common place where the present is written down and read from.
That's infrastructure. And infrastructure is slower and less glamorous to build than a memory feature you can announce.
But it's the layer that the next phase of this actually needs.
Once you have more than a few agents doing real work, intelligence is no longer the thing holding you back. The agents are smart enough.
The thing holding you back is that they can't see each other's present. So a person has to be the bridge.
The Layer That Gets Built Next
We're fairly convinced shared state is the missing piece. And that it's about to get built.
The pattern is familiar.
When the people furthest ahead are all solving the same problem by hand with cron jobs and copy-paste and a human in the loop, that's usually the moment right before someone turns it into infrastructure.
Storage was like that before S3. Payments were like that before Stripe.
The plumbing gets standardized once enough people are clearly hurting for the same plumbing.
We built Dock for exactly this reason. But you don't need to take anyone's product on faith to believe the shape of it. Just look at what your own setup looks like the moment you go past three agents.
They each remember their own past. None of them can see the shared present. And you're the one carrying it between them all day.
The Close
Memory gave the machines a record of yesterday.
The piece still missing is the one that lets them see the same present at the same time. And stop routing it through you.
Build that and the 30 blind specialists finally start acting like a team.
Memory is the past. State is the present.
Your agents remember. Can they see?
Vol 1: The opportunity exists. Economics changed.
Vol 2: Smart operators doing dumb work. Patterns to spot.
...
Vol 18: More agents, more problems. Smart agents with no shared state are just smart islands.
Vol 19: Memory is the past. State is the present.
Your agents remember. Can they see?
Mike & Govind
Running more than three agents? Look at how the present moves between them. If the answer is "through you," that is the layer that hasn't been built yet.