All posts

· The LVCS team · 2 min read

How LVCS works

People and agents use the same protocol for presence, edits, and questions. Nobody gets a special lane. Not even you, sorry.

  1. One live main

    Everyone edits the same project, live. Edits merge the same way on every machine. No branches to babysit, no text conflicts to untangle at 6 p.m. on a Friday.

  2. Every revision, on the record

    main keeps moving, and every version it passes through keeps its attestations. Open any revision, diff it against now, and push exactly the one ci passed. History without the branches.

  3. Heads-up before the collision

    Before an agent touches your lines, you hear about it. Say hold and it waits. Politely. Unlike some coworkers.

  4. Actions, not CI on every branch

    Each action runs once per version, signs its result, and gets reused until its inputs change. ci moves when runners agree. Other actions can follow it.

  5. Agents are participants, not guests

    Authority comes from signed grants that trace back to the project owner, not from having a pulse. Grants are long-lived, so agents can work at 3 a.m. Revoking one is an explicit, signed act.

  6. Git stays git

    Your project is still a git checkout. lvcs checkpoint writes a normal commit. Uninstall LVCS and you've got a normal repo. No hostage situation.

Install it. Forget it's there.

One small program runs wherever you or an agent works. Every machine runs the same one. None of them is in charge.

Your tools still workYour project's still a normal folder and a git checkout. Save from any editor, script, or agent and everyone gets it.
What it costsNothing. No per-seat pricing, no per-minute runners, no “contact sales.” Your machines, your electricity, our condolences to your CI bill.
Nothing to hostMachines find each other on the LAN or across the internet. No server to run, pay for, or refresh a status page about.
Offline is fineWork on a plane. Sync when you land. Everyone ends up with the same code, which is more than you can say for your last merge.
Heads-up, not surprisesSomeone's about to change your lines? You hear first, and you can tell them to wait.
Actions next to the codeYour machines run your actions and sign the results. No queue behind strangers' builds.
Your agents includedA Claude Code plugin, the lvcs command line for every other agent, and a VS Code extension for the humans.

Two machines editing live in five commands.

The reference is generated from the code, so it can't drift. Unlike the docs you're used to.

Quickstart

In a git checkout with nothing uncommitted:

terminalon main
1cd ~/code/my-project2lvcs init       # prints your project id3lvcs daemon     # leave it running

lvcs init starts from your current commit. On another machine, join using the first one's address:

terminalon main
1lvcs join <project-id> --root ~/code/my-project --bootstrap <address>2lvcs daemon --root ~/code/my-project

Now edit in either directory with whatever you like. The other machine sees it as it lands.

The ones you'll actually use

  • lvcs status: where you stand. What you can do, open holds and asks, unread notifications, who's connected, and the last thing that went wrong.
  • lvcs explain <value>: what an error code, rule, or notification means, offline. Hand it a path and it tells you how LVCS sees that file.
  • lvcs key new: a new participant key. Every agent gets one.
  • lvcs checkpoint <revision>: a git commit of exactly the revision a channel attested.
  • lvcs ask, answer, hold, and say: talk to whoever is in the same lines.
  • lvcs checkpoint: write main as a plain git commit.
  • lvcs run <action>: fire a manual action, like a release.
  • lvcs audit: check that every change was made by someone allowed to make it.

Every refusal tells you why and hands you the exact command that fixes it. Stuck anyway? lvcs status.

Agents

  • Claude Code: install the plugin. Before each edit, everyone in those lines hears about it, and holds come back.
  • Any other agent: it runs lvcs in its shell, as a participant you granted.
  • Nobody's words land in an agent's context uninvited. It reads a message when it chooses to, with lvcs notifications read.

Reference, generated from code

Saved to mainNovember 1, 2026 · The LVCS team