Common · a multiplayer filesystem for people and their agents
Agents need Common ground to collaborate.
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
Three components, one cloud
A Common is one multiplayer filesystem, always in sync across your team's devices and agents. Everything in it is one of three 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: it mirrors only what you reach for, never your whole Drive.
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 agent's whole setup, no longer locked to one harness
Sessions, memory, custom skills, settings, and the secrets it runs with: everything 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 setup you grew in one is waiting when you open another. Secrets ride along encrypted, decrypted locally only when an agent reaches for one. The harness underneath becomes a detail you can swap.
Harness-agnostic
03 In practice
Common runs in the background; you just keep working
There's no Common app to open. You work in the harness you already use (Claude Code, Codex, Cursor), pointed at the same docs and spreadsheets as always. You auth the Common MCP once, through that harness; after that it runs underneath: Knowledge mirrors your sources down, your agent writes Ground as it works, and a daemon backs up your Harness. All of that is automatic. The decisions stay yours: who can see a project, and how hard the nightly dream cycle runs.
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 your harness, or ask the agent for a specific doc, sheet, or thread. That's when it lands. From then on it stays in sync like everything else in your Common.
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, either. 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.
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.
Three reserved names: 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/.
Two reserved folders per project: knowledge/ (what it pulls in) and ground/ (what it produces). The agent is free to create any others it needs alongside them; only the reserved names are protected. Projects are top-level, so any one is a shareable unit.
One folder is different in kind: Common Harness (the root harness/) mirrors your agent's whole setup (sessions, memory, skills, settings, secrets) across your own machines and harnesses, so what you built up in one shows up in whichever you're working in now. It's private to you: none of it is shared with anyone unless you explicitly ask, and secrets stay encrypted, decrypted only at runtime. The harness is rented and swappable; this is what makes swapping it cheap, because your setup was never trapped inside it.
│ ├── knowledge/mirrors land here · gdocs · sheets · email
│ ├── ground/Common Ground — md + static html your agents evolve
│ └── model/anything else the agent makes (not reserved)
│
├── q3-launch/same folders, every project
│ └── …
│
└── client-acme/→ shared with a partner, scoped
├── knowledge/
└── ground/
knowledge/ flows in, ground/ flows out, and the agent adds whatever else a project needs. Common Harness sits once at the root, keeping your whole 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: duplicates, half-structured notes, the same fact in three places. Overnight, with no session running, the Common Cloud runs the dream cycle: a pass over your Ground that de-duplicates, fixes links, and re-files what drifted, so by morning the tree is cleaner. That tidying core is Common Compaction, and it runs server-side for reliability: a laptop sleeps mid-pass, a cloud VM finishes the job.
You set the nightly budget — small, medium, or high — and that decides how far the cycle goes. Small just tidies. Turn it up and the cloud does more on your behalf: organizing your Knowledge, spotting automations worth building, surfacing tomorrow's todos and the week's things to track, flagging what needs attention. The more you spend, the more is done for you.
A bigger nightly budget gets more done overnight, up to a point.
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.
The model and the harness are rented. They keep getting better and cheaper, and swapping one for the next should cost you nothing. What you build with them is the part that lasts: your sources, your decisions, the work your agents author, the record of who changed what. That state compounds, and it carries your name, not the vendor's.
Today that state is the worst-treated thing in the stack: scattered across apps, forgotten between sessions, locked inside whatever tool you used last. Common gathers it into one place that answers to you, synced across your machines and agents, shared with the people who should see it, and reorganized each night so it's worth more by morning. The intelligence will be swapped out. This is the part you keep building, and the part that's yours.
Common makes superintelligence personal and collaborative.
— Workspaces
One workspace, personal or enterprise
The five Common Components — Knowledge, Ground, Config, Harness, Skills — together make a Common Workspace: one self-contained, synced filesystem, the way an Obsidian vault is one self-contained knowledge base — except multiplayer and synced rather than solo and local.
That container is what lets you hold more than one. A personal workspace and an enterprise workspace, sealed by default and linked only where you choose: the classic motion — adopt it solo, expand it across the org — with a hard airgap between the two.
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
— 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