Common

The ground agents share.

Agents are getting better at the work. They are still bad at having a place to put it. Common is that place: a synced filesystem where sources come in, agent work goes out, and the state stays yours.

Not a smarter chat box. Not another memory file. A folder with rules: readable by people, dependable for agents, scoped for collaborators, and current on every machine.

Knowledge inDocs, sheets, messages, calendars, repos, and other source material mirrored lazily into local files.

Ground outFindings, decisions, drafts, pages, and project state written where the next agent will read first.

State ownedThe model can change. The harness can change. The accumulated work does not have to reset.

The missing piece is not an agent that remembers harder. It is common ground.

Two people can share a file, a folder, or a repo. They cannot yet share the living context their agents need to work from. That is the gap Common fills.

01The gap

Collaboration breaks because the work has nowhere shared to live.

Your context is scattered across apps, chats, folders, and whatever your current harness happens to remember. A second person has their own scatter. When both of you point agents at the same problem, the agents are not meeting on shared ground; they are each reconstructing the world from private scraps.

So the old choreography returns: send a doc, paste a thread, summarize the current state, re-explain a decision, hope the other side's agent sees enough to avoid doing the same work twice.

The single-player pain is the same problem in smaller form. The agent "forgets" because the work is not being written down in the place the next session treats as real.

No common ground There is no shared object to grant access to.
Context by duct tape Connectors fetch fragments when the agent needs a corpus.
Memory beside the work Notes and transcripts help, but the project itself should be the record.

02What Common is

Five components, one cloud.

A Common is one filesystem. The pieces are deliberately plain, because the point is not a clever interface; it is a stable place people and agents can both read. The cloud is the hub. The folder is still the product.

The Common Cloud

The hub every Common routes through

It sits between your local Common and everything else: your machines, collaborators, connected sources, permissions, and background jobs. It does not replace the folder. It keeps the folder alive.

Hub

Common Knowledge

On-demand mirrors of the sources you reference

Docs, Sheets, Gmail, Calendar, Notion, Slack, Linear, repos: the systems people already live in. Pull one in and Common keeps a local copy current, so the agent can search files instead of spending the turn wrestling a connector.

Flows in

Common Ground

The agents' evolving work, written as the project record

Findings, decisions, drafts, static pages, running notes, and the state that accumulates as you work. It fixes the agent forgetting between sessions by making the work itself the memory.

Flows out

Common Harness

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

Sessions, memory, custom skills, settings: the setup that makes an agent yours. Common keeps it portable so switching machines, models, or harnesses does not mean starting over.

Harness-agnostic

Common Config

Secrets, keys, settings, and policy

The smallest component and the tightest handling. Secrets sync encrypted, stay scoped, and are decrypted locally only when an agent reaches for them.

Encrypted

Common Skills

Reusable tools and prompts your agents call

Shared at the root or scoped to a project. Write a tool once and every permitted agent can call it, wherever that agent happens to run.

Shared

03The direction of things

Knowledge flows in. Ground flows out.

The split matters because each side has a different source of truth. Knowledge starts elsewhere. It is mirrored into Common so agents can read it locally. Ground starts in Common while a person drives an agent. It syncs outward to everyone with access.

Paste a Google Doc link into a session. Common Cloud mirrors that doc into knowledge/. Your teammate keeps editing in Google Docs. Your agent reads a current local copy, cross-checks it against ground/, and writes the new work back to the project record.

You linked the doc, so the cloud mirrored it down. Your team keeps editing in Google Docs as if nothing changed.

04On disk

The layout is boring on purpose.

Agents need stable paths. People need a tree they can understand without a whiteboard. Common keeps the project boundary at the top level and repeats the same reserved names where scope changes.

~/Common/
├── skills/        shared tools and prompts
├── config/        shared secrets, keys, policy
├── knowledge/     org-wide mirrors
├── harness/       sessions, memory, setup
│
├── deal-room/
│   ├── skills/       scoped tools
│   ├── config/       scoped settings
│   ├── knowledge/    mirrored sources
│   └── ground/       project record
│
└── q3-launch/
    ├── knowledge/
    └── ground/

Five reserved namesskills, config, knowledge, ground, harness.

Everything else is a projectTop-level folders are the units you work on and share.

Scope comes from locationRoot folders are shared; project folders are scoped.

The work is the memoryThe next session reads the project record first.

05History

If agents write the work, the record has to be better than a diff.

Common keeps an append-only account of what changed, who asked for it, which agent did it, which model and harness were used, what files moved, and what the change meant in plain language.

That makes the folder safe to share. You can ask what changed this week. You can roll back a file. You can see whether a teammate, contractor, or partner touched the record. You can understand the cost and shape of agent work by project.

You · Codex

Revised the pricing model from the latest numbers.

A teammate · their agent

Added verification steps to the diligence checklist.

You · Claude Code

Re-scoped the Q3 budget.

rolled back

A partner · their agent

Logged the signed agreement into the deal room.

06Sync

Shared drives keep the last writer. Common keeps the situation.

When two people touch the same thing at once, Common does not pretend one of them did not exist. Both edits are kept, the divergence is logged, and the reconciliation is handled as a semantic merge.

That matters because agent output is rarely a single clean line. It is a bundle of intent: a draft, a decision, a calculation, a citation, a chain of files. Common's history model has to preserve that intent or the whole thing becomes another folder you are afraid to trust.

The multiplayer story is not "agents collaborating in the abstract." It is accountable people putting their agents to work on the same ground, with boundaries clear enough to stand behind.

07The night shift

By day, agents write in a hurry. By night, Common cleans up.

Agent work accumulates messily: partial findings, repeated facts, drafts that almost connect, links that should exist but do not yet. A human can tidy that, but the whole point is not to make the human the librarian of every agent trace.

So Common Cloud runs a background pass when no one is driving a session. It deduplicates, repairs links, reorganizes drifted notes, and turns the day's loose output into cleaner Ground for the next morning. The budget is yours to set. The model doing the tidying is rented. The cleaned-up state it leaves behind is not.

Common Compaction is not magic memory. It is paid-for cleanup of your own files, between turns.

You author Common Ground by day.
Common authors it back by night.

08The stack

The rented layers get cheaper. The owned state gets richer.

A model is a stateless function: context in, tokens out, nothing kept. A harness is a workbench. Useful, swappable, and likely to churn. The part that compounds is the state underneath: sources, decisions, artifacts, history, preferences, and the working record of how you and your collaborators think.

Most memory tools live inside the turn. They help an agent recall. Common starts lower. It owns the record those memories should be of.

Layer	What churns	What Common keeps
Models	Better one next quarter, cheaper one next month.	The context, artifacts, and decisions the model acted on.
Harnesses	Codex, Claude Code, Cursor, whatever replaces the current workbench.	Sessions, memory, skills, settings, and project state in portable form.
Memory APIs	Store-and-retrieve loops bound to one app or vendor.	The filesystem record underneath those loops, shared across people and tools.
Drive-style sync	Files for people, without agent-native history or Ground.	Knowledge in, Ground out, per-project access, semantic audit, and rollback.

09The point

Rent the intelligence. Own the ground.

Common does not try to be the agent. It gives the agent a place to stand: a synced, inspectable, shareable state layer owned by the people accountable for the work.

That is the bet. The intelligence will keep moving. The harnesses will keep changing. The best work should not be trapped inside either one. It should land in ground you can read, share, audit, roll back, compact, and carry forward.

The intelligence is rented.
The ground is yours.Common