Common Ground for personal agents
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 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. Learn them and you can read any Common — yours or a collaborator's — at a glance. Start with the hub.

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.

Raw accumulation would just pile up. The nightly pass is what turns a day's scattered output into something easier to read the next morning, and the gains stack: tidier ground makes the next day's work tidier still, the night after that cheaper to organize.