A folder that syncs, remembers, and stays yours.

The thing you can't do today is collaborate

The one thing nobody can work around today: you can't collaborate with another person and their agent.

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.

And the friction isn't even the real problem. There's nothing to grant access to: scoped permissions for a shared workspace aren't hard to build, they're impossible — the workspace doesn't exist. No agreed-upon substrate that two people, and both their agents, can read and write.

That absence is the tell. It's also why a lone agent feels starved for context and forgets between sessions. Three symptoms, one cause: no shared place the work lives.

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.

Two kinds of state, flowing in opposite directions

Common holds two kinds of state. They differ by where the source of truth lives — and, it turns out, by which way they sync.

Common Knowledge is everything already written down somewhere else. A Google Doc, a Sheet, a Gmail thread, a Notion page, a chat history — the remote owns it; Common pulls a local, agent-traversable copy so the model can grep it at filesystem speed instead of round-tripping a brittle connector every turn. There's a server in the middle: the Common cloud does most of the work — it polls your connected stores and fans the mirror down to every machine. Call it 80/20 — mostly cloud-orchestrated, occasionally a local pull pushed back up. Common Knowledge flows inward.

Common Ground is the truth that originates here — the live, evolving output of the agents' own work: the strategy, the findings, the running state, the markdown and static HTML that grow as you go. This isn't a memory file off to the side assisting the work — it's the project's system of record. There's no upstream to defer to — it starts here. Here the ratio inverts — 80/20 the other way — because nearly all the authoring happens on a person's machine, where they're driving an agent. The agent flushes Ground to disk; it syncs up to the cloud and down into every collaborator's identical tree. Common Ground flows outward.

That asymmetry is just honest distributed-systems design: pull-heavy data is cheapest to orchestrate centrally; author-heavy data belongs at the edge where the work happens. Map it back to the pains — Common Knowledge cures context by duct tape, Common Ground cures the agent forgets, and the synced tree beneath both is the shared ground that makes collaboration, and permissioning, finally possible.

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.

Not "two agents collaborate." Two 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 that's the real unlock.

The headline isn't "watch two agents work together." It's two 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.

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