land.

How land makes your agents faster

After an agent finishes, its change still has to get through CI and onto main. Most of that time is waiting, and most of the waiting is CI rerunning tests that already passed, after every rebase, in the merge queue and again on main.

Todayone change goes through the CI machine 3 or more times, and waits in line between themCIall testsCI againall testsCI on mainall testsqueuemain moved, so rebase and run againyour PRmainWith landone pass, one check, no line to wait incombinewith mainskipunaffected teststestthe few that matterlet inif they passyour branchmain…✓✓✓
❚❚ click the picture to stop
land doesn't make CI's machines faster. It stops running the same tests on the same change again and again.

land shortens that path in three ways.

1

Only the test commands that matter run

land records every file each of your test commands reads. Change a file and only the commands that read it run again. The rest already passed on this exact code. No model is guessing here: land writes down what each command actually read, compares that with what your change touched, and gives the same answer every time you ask.

2

No line to wait in

When agents finish, one land merge takes all their branches and checks them together on top of the latest main. There's no rebase, no second CI run and no merge queue, so ten agents finishing at once don't wait for each other.

3

No conflicts over the same file

land combines changes entity by entity (functions, classes, methods) instead of line by line. Two agents editing different entities in one file are combined automatically, and nobody has to resolve a conflict.

Each picture below shows the same moment twice, once labelled Today (git and CI the way most teams run them) and once labelled With land.

Try it yourself

Push a few changes and compare the two lanes. The timings here are a simplified simulation. The measured results are further down.

0.0 s
Today · git + CI
CIall 12 commandsmain moved: rebase, run CI againpushedmain
on main 0 · CI runs 0 · commands run 0
With land
landonly affected commandspushedmain
on main 0 · checks 0 · commands run 0

You can also click the belts. One click pushes one change, and several quick clicks send a burst, some of which contain a bug.

1 / 5

Everyone pushes at once

Today · git + CI
agent 1
agent 2
agent 3
agent 4
agent 5
agent 6
agent 7
agent 8
time → all 12 commands waiting in line
✗ agent 8 waits for 7 full test runs first
Eight agents finish at once, so eight pull requests wait in one queue, and each one reruns all 12 test commands for a change that touched one package.
With land
agent 1
agent 2
agent 3
agent 4
agent 5
agent 6
agent 7
agent 8
time → 1 command
✓ all 8 on main, none waiting in line
land knows which test commands read the files that changed, 1 of 12 in this example, so one merge checks all eight together and nobody waits in a line.
2 / 5

Two changes, one file

Today · git + CI
orders.py
def first(seq) agent 3
def second(seq)
def last(seq) agent 4
✗ merge conflict · a person has to fix it
Two agents edited the same file, so git reports a conflict and a person has to resolve it while both agents wait.
With land
orders.py
def first(seq) agent 3
def second(seq)
def last(seq) agent 4
✓ different entities · combined automatically
The edits were in different entities, so land combines them and tests the result. Nobody has to step in.
3 / 5

Fine alone, broken together

Today · git + CI
change Atested alone ✓
change Btested alone ✓
main + A + B✗ broken, everyone blocked
Each change passed its tests alone. Together on main they break it, and every agent is blocked until someone finds the cause in the CI logs.
With land
main + A✓ landed
main + A + B✗ 2 tests fail · B sent back
main✓ still green
land tests every change on top of what's already on main, so the clash is caught before it lands, and the agent is told which 2 tests fail.
4 / 5

An agent deletes a failing test

Today · git + CI
tests/test_orders.py
def test_first()
def test_last()
def test_second()
CI ✓ green · the bug ships
An agent can't make a test pass, so it deletes the test. CI turns green and the bug ships.
With land
tests/test_orders.py
def test_first()
def test_last()
def test_second()
✗ sent back · tests are protected
land never lets a merge delete or weaken your tests. The change is sent back with the reason.
5 / 5measured, 16 agents on each side on a large TypeScript monorepo

The same test suite, measured

wait for an answer, per push
today18.8 min
land5.3 min
features shipped
today11
land13
server time
today5.87 h
land0.93 h

Put land on your repo

Sign in with GitHub, pick a plan, add a repository, and add a few lines to your agents' CLAUDE.md.