Faster CI for your agents. No runner bill.

lirra runs your agents' pipeline on the Mac on your desk, before they commit. Work done once is never done again, and every minute is free, macOS included.

Install on your Mac

Made for builders who can't stop building. lirra turns the Mac on your desk into CI that answers before your agent moves on.

FIG 0.1

Green before you commit

Your agent runs the whole pipeline on the tree it has right now, uncommitted edits included. No more "fix CI" commits.

FIG 0.2

Nothing runs twice

Every task is keyed on exactly what it reads, so work done once comes back from the cache: for your agent, for the push, for the next PR.

FIG 0.3

Built for agents

It fails fast, answers in a few lines with an exit code, and ends with the exact next command. From the CLI, or as MCP tools.

Agents fix their
own failures

Your agent runs the very pipeline CI runs, on the same VMs with the same cache, so its green is CI's green. It finds out on its own tree, before anyone else does.

  • Same tasks, images and cache keys as CI: if it passes here, it passes there
  • --fail-fast stops at the first failure, so the fix starts in seconds
  • A few lines and the next command, never a log dump
0Green: every task passed or was cached. Commit.
1A task failed. Read the summary, fix, run again.
2A usage mistake. Read error: and hint:.
3Still running. Run the next: line to keep waiting.

An agent never misreads a run

Green, failed, a mistake in the command or still running: each has its own exit code. Your agent never commits on a run that hasn't finished, or debugs tests over a typo.

The next command, already written

Every answer ends with the exact command to run next, ids filled in. No docs to read, no flags to guess: your agent runs the line. Over MCP, it's the tool call and its arguments.

Most of your pipeline,
done before you push

Every result is keyed on exactly what its task read, so work done once is never done again, by your agent or by CI. And the plan stays open while it runs.

FIG 1.1

Agent and CI share every result

Keys leave out the commit and the branch. When your agent's tree is pushed, CI finds every task done and goes green in seconds.

FIG 1.2

Evolve the plan mid-run

What has started is frozen; what hasn't can still evolve. Agents add or cancel work while the run is in flight, and generators grow it from what they find.

Keyed on contentFiles, command, env and image. Never the commit, the branch or what triggered it.
Checked before bootThe host works out every key from manifests, so a cache hit starts no VM at all.
Joined in flightA task already running for another run is joined, not started a second time.

Linux and macOS,
without the bill

The Mac on your desk keeps fresh VMs warm and ready in a second. Run as much as you like: your secrets never leave it.

FIG 2.1

Your Mac is mostly waiting

Your agent spends most of its time reading and thinking, and your cores sit idle while it does. lirra puts that idle time to work, on hardware you've already paid for.

  • CI runs in the gaps your agent leaves
  • It takes only what you're not using, and backs off the moment you need it
  • Battery-aware: on a MacBook it waits for the charger, then picks up where it left off
  • Scheduled runs take the nights
FIG 2.2

Pool every Mac you have

Join your MacBook to the Mac mini over Tailscale, on a Thunderbolt cable beside it or from across town.

  • Queued Linux work spreads to every Mac that's awake and plugged in
  • The mini keeps the queue, the cache and the secrets
  • Close the lid any time: its tasks go back to the queue
~1s startupVMs wait warm in a pool, so a task starts at once instead of queueing for a runner.
$0 a minuteYour hardware, your runs. macOS included, no 10× multiplier.
Stays homeNo cloud to sign up for. Every task in a fresh VM, walled off from your network.

Drive everything,
from anywhere

Everything lirra does is an operation you can call from the CLI or over REST, and agents get theirs as MCP tools: the same inputs, outputs and next steps everywhere. Script it, build on it, or hand it to your agent.

Some of the operations runexecwaitresultslogsretrycanceladdplanwhyapproveruns.listruns.statsevents.listpools.listcapacity.statushosts.addimages.buildlayers.gcsecrets.granttokens.createstatus

Why not just
GitHub Actions?

Hosted CI bills by the minute and waits for a push. lirra runs on your Mac, before you commit.

Best for small teams lirra On your Macs GitHub ActionsHosted runners RWXHosted CI
Cost $0 a minute Per minute Per vCPU-second
macOS builds Included At ~10× Linux only
Run before you commit Working tree Push first Local changes
Nothing runs twice Every task Hand-written keys Every task
Evolve a run mid-flight Agents add work Generated tasks
Made for agents MCP, next: lines CLI hints
Secrets stay home On your Mac
Get started

Per GitHub's and RWX's public docs, November 2026.

Switch over in
one command

Coming soon

lirra import github reads your workflows, splits their jobs into cacheable tasks and writes .lirra/ci.yml. The first run is the slowest you'll ever have.

Get started

Your agents are fast.
Now your CI is too.

One command on the Mac you already have. Your agents take it from there.

$ curl -fsSL https://lirra.dev/install | sh
  1. 01 curl … | sh Install One binary for Apple silicon, the daemon set up under launchd.
  2. 02 lirra doctor Check the Mac Says what's missing, and the exact command that fixes it.
  3. 03 lirra run Run Your pipeline, from any checkout. Hand the skill to your agent.