Agents need Common ground
to collaborate.

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 — and points 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.

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.

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 — 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 quietly ties the artifacts you're working on into one place your agents can read, and leaves everything else where it sits.

The anatomy of a Common

Here's the layout on disk — 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.

Every change is recorded, attributed, and reversible

Common keeps an append-only log of everything that happens in it — what changed, who changed it, and which agent did the work — written so you read it in plain language, not as 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.

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.

And the effect compounds: a tidier ground tonight makes tomorrow's work tidier still, and the night after that cheaper to organize. Each pass leaves the next one less to do.