I work alone on about sixteen repos, with a few coding agents. Every new session started the same way: the agent read half the repo to work out where we were, and a single Claude Code call already costs around 29k tokens before it reads a line of mine. Worse, what it read was sometimes out of date. One of my TODO files had hundreds of open boxes, some of them long since done, and the agent happily worked on those.
So I built Relai, a small Go CLI with no server and no account, just git. relai handoff prints where a repo stands in a few hundred tokens: the branch, recent commits, open tasks from Beads, the next unchecked step of any OpenSpec change, and the decisions and pitfalls I keep in a notes file. It's generated from files, not written by an LLM, so it can't drift from the repo. When it can't read the tracker it says so instead of printing "0 tasks", because I learned the hard way that a confident wrong summary is worse than none: in my first evals, a compact handoff built on a stale task list made a model confidently wrong in a single turn. relai workspace does the same for a whole folder of projects, about 400 tokens for my 16 repos. There's also relai discover --links, which looks for mentions between repos and proposes links for you to confirm, and relai tidy, which closes a task only when a commit on the default branch says "Closes ".
The part I care about most is that nobody has to remember to run it. A handoff isn't a file you maintain: it's computed on demand from the repo, so it can't go stale, and the same repo always gives the same output. relai init adds a small hook for Claude Code that loads the handoff at the start of every session, because a line in AGENTS.md saying "run relai handoff first" is only a request that agents often skip. In the fresh clones I tried, with no instruction about the project, a session answered "where are we?" from the handoff in one turn, and without the hook it needed two. Two git hooks take care of the housekeeping after that: one keeps the task export in the repo current when you commit, the other closes finished tasks and deletes merged branches after a merge. The only thing I still write by hand is the notes file with decisions and pitfalls.
Does it help? On my 16 real repos, with Claude Haiku, agents saved a median of about 100k tokens per task when they started from the overview and the handoff instead of exploring. That's one run per case, so take it as a hint, and one case actually cost more with Relai than without. On two small projects the handoff was more expensive than just reading the README. On scripted fixtures of mine it matched reading the docs on correctness with far fewer tokens, but I built those to trap stale docs, so they prove less. I've only tried Claude.
I also tried it on a portal repo with about 15 CI/CD pipelines, and it worked well there too. That one was just me using it, not a measured run, so I can't give you numbers for it.
I'm also trying to treat this as something other tools could read, not just my CLI. The handoff format is written down as a spec (currently v0.5, still a draft, with versioning rules and a changelog), and I build Relai itself with OpenSpec: the changes, the specs and the archive are all in the repo. To be clear about how far that goes: there's no formal schema for relai.yaml yet and no second implementation, so it's a format with one reader, not a standard. If you'd write another implementation or want a field I haven't thought of, I'd like to hear it.
There's an optional second piece, RELAI-TEAM, a self-hosted board that reads the same files (Beads, OpenSpec, TODO.md checklists) and lets each person or agent claim a task so two never start the same one. It has leases so a crashed agent frees its tasks, an MCP adapter for Claude Code and others, token rotation, rate limiting. I use all of this alone, so nobody has tested the team part with several humans, and I don't know yet whether it pays off beyond my own setup.
The lesson I didn't expect: my first version of the server polled the repos on a timer, and every bd call rewrites about 3 MiB of its database, even for a read. Idle, it was writing around 9.5 MB/s, roughly 790 GiB a day, and my NVMe hit 80 °C. I fixed it by fingerprinting each repo with a few stat calls and only reading what changed. If your tool shells out to something, measure what that something writes.
If you try it, I'd like to hear where it breaks, especially with agents other than Claude or repos that look nothing like mine. Docs are at https://relai.rudy-ops.fr/ and the code is at https://github.com/ECG-Rudy-Glt/RELAI and https://github.com/ECG-Rudy-Glt/RELAI-TEAM.
