Rent the intelligence. Own your Common. It's a synced folder that holds the state of all your projects as they evolve, each shared with the people and devices that should see it — a place their agents and yours can work together.
01 Where this starts
The thing you can't do with agents today is collaborate with others
The one thing nobody can work around today: your agents can't collaborate with other people's agents.
Everyone keeps their context their own way: some files, a few shared docs, a project repo, a personal wiki, a thread or two. They point their own AI at it. The moment two people work the same problem, there's no shared place that context can live, so they fall back to the old motions: mail a doc around, paste state into a chat, let each agent re-derive what the other's already figured out.
The same gap is why a lone agent feels starved for context and forgets between sessions. Three symptoms, one cause: no shared place the work lives.
02 What's in a Common
Five components, one cloud
A Common is one filesystem, and everything in it is one of five Common Components, all routing through a single hub: the Common Cloud. Start with the hub.
The Common Cloud
The hub every Common routes through
It sits between your local Common, a full working copy, and everything else: your machines, collaborators, and connected sources. It mediates sync the way Dropbox does and decides who can read what. Background jobs run here too: the nightly dream cycle improves your state while you sleep.
Hub
Common Knowledge
On-demand mirrors of the sources you reference, local and grep-able
Docs, Sheets, Gmail, Calendar, Notion, Slack, Linear: the apps a person or a small team already lives in. Pull one in and the cloud keeps a local copy current on every machine, so the agent greps it at filesystem speed instead of round-tripping a connector. Lazy by design: nothing syncs until you reference it — not your whole Drive, just what you reach for.
Flows in
Common Ground
The agents' own evolving work, the project's record
Strategy, findings, running state, the markdown and static HTML that accumulate as you work: the project's source of truth, not a memory file off to the side. It fixes the agent forgetting between sessions.
Flows out
Common Harness
Your harness's own state, no longer locked to one
Sessions, memory, custom skills, settings: the accumulated setup that makes an agent yours, today trapped in whatever harness built it because harnesses don't interop. Common keeps it in a neutral form any harness can read, so the memory you grew in one is waiting when you open another. The setup travels; the harness underneath becomes a detail you can swap.
Harness-agnostic
Common Config
Secrets, keys, and settings — the smallest component
The fewest bytes and the tightest handling. Encrypted at rest and in transit; each secret is decrypted locally the moment an agent reaches for it, never before.
Encrypted
Common Skills
Reusable tools and prompts your agents call
Shared at the root or scoped to a single project. Write a tool once and every agent with access can call it, wherever it runs.
Shared
03 In practice
Nothing syncs until you point at it
Common Knowledge doesn't mirror your whole Drive, or every doc you can technically open. There isn't the space for that, and a folder crammed with everything is just noise the agent has to wade through. So Knowledge is lazy: an artifact lands in Common only when you reach for it. You paste a link into the chat, or ask the agent for a specific doc, sheet, or thread. That's the moment it syncs, and not a second before.
Say you're in a harness chat working through a launch plan and you drop in a Google Doc link. Common Cloud mirrors that one doc down into Common Knowledge, a live local copy the agent greps at filesystem speed, next to everything else you've pulled in. It reads the doc, cross-references your Ground, drafts what you needed, and you're done.
And nobody left Google Docs. Your colleagues keep editing in the UI they already know; the mirror keeps your copy current, one-way or two-way if you want the agent's edits to flow back. That's the whole posture: Common doesn't drag people out of the tools they live in. It ties the artifacts you're working on into one place your agents can read, and leaves everything else where it sits.
You linked the doc, so the cloud mirrored it down; your team keeps editing in Google Docs as if nothing changed.
04 On disk
The anatomy of a Common
The diagram below does most of the work; the rules are short.
The same folders at every scope. Where they sit is what they mean: shared at the root, scoped inside a project.
Five reserved names: skills, config, knowledge, ground, harness. Anything else at the root is a project.
Knowledge flows in; Ground flows out. Sources mirror down into knowledge/; your agents' work syncs up and across from ground/.
Projects are top-level, never buried in a monorepo, so any one of them is a shareable unit.
One folder is different in kind: Common Harness (the root harness/) backs up your harness's own state (sessions, memory, custom skills, settings) in a form any harness can read. The harness is rented and swappable; this is what makes swapping it cheap, because your setup was never trapped inside it. Switch harnesses or machines and pick up where you left off.
~/Common/your Common — one synced root
│
├── skills/Common Skills — reusable tools every project can call
│ ├── knowledge/mirrors land here · gdocs · sheets · email
│ └── ground/Common Ground — md + static html your agents evolve
│
├── q3-launch/same folders, every project
│ └── …
│
└── client-acme/→ shared with a partner, scoped
├── knowledge/
└── ground/
The same folders at every scope; where they sit is the scope: shared at the root, scoped inside a project. Knowledge flows in, Ground flows out; Common Harness keeps your setup portable.
05 History & audit
Every change is recorded, attributed, and reversible
Common keeps an append-only log of everything that happens in it: what changed, who changed it, which agent did the work. It's written in plain language, not raw diffs.
Audit — ask "what changed in the deal room this week?" and get a real answer.
Rollback — restore any file to any earlier version, the way you'd roll back a Google Doc.
Blame — every change carries both the person and the agent acting for them: You · Claude Code, a teammate · their agent.
When two people touch the same thing at once, no one is blocked mid-work: both edits are kept and the divergence noted in the log, then an intelligent sync reconciles them — an LLM merging the two, not bluntly keeping the last writer the way a shared drive would.
And because every change is logged, Common doubles as an observability layer: tokens spent, which model, which harness, by whom; accumulated per project, append-only, across everyone. At a glance you can see how much agent work has gone into each corner of your Common.
You · Claude Code
Revised the pricing model from the latest figures
A teammate · their agent
Added a verification step to the diligence checklist
You · Claude Code
Re-scoped the Q3 budget
↩ rolled back
A partner · their agent
Logged the signed agreement
06 The dream cycle
While you sleep, the cloud reorganizes what your agents wrote today
All day your agents write to Common Ground in a hurry: a finding here, a half-structured note there, the same fact recorded three ways across two projects. It piles up faster than anyone reorganizes it. So at night, with no session running, the Common Cloud takes a pass over your Common: it de-duplicates, repairs broken links and adds the ones that should exist, and reorganizes what drifted. This nightly pass is Common Compaction: the cleanup that happens between sessions instead of during them.
It runs in the cloud for reliability: a laptop sleeps, drops its network, or loses power mid-pass; a cloud VM runs the compaction to completion every time. It's also the one job that doesn't need you at the keyboard. Every other write to Common Ground starts at the edge, where a person drives an agent, and syncs up. The dream cycle inverts that: Ground is generated centrally overnight, then fanned back down. By morning the tree your agents open is the same one, only more coherent. They start from a cleaner footing instead of re-deriving structure you already paid for once.
More budget buys deeper Common Compaction — until the ground is about as tidy as it gets.
06 Why it compounds
Your AI usage compounds into capital you own
Every project you run, every source you mirror, every flush of Ground lands in the same substrate — tidied each night by the dream cycle — so your Common is worth more the longer you use it. Share one and it compounds across people too: the more a team works the same ground, the more that ground is worth.
It's the difference between renting intelligence and building capital. You can hand a model a task — even a whole job — but you can't hand it your learning. That accumulates here: your workflows, your judgment, your institutional memory, in a layer you own. Swap the generalist model for next quarter's better one and you keep the company veteran — because the expertise lives in your Common, not the model.
It's also a different shape than the memory products. They live inside the turn, racing to store-and-retrieve a little faster each request — that layer is commoditizing toward zero. Common works in the background between turns — the sync, the mirror refresh, the Ground flush, the change log — and hands the agent context as a tool. It isn't a faster memory store; it's the data the memory is of.
That's the real difference. Every memory tool — claude-mem included — treats memory as an accessory to the model and harness, a store the agent reaches into. Common inverts the stack: memory is the product; the model and harness sit on top. Here's how it sits next to the tools people reach for today.
Alternative
What it is
What Common adds
claude-mem
Compresses your Claude Code sessions into searchable memories, re-injected each session — local SQLite + vectors, single user.
Owns the substrate those memories derive from — synced across people and machines, with external mirrors and an audit trail. The work is the record, not a copy beside it.
langmemLangChain SDK
A library you wire into one app's agent to extract and consolidate long-term memories into a store you provide.
Not a memory library bolted into one app's loop — the owned, synced substrate the memory lives in, shared across people and harnesses.
Agent-memory APIsMem0 · Zep · Letta · Supermemory
Hosted store-and-retrieve the agent calls inside every turn.
Runs outside the turn as an owned, portable filesystem — not a per-vendor memory API.
Cloudflare Agent Memory
Managed memory store bound to one platform's agents.
Harness-agnostic and yours — no platform lock-in.
CLAUDE.md & memory files
Hand-kept notes a single harness reads at startup.
A synced, multiplayer system of record with per-project access control and blame.
Dropbox · Drive · iCloud
Generic file sync — your files mirrored across devices.
Agent-native: Knowledge in, Ground out; a real change log; per-project ACL for agents.
Most of these live inside the turn, on one machine, for one person. Common is the layer beneath them — owned, synced, shared.
· · ·
07 The wider bet
Every platform shift moves distribution — this one moves it to tools
2000s
Platform: servers + fiber the internet itself
↓ distribution
Websites
2010s
Platform: mobile + internet a computer in every pocket
↓ distribution
Apps
2026 →
Platform: harness + model + internet intelligence on tap
↓ distribution
Tools
Common lives here
Each shift relocates distribution. This one relocates it to the tools a harness reaches for.
So which tool is worth owning? Not the model — it's rented by the token, and next quarter there's a better one. Not the harness — they multiply and churn. The one thing that compounds is your accumulated context: the diligence, the project state, the institutional memory your agents produce and consume.
Data outlives the model that wrote it and the harness that rendered it. The durable bet is a user-owned data tool — portable and harness-agnostic by construction — plugging into whatever you run today and whatever replaces it tomorrow. Common is that tool.
08 Follow the value
Commoditize your complement
Make your complement cheap and abundant, and the value lands on your side. Hardware makers want free software; software makers want cheap hardware — commoditize the layer next to yours, and the margin is yours.
In the agent stack, the complement to your data is the intelligence itself — and it's commoditizing on its own. A model is a stateless function: context in, tokens out, nothing kept. Frontier models a quarter apart are increasingly interchangeable; swap one for another and keep working. The harness is going the same way. You rent both, and rent better ones next quarter.
What doesn't reset between turns or churn between vendors is the accumulated state — your diligence, your decisions, the work in flight. If the intelligence is the commodity, value accrues to the state. The model is the complement to your data, not the other way around.
The intelligence is stateless. Common is the state.The model is a guest · your state is the house
07 The point
Rent the intelligence. Own your Common.
Strip it back and Common is one trade. You rent the model and harness. Everything they touch lands in a layer that doesn't churn: your sources, your decisions, the work your agents author, the record of who changed what. That layer is the asset, and the only part that's actually yours.
Today it's the worst-treated thing in the stack: scattered across apps, forgotten between sessions, locked inside whatever vendor you used last. Common makes it a place you own: synced, shared on your terms, carried across every AI and every machine. Don't pour your best work into a model you'll replace; build it into ground that's yours.
Common is not your agent or your personal superintelligence. Common is the ground it stands on, and that's yours.
— The one missing thing
Three pains, one substrate
Name the three symptoms; they're all one substrate apart.
No common ground. Collaborating with another person and their agent is barely possible. There's no shared place the work lives, so there's nothing to grant access to — permissioning can't even exist yet. The substrate has to come first.
Context by duct tape. Getting the right context into a single agent is a patchwork of brittle connectors and grudging APIs, with a remote source of truth forever a step out of sync with what's actually on disk. The agent spends its turn fetching instead of thinking.
The agent forgets. Not literally — there's a transcript to scroll, and lately a memory file the harness scribbles to. But both miss the point: a log and a sticky note sit beside the work, assisting it. The real unlock is the work itself as a living system of record — decisions, findings, data refined by compute into insight — compounding on disk and read first by whatever model picks it up next. Memory shouldn't be a static file off to the side; it should be front and center: the project's state of record.
One fix for all three: a constantly-synced filesystem that mirrors your sources in, captures the agents' work, and gives you a real place to grant access. That's Common.
No common ground
No shared place the work lives — so access control can't exist.
One synced tree, per-project ACL
A shared substrate you can finally scope.
sync
Context by duct tape
Brittle connectors; remote always a step out of sync.
Common Knowledge
Your sources, local and legible at filesystem speed.
mirror
The agent forgets
Nothing writes yesterday down where the model reads first.
Common Ground
The project's evolving state of record, compounding on disk.
flush
Three pains, three mechanisms — the whole product, mapped one to one.
— How it feels
You stop managing state — it's just there
The whole idea is that you stop managing state and just have it. Sit down at any machine and your projects are already current — nothing to sync by hand, nothing to remember to save. A background process watches the tree and keeps everything in step, continuously.
Every project sits at the top level of one folder — one per deal, launch, or research thread — side by side, never buried inside one big archive. The shared things many projects need — skills, secrets, and your harness's own state — live at the root. The layout is flat, legible, and identical on every machine and for every collaborator.
And it syncs continuously: there's no gate where each change has to be reviewed and approved before it lands. You still get full history, rollback, and attribution — they just never get in the way.
Before — one folder, no per-project line
one big folder/ everything tangled together
├─ deal-room/
├─ q3-launch/
├─ research/
├─ finance/
└─ ops/
After — shared at the root, projects at the root
~/Common/
├─ config/ shared setup
├─ knowledge/ org-wide mirrors
├─ deal-room/ a project
├─ q3-launch/
└─ client-acme/ shared with a partner
— Why it stays human
You can outsource thinking. You can't outsource accountability.
There's a line from an IBM training manual in 1979 that has aged into a warning.
A computer can never be held accountable, therefore a computer must never make a management decision.IBM training manual · 1979
You can hand an agent your thinking — the drafting, the synthesis, the legwork. What you can't hand it is accountability: when the call is wrong, the agent can't answer for it; a person does. And accountability needs something else you can't delegate — understanding. You can't stand behind a decision you don't understand.
So the job was never to take the human out of the loop. It's to get the human to understanding faster. Common outsources the thinking by building the unified context layer underneath the agents — and then spends its effort closing the gap between what the agents did and what the person understands, so they can take the decision, own it, and move. The agent does the work; the person keeps the accountability; Common is what lets them actually be accountable at the speed the work now moves.
That's why Common is built around people, not agents. The unit isn't an autonomous agent humming away in the dark — it's a person, accountable, with agents working their Common Ground, and a blame trail that records who decided what. Which quietly reframes the entire multiplayer story.
— The arc
It looks like agents collaborating. It's really accountable people, putting their agents to work.
It's the most proven motion in software — a tool you adopt solo that quietly turns multiplayer — but pointed at people, not bots.
It starts single-player: a personal utility where your own context finally syncs itself, current everywhere, nothing to push or pull. But the file you were already keeping for yourself turns out to be exactly the file a collaborator's agent needs. Single-player becomes multiplayer the instant a second person writes to the same tree — and it scales from there to a whole team. That's the real unlock.
The headline isn't "watch agents work together." It's accountable people putting their agents to work on the same ground. Because every project is its own top-level folder, a project is a shareable unit: grant a partner read access to one deal room — their agent and yours now share its live Common Ground — without exposing anything else you keep. A contractor sees only the project they're on. That per-project, per-person scoping is exactly what a single shared repository structurally cannot express.
And the boundary can run far larger than one folder. Link a personal Common to a company's Common and its Common Knowledge flows into context where it's allowed to. But the two must stay sealed by default — a hard airgap, so private data never bleeds into corporate and the reverse holds just as firmly. Think identity-scoped Commons — the way an enterprise account and a personal account already sit side by side but separate, except here it's the data layer, not the chat history. Links are explicit, directional, and scoped; nothing crosses unless someone draws the line.
Sharing context with a person and their AI should be as ordinary as sharing a folder — and keeping two worlds apart, as ordinary as not sharing one.
deal-room/ → partner · readq3-launch/ → contractor · scopedwork ⇄ company Common · linkedpersonal · airgapped