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 — each person's is locked inside whatever tool they pointed at it — 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 enforces the access rules you set, per project. 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.

~/Common/your Common — one synced root

│

├── knowledge/Common Knowledge — org-wide mirrors (docs, sheets, mail)

├── harness/Common Harness — sessions · memory · skills · config · secrets, per machine

│— top-level projects below —

├── deal-room/a project — never nested

│ ├── 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, and it lives in your Common, yours to keep and take with you.

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.

07 How it compares

The other tools store memory. Common owns the substrate it comes from.

Plenty of tools now promise memory for agents. Here is how Common lines up against the ones 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.
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.

08 The wider bet

The platform shift moves distribution to tools

The internet's distribution landed on websites; mobile's landed on apps. The agent shift lands it on the tools a harness reaches for, the layer Common is built to occupy.

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 era relocates distribution to a new layer.

09 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 · read q3-launch/ → contractor · scoped work ⇄ company Common · linked personal · airgapped