Common · the shared context layer for agents

Common Ground for personal agents
to collaborate.

Common is a synced folder that holds the context a project runs on — its sources, its decisions, the state the agents produce and read. One place where people and their agents work the same problem together: current on every machine, remembered across every session, shareable by default. Models and harnesses are transient — even the best get swapped within the year. Common is the ground they stand on: it persists, and compounds in value over time.

3 problems solved/ 2 kinds of state — Knowledge in, Ground out/ Any harness it plugs into

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

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.
02 What's in a Common

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 Common Cloud

Every local Common is a full working copy. The Common Cloud is the hub between it and everything else — your other machines, your collaborators, your connected sources. It polls those sources, mediates sync the way Dropbox does, and decides at retrieval who's allowed to read what. Boundaries and sharing exist because the cloud enforces them; the local folder alone is all-or-nothing.

It also works while you sleep. Background compute runs server-side — the nightly dream cycle is the clearest case — so state can improve with no one at the keyboard. Below are the five Common Components it keeps in sync, each with its own direction of flow.

Common Knowledge

Mirrors of your external sources — local and grep-able

Docs, Sheets, Gmail, Calendar, Notion, Slack, Linear — the apps a person or a small team already lives in. The remote stays authoritative; the cloud keeps a local copy on every machine, so the agent greps at filesystem speed instead of round-tripping a connector each turn. It replaces the connector duct tape with a copy on disk.

Flows in
Your sources Docs · Slack · Calendar Common Cloud Your Common local disk

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
Collaborators their Commons Common Cloud Your Common agent at work dream

Common Harness

Your harness's own state, no longer locked to one

Sessions, memory, custom skills, settings — the accumulated setup 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 memory you grew in one is waiting when you open another. The setup travels; the harness underneath becomes a detail you can swap.

Harness-agnostic
Codex · Cursor any harness next Common Cloud Claude Code your harness now

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
Other machines Common Cloud Your Common decrypt at runtime

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
Every project, every client Common Cloud Your Common authored here

Memory isn't an add-on to your agents.
It is the data they compound — growing more valuable over time.

03 On disk

The anatomy of a Common

Here's the layout on disk — the diagram below does most of the work; the rules are short.

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.

~/Common/your Common — one synced root
├── skills/Common Skills — reusable tools every project can call
├── config/Common Config — secrets, keys & settings
├── knowledge/Common Knowledge — org-wide mirrors (people, wiki)
├── harness/Common Harness — sessions · memory · skills · settings, harness-agnostic
— top-level projects below —
├── deal-room/a project — never nested
│ ├── skills/scoped tools
│ ├── config/scoped secrets & settings
│ ├── knowledge/mirrors land here · gdocs · sheets · email
│ └── ground/Common Ground — md + static html your agents evolve
├── q3-launch/same folders, every project
│ └── …
└── client-acme/→ shared with a partner, scoped
├── knowledge/
└── ground/
The same folders at every scope — where they sit is the scope: shared at the root, scoped inside a project. Knowledge flows in, Ground flows out; Common Harness keeps your setup portable.
04 History & accountability

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.

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
Audit — ask in plain language Rollback — restore any version Blame — person and agent
05 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 — 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.

diminishing returns you set this nightly budget → less $ more $$$ coherence by morning
More budget buys deeper Common Compaction — until the ground is about as tidy as it gets.

It's also how the cloud earns its keep: metered compute you choose to spend on your own data, on a budget you set. The model that does the tidying is rented and interchangeable; what it leaves behind on disk is not.

You author Common Ground by day.
The dream cycle — Common Compaction — authors it back by night.

06 The point

Rent the intelligence. Own the ground.

Strip it back and Common is one trade. The intelligence — the model, the harness — you rent, and you'll rent something better next quarter. Everything those rented parts touch — your sources, your decisions, the work your agents author, the record of who changed what — lands in a layer that doesn't churn. That layer is the asset, and the only part that's actually yours.

Today it's the worst-treated thing in the stack: scattered across apps, forgotten between sessions, locked inside whatever vendor you used last. Common makes it a place you own — synced, shared on your terms, carried across every AI and every machine. Don't pour your best work into a model you'll replace next quarter; build it into ground that's yours.

Common doesn't want to be your agent.
It wants to be the ground your agents stand on — and to be yours.