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.

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.

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.

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 — per machine. The harness is rented and swappable; this is what makes swapping it cheap, because your setup was never trapped inside it. Change machines or harnesses, 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, you get the answer you already know from shared drives: the latest edit wins, the other is kept as a conflict copy, and the agent notes the divergence in the log — no one is blocked mid-work, and a later sync reconciles it.

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 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.

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.

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. Compaction for the data layer — the cleanup that happens between sessions instead of during them.

It runs in the cloud because that's where the off-hours compute lives, and because it's 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.

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. The model and harness pointed at it get swapped every quarter; the Common only grows. 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.

Every platform shift moves distribution — this one moves it to tools

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.