Runi is a desktop app and a small local daemon. The daemon watches the coding agent sessions you already run, keeps the parts a teammate would need, and hands those to the next session that starts. Any machine, any agent, before the first prompt.
It is not an agent, an orchestrator or an IDE. It never launches your agent and never drives anyone else's. Uninstall it this afternoon and every session you run tomorrow works exactly as it does today. You just pay again for things your team already worked out.
The loop, end to end#
-
Your agent works, normally#
You open Claude Code, Codex, Cursor, OpenCode, Gemini CLI or OpenClaw in a repository your workspace tracks, and prompt it as usual. Nothing about the session changes. Runi registered a hook or a plugin with that agent, and it runs beside the session instead of in front of it.
-
The daemon turns the session into records#
Prompts, the agent's visible replies, the commands it ran, the tests that passed or failed, the files it edited. Each becomes a small structured event. Secrets are stripped on your machine before the event exists, and a file your ignore rules exclude is never named at all.
-
Records reach your workspace, scoped#
Events are written to your workspace and readable by that workspace alone. The database enforces it, not the application. Your teammates see them live in the app.
-
The next session opens already briefed#
When anyone on the team starts a session in that repository, Runi assembles a ranked packet and injects it as the session's starting context: open tasks, decisions and their reasons, approaches that failed, who is holding which files right now. Nobody asked for it. A session cannot request a fact about a problem it does not yet know it has.
-
A human signs what lasts#
Anything that becomes durable team memory is drafted by Runi and confirmed by the person whose session produced it. Only then does it ride into anyone else's brief. A confident wrong answer never travels faster than a right one.
Tip
Git syncs the code. Runi syncs what the team and its agents worked out about the code.
The two channels#
Context reaches an agent two ways, and they do different jobs. Both go through the same gate, so neither shows anything the other would refuse.
| Channel | When | What it carries |
|---|---|---|
| Push · the brief | Once, at session start | The things an agent would never think to ask for. A teammate holding this file right now. An approach that already failed. A decision that settles the question it is about to re-open. |
| Pull · the MCP tools | Any time, on request | The archive. The brief runs under a token budget, and everything ranked below that line is still reachable by asking. See the MCP tools. |
What lives where#
| Piece | Where it runs | What it does |
|---|---|---|
| The desktop app | Your machine | Everything you read and every decision you sign: sessions, tasks, memory, shared work, team, settings. |
| The daemon | Your machine, ~/.relay |
Hooks, redaction, the ignore gate, the outbox, and the MCP server your agents talk to. |
| Your workspace | Runi's backend | The structured records your team shares, scoped by row-level security. |
| Private session detail | Your machine, ~/.relay/detail/ |
The full local record of your own sessions, kept even when you share nothing with teammates. |
The vocabulary#
Five words do most of the work in the app.
Session#
One run of one agent, in one repository, on one machine. It has a status while it is live and a record once it finishes. Everything else hangs off sessions.
Task#
A card describing a piece of work. Most are created for you from the first real ask of a session; you can also write them by hand. A card carries a title, the intent, the prompt it came from, and everything later attached to it. See Task cards.
Brief#
The packet injected at session start. Ranked, budgeted, attributed, and filed with a receipt so you can see afterwards whose work reached whom. See The brief.
Memory#
A durable statement: a decision and its reason, a discovery, a known issue, a convention. Proposed by your agent or by you, confirmed by a person, then carried into other people's briefs. See Memory.
Shared work#
A hand-over. A piece of work passed to a teammate with the reasoning attached, instead of a branch name passed with the reasoning left behind. See Shared work.
What it will not do#
- Scan or index your repository. There is no file scanner and no repo indexer. Neither was ever built.
- Read your Git history. Not commits, not branches, not blame.
- Read files your agent did not edit. A record of a change is a record of a change, not a copy of the tree around it.
- Publish your model's private reasoning. Extended thinking is a scratchpad, not a team channel. No adapter registers for the hooks that carry it.
- Write to your repository. Ever.
The full boundary, with the exact list of what may and may not cross, is in What Runi sees.