Mod is the open-source layer that keeps your agents' work in sync and secure on every machine they run on. Any model, any harness, and the state stays yours.
One piece of work and its log. Watch it, resume it, hand it on or share it.
driversClaude Code, Codex, Cursor and Pi drive sessions, with the same tools.
compute timeThe model that thinks for each session, paid by subscription, your own key or Mod's router.
system callsOne tool set for every agent. Every write names its author and can be undone.
configurationWritten know-how an agent reads when the task calls for it.
Your tree of projects, each shared and synced on its own.
folders with membersA folder with members, and the unit you share.
filesEach its own CRDT. Merges per character and keeps its history.
schemasTasks, comments and the types packages add. One record everywhere.
folders with filesGit repositories, placed beside the documents they belong with.
historyEvery change, who made it and why. Undo it, restore a version, or read it live.
Claim tool calls and run them. Where work runs is never the address.
your MacYour Mac runs sessions in VMs beside your checkouts.
your machinesYour own machines join your World and run sessions too.
on demandPicks up sessions while your devices are away, then hands them back.
isolationOne VM per session, thrown away when the work is done.
Arrangements of panes that a person and an agent both change.
programsViews over shared records. Agents use them by writing records.
how agents see and actSay what is on screen, declare your actions, say what happened: the agent is told, and does what a person does.
One task touches a model, tools, files, memory and review in under a minute. In Mod those run on one session's log, so nothing drops between them, including the people.
Any model, through the agent you already use. Pay with the subscription you have, your own API key, or Mod's router, metered per person and project so a runaway agent stops instead of spending.
harnesses · inferenceTool 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.
sessions · 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, one tree, 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 └─ launch-site/ ├─ home.html doc · the pages ├─ developers.html doc └─ site/ code · the checkout that builds them ├─ @ main worktree on Nassar's Mac └─ @ reset worktree in a VM
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.
A tool call is written to the session's log, then claimed by a worker. Every session runs in its own VM, and moving it to another machine changes where it runs, not the session: its log and documents are already there.
The Mod app runs sessions in VMs on your Mac, beside your checkouts and the harnesses you already use.
worker · your machinesA Linux box on your network joins your World as a device and runs sessions in its own VMs.
worker · the poolClose the lid and busy sessions carry on in the pool, then come home when you are back.
.mod/setup lives in the repository, so it is versioned, branched and reviewed like code.
A new session's VM starts from a saved snapshot of its project, then catches up on what changed.
The VM holds no state of its own. It reads the session from the log and writes back to it.
Access is granted per project or per session, never per server. It travels with the work, so it holds offline and on a remote VM.
People, agents and devices each have an identity. Every change names its author, person or agent.
authenticationSign in once. Each device signs its connection with its own key, and a VM never holds your sign-in.
authorisationSessions are private until shared. Editing documents and running commands are separate grants.
An agent never outranks its person. It gets at most what the person who runs it has, and you choose which actions always wait for a person.
# 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 sync to every device: 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"] } # 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.