More Agents, More Problems
They don't know where anything lives. The bottleneck isn't intelligence or memory. It's that the work has no home.
Mike Molinet & Govind Kavaturi
Your agents are smart. They just don't know where anything lives.
Last week we discussed how "co-piloting won't scale" — sessions accumulate, systems operate, and the objective is transitioning beyond co-piloting toward systematic approaches.
This week: the critical component that allows these systems to function properly.
The Setup
Your agents are smart.
They write code. They research. They draft content. They monitor inboxes. They scope features.
Individually, they're very good.
But here's what your day actually looks like:
Agent A finishes a research brief. Pings you. You read it, pull out what matters, paste it into Agent B's window. Agent B drafts something. You review it, realize it needs data from Agent C. Copy that. Bring it back.
Agent C needs context from Agent A's work. But Agent C doesn't know Agent A exists.
The work has no home.
The Real Bottleneck
Vol 15 identified you as the bottleneck. Intelligence isn't the limitation. Coordination is.
This is the deeper layer.
The bottleneck isn't the model. It's that there's no shared place the work lives.
Each agent lives in its own context. The human becomes the bridge that carries state between them. You're not doing work. You're routing messages between things that do work.
It doesn't scale.
More Agents, More Islands
One agent? Easy. You're the context.
Three agents? Manageable. You can hold it in your head.
Ten agents? You're drowning.
Each agent is an island. Smart island. Capable island. But island.
No shared state. No awareness of each other. No single source of truth.
The only thing connecting them is you. Copy-pasting between windows. Remembering which agent knows what. Manually bridging every gap.
The Question Nobody Asks
Where does the work actually live?
Not the prompts. Not the outputs. The work.
The plans. The decisions. The drafts. The tasks. The contributions.
Where is the canonical version? Who owns it? Who can read it? Who can write to it?
For most builders, the answer is: nowhere. Or everywhere. Which is the same thing.
Two Layers People Conflate
"Agent memory" bundles two different problems. Most solutions only solve one.
Layer 1: Retrieval.
What one agent recalls. Redis. Vector DBs. Embeddings. Fuzzy lookup.
Single-agent. Useful. But not the gap.
Layer 2: Shared work-state.
Where the work lives across agents. Plans. Tasks. Drafts. Decisions. Contributions.
Multi-actor. Attributed. Inspectable. Current.
Humans and agents on the same surface.
This is the gap.
Four Failure Modes
Every pain people report traces back to missing shared, attributed state.
Memory rot.
Writes with no source, scope, or timestamp. Stale entries quietly win retrieval. Nobody knows what's current.
Lost handoffs.
No shared record carries context across agent-to-agent or agent-to-human handoff. Every handoff is a fresh re-explanation.
Infinite loops.
Two agents modify the same thing. Neither treats the other's change as authoritative. They loop forever. The max-iteration knob caps a symptom, not the cause.
Human-as-recovery.
No visible record. Oversight means reconstructing what happened after it breaks. That's not reliability. That's operational debt.
Same root cause. No shared state.
Shared State Without Provenance Is Shared Ambiguity
Shared state alone isn't enough.
If you don't know who wrote it, when, based on what, and whether it's authoritative, you have shared ambiguity.
Four questions every write should answer:
Who. Human or which agent wrote this?
When. And is it still current?
Based on what. What input produced it?
Authority. Can another agent treat it as truth?
Without provenance, every write is a guess sitting next to a fact. No way to tell which is which.
What This Looks Like
The fix is one shared, attributed state that humans and agents both read and write.
Not a chat window. Not a vector database. A surface.
Plans land there. Tasks land there. Drafts land there. Decisions land there.
Every contribution attributed. Every change timestamped. Every actor visible.
Agents read from it. Agents write to it. Humans read from it. Humans write to it.
One home for the work.
We built this for ourselves. Dock, our latest from the lab. A workspace where humans and agents share the same state.
The Framework
Building shared state for your agents:
Step 1: Define what "the work" is.
Plans. Tasks. Drafts. Decisions. Outputs. What needs to persist across agents?
Step 2: Choose the home.
A shared workspace. A database. A doc. Something all agents and humans can read and write.
Step 3: Attribute every write.
Who wrote it. When. Based on what. Authority level.
Step 4: Define ownership.
Who owns what? Who can modify? Who is authoritative?
Step 5: Build the handoffs.
Systems run. The handoff from one agent to the next should read from shared state, not from you copy-pasting.
Step 6: Make it inspectable.
Oversight should be a glance, not an investigation. If you can't see what happened, you can't trust it.
The Close
Your agents are smart.
But smart agents with no shared state are just smart islands.
The bottleneck isn't intelligence. It's not memory. It's coordination.
And coordination requires a home for the work.
Where does your agents' work actually live?
Vol 1: The opportunity exists. Economics changed.
Vol 2: Smart operators doing dumb work. Patterns to spot.
...
Vol 17: Co-piloting won't scale. Sessions build. Systems run.
Vol 18: More agents, more problems. Smart agents with no shared state are just smart islands.
Where does the work actually live?
Mike & Govind
Running multiple agents? Ask yourself: where does the work actually live? If the answer is "in my head" or "across 12 tabs," that's the problem. Give the work a home.