Your pipeline rebuilds the world. hotlane forks it - and ships in 978 ms.

Push a change and hotlane forks the app that is already running, applies your delta, verifies the fork in isolation, and flips traffic to it. Rollback is a pointer, not a pipeline.

one real push, end to end 0 ms

snapshot 179ms patch 43ms boot 743ms verify 13ms

the loop - try it

Run a deploy right here. Then break one.

simulated daemon - timings replayed from the real benchmark live: v7

# press a button - each run replays a real push at real speed

$ hotlane push
fork hotlane-api-v8 (v8): snapshot 179ms | patch 43ms | boot 743ms | verify 13ms
  ok   http: /health == 200 (13ms)
PROMOTED v8 live in 978ms

how it works

The running app is the deploy unit - not a cold-built image.

fork

Snapshot the live container - warm dependency caches and incremental build state ride along free - and apply your git delta to the copy.

verify

The fork boots on a side port and must pass your hooks: health checks, smoke scripts. Production traffic never touches an unverified fork.

flip

Promotion swaps a proxy pointer. The old version stays parked in a ring - rollback restarts it and flips back in well under a second.

the archivist

Fast because it reuses. Trustworthy because it never stops checking.

Copies of copies rot: stray state accumulates, someone hotfixes a container by hand, and git quietly stops describing production. So after every promote, hotlane rebuilds your app from source, from scratch, in the background - the image classical CI would have made, minus the waiting - and periodically boots that clean build to diff its behavior against live.

$ hotlane drift
DRIFTED: behavior differs on /: clean build serves "hello", live serves "TAMPERED"
next push will rebuild from hotlane-api:clean

Divergence pings your webhook (Slack or Discord native), and the next ordinary push rebuilds from the clean image - the chain heals itself. Every version is also pushed to your registry as a durable, pullable, from-source image: the audit trail survives the host.

measured, not promised

Benchmarked against a real production pipeline.

path	push to verified live (median)	rollback
GitHub Actions pipeline (15 real runs)	8m 13s	re-run the pipeline
hotlane - TypeScript / Express	1.72s ~286x	0.64s
hotlane - FastAPI	1.18s ~417x	0.65s

Small apps with real build steps (tsc, pip), 10 runs each. Your own build and boot time dominate the total - the machinery itself adds well under half a second. Full method and caveats in the repo.

built for agent loops

An agent can't wait eight minutes to learn it was wrong.

Agentic development is push, observe, fix, push again - dozens of times an hour. hotlane makes each turn of that loop cost about a second, and makes the failure case safe: a bad push is rejected in isolation, with the failing hook and the fork's logs returned to the caller, while production keeps serving.

api

one endpoint

POST a raw git diff to /v1/push. The response is JSON: phase timings, hook verdicts, promoted or rejected with logs. Anything that can curl can deploy.

gate

bad pushes die in isolation

Verify hooks are the agent's guardrail: unverified code never receives a byte of traffic, and a rejection is a structured signal to iterate on, not an incident.

undo

rollback is a pointer

Sub-second, no builds, no pulls. The agent - or you - can always get back to the last good version instantly.

Agents can learn the whole tool from hotlane.dev/llms.txt.

install

One binary. It is the daemon and the CLI.

curl -fsSL https://hotlane.dev/install.sh | sh
# or: npm install -g hotlane  |  pip install hotlane

cd your-app
hotlane init                  # detects Node / Python / Go, writes hotlane.yml
hotlane serve                 # boots the warm pool, proxies traffic
hotlane push                  # ~1s later: verified and live

Runs anywhere Docker runs: your VPS, bare metal, a Raspberry Pi, any cloud. No Kubernetes, no YAML zoo - one daemon, one config file.