The log
Every message, tool call and edit is an event on an append-only log. The window, the CLI, the phone and every agent read the same one.
Agents went from one model call, to subagents, to swarms. Computing took the same path, from threads to cores to clusters, and swarms need what clusters needed: shared state, scheduling, identity and access. Plus one thing clusters never had: the people they work with. Mod is that layer. It is open source, and it runs wherever your agents do: your Mac, a VM or any cloud.
Every message, tool call and edit is an event on an append-only log. The window, the CLI, the phone and every agent read the same one.
Documents merge per character and live everywhere. Code merges per commit and lives in a checkout. A path belongs to exactly one.
A session is a thread an agent runs in. Its log is the unit you read, share, pause and join, and the unit of access.
A tool call is written to the log and claimed by a worker, on your Mac, in a VM or in the cloud. Where it runs is never part of the address.
An app is a view over typed records, installed once in a World. Agents use it by writing its records, the same way people do.
read_document, patch_document, create_task, comment, set_view. One set of calls for every agent, whichever model is behind it.
Claude Code, Codex and Cursor plug in as they are. Mod drives them and writes what they do to the log.
A World holds a person's projects. Share a project or one session, and the people and agents in it see the same work.
The panes a person is looking at. An agent can read the view and open what the work needs, so you watch it happen.
One task touches a model, tools, files, memory and review in under a minute. In Mod those run on one log, so nothing drops between them, including the people.
Any model, through the agent you already use. The model is the part you swap most, so nothing is built around one.
harnesses · routingTool calls are written to the log, then claimed and run by a worker wherever the work lives.
tools · workersDocuments, tasks and every session's log. The memory is the same work people read and edit.
the log · documentsEvery session is already a trace, and every correction a person makes is on it. That is what an agent learns from.
evals · skills · macrosThere is no tracing to wire up. Read any session off the log, grade it, build a dataset from it and replay a fix before it ships.
An answered question, a rejected edit, a comment on the line the agent got wrong. Each one is on the log, with who made it and what it was about.
Fix the agent once in a thread, save it as a skill, and every session in your World reads it the next time the task comes up.
A flow your agent repeats every morning is saved as one tool call. It runs in seconds, with no model in it until something needs judgement.
Most agent tools pick one storage model and force everything into it. Mod keeps two, because a document and a codebase merge differently, and says which one every path is on.
# one project, both realms spring-launch/ ├─ launch-plan.md doc · on every device ├─ notes/launch-sync.md doc · written during the call ├─ apps/launch-plan doc · typed records ├─ mod-monorepo @ main code · worktree on Nassar's Mac ├─ mod-monorepo @ reset code · worktree in a VM └─ subduction code · second source
// one address for both. It never names a host. type Realm = 'doc' | 'code' interface ModRef { realm: Realm path: string // project-relative, or repo-relative at?: string // code only: a branch or commit }
Every crossing is a command. Moving files between the realms, checking out, saving to disk: each has a direction, and a save is refused before it overwrites bytes you did not see. Nothing reconciles in the background.
# start a session in a project and give it work $ mod-next session create <projectId> "reset expiry" $ mod-next message send <sessionId> "Links should expire after an hour." # the agent asks when it needs you; answer from anywhere $ mod-next session asking <sessionId> $ mod-next session answer <sessionId> <interactionId> expiry=1h
# documents are on the log: written here, open everywhere $ mod-next docs create <projectId> notes/launch.md --content "# Launch" $ mod-next docs list <projectId> # a typed record is a document an app draws $ mod-next docs create <projectId> plan/reset-screen \ --dataType launchplan --data '{"work":"Reset screen v3","owner":"Sam"}'
# give a project its repository; sessions work in its worktrees $ mod-next code adopt <projectId> --repo . --base main # open a session's code on this machine, on its own branch $ mod-next code open <projectId> <sessionId> --fork
# an app is a package: a manifest, a build, one module $ mod-next app init launch-plan --dataType launchplan // package.json "mod": { "name": "Launch plan", "dataType": "launchplan", "reads": ["tasks"], "writes": ["tasks"], "entry": "dist/app.js" } # build, publish, and install it for every project in your World $ mod-next app push <projectId> --world
Mod drives the harness already on your machine and gives it the same tools, files and people every other agent in the project has.