A folder that syncs, remembers, and stays yours.
Common gives agent work a user-owned filesystem. It mirrors source material in, keeps the work itself as the record, and makes that state portable across collaborators, machines, models, and harnesses.
Memory should not be an accessory to the model. Memory is the product. The model and harness sit on top.
The hard thing is not one agent remembering. The hard thing is two people working from the same ground.
Today, every person keeps context their own way: files, docs, chats, local notes, and whatever their harness remembers. When two people ask their agents to work on the same problem, there is no shared substrate beneath them. They pass documents around, paste state into chats, and make each agent re-learn what the other already found.
That also explains the single-player pain. The model does not need another sticky note beside the work. The project needs a state of record the model reads before it acts.
No common ground
No shared place to read, write, or grant access to.
Context by duct tape
Connectors fetch fragments instead of giving agents a traversable local corpus.
The agent forgets
Transcripts and memory files sit beside the work. Common Ground makes the work the memory.
Five primitives, one filesystem.
These are the durable objects in Common. The folder names are deliberately plain. Scope comes from location: at the root they are shared; inside a project they belong to that project.
Mirrored source material: Docs, Sheets, Gmail, Notion, chat histories, and other records owned elsewhere.
The project state of record: decisions, findings, drafts, running notes, static pages, and agent-produced insight.
Portable harness state: sessions, memory, local setup, and the history that lets you switch machines or tools.
Secrets, keys, environment, policy, and scoped settings. Shared at the root, project-specific inside a project.
Reusable tools, prompts, automations, and project-local capabilities agents can call.
The filesystem gives agents stable paths.
Common uses the same reserved folders at every scope. Anything else at the root is a project. That gives humans a simple tree and gives agents stable paths to expect.
| Folder | At root | Inside a project |
|---|---|---|
| skills/ | Shared tools | Project tools |
| config/ | Shared secrets and policy | Scoped secrets and settings |
| knowledge/ | Org-wide mirrors | Project mirrors |
| ground/ | Reserved | Project state of record |
| harness/ | Harness backup | Not repeated |
~/Common/
├── skills/ shared tools
├── config/ shared secrets, keys, policy
├── knowledge/ org-wide mirrors
├── harness/ sessions, memory, setup
│
├── deal-room/
│ ├── skills/
│ ├── config/
│ ├── knowledge/ mirrored sources
│ └── ground/ system of record
│
└── q3-launch/
├── knowledge/
└── ground/
Knowledge comes in. Ground moves out.
The split matters because each side has a different source of truth and a different sync pattern.
Reflect the world into the folder.
Remote systems remain the source of truth. Common mirrors them into a local, agent-traversable corpus so the model can search files instead of spending the turn fighting APIs.
- Mostly cloud-orchestrated pull and fan-out.
- One-way first; two-way by store over time.
- Solves context by duct tape.
Write the work where everyone can stand on it.
Ground originates locally while a person drives an agent. The agent flushes decisions, findings, drafts, and artifacts to disk; Common syncs that state to the server and down to collaborators.
- Mostly local authoring, continuous sync.
- The project memory lives here, not off to the side.
- Solves the agent forgets.
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 gives collaboration and permissioning a real place to exist.
Distribution moved to the tool call.
Which tool is worth owning? Not the model. Not the harness. Own the user-controlled data layer every harness reaches for. Common is that tool.
The rented layers get cheaper. The owned state gets richer.
Commoditize your complement still applies. In this stack, the complement to your data is intelligence. Models improve, prices fall, and harnesses compete for the same workflows. Good. That makes the state they operate on more valuable.
A model behaves like a stateless function: context in, tokens out, nothing kept. A harness gives you a workbench. Common keeps the compounding asset underneath both: the sources, the reasoning, the decisions, the artifacts, and the audit trail.
The intelligence is stateless.
Common is the state.
Every change is recorded, attributed, reversible, and observable.
Continuous sync needs a history model people can actually use. Common keeps semantic change logs: person, agent, model, harness, tokens, files touched, and a plain-English summary of what changed.
Audit
Ask what changed in a project this week and get an answer in language, not a diff dump.
Rollback
Restore a file or a scoped set of changes to an earlier version, closer to document history than source control.
Blame
Attribute every change to a person and the agent acting for them.
Observability
See agent work by project: tokens, model, harness, user, and time. Useful for trust, cost, and management.
You can outsource thinking. You cannot outsource accountability.
A line from an IBM training manual in 1979 still has teeth:
A computer can never be held accountable,
therefore a computer must never make a management decision.IBM training manual · 1979
Agents can draft, synthesize, search, and calculate. A person still owns the decision. Common serves that person by making the work inspectable enough to understand, share, question, roll back, and stand behind.
The demo should not be "two agents collaborate." It should be two accountable people putting their agents to work on the same Common Ground.
Most memory tools keep memory beside the work. Common puts it underneath the work.
claude-mem, langmem, Mem0, Zep, Letta, Supermemory, and platform memory products all help an agent recall things inside the turn. Useful, but auxiliary. Common starts lower in the stack.
| Alternative | What it does | Common's answer |
|---|---|---|
| claude-mem | Compresses sessions into searchable memories for future Claude Code sessions. | Owns the project record those memories derive from, synced across people and machines. |
| langmem | SDK for extracting long-term memories inside an agent app. | Not a memory library inside one app; the shared substrate beneath apps. |
| Memory APIs | Hosted store-and-retrieve for an agent's turn loop. | Runs mostly outside the turn: sync, ACL, Ground flush, Knowledge refresh, audit. |
| Dropbox / Drive | Generic file sync for people. | Agent-native: Knowledge in, Ground out, Harness portable, change log semantic. |
Not file sync with AI features.
Dropbox and Drive sync files for people. Common gives agents a data layer to work on: remote knowledge mirrored into a local corpus, project ground as the record, harness state portable, scoped ACL, semantic history, and tool-call distribution. Similar surface area; different center of gravity.
The model is rented. The harness is rented. Your context should be yours.
Common does not try to be the agent. It gives the agent a place to stand: a portable, synced, inspectable state layer owned by the people accountable for the work.