Deploys at the speed agents iterate.

the loop - try it

Run a deploy right here. Then break one.

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

stop burning compute

An agent iterating 100 times a day:

Extrapolated from measured medians on two paths that are not the same app - read it as "orders of magnitude", not a precise multiple.

how it works

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

the archivist

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

After every promote, hotlane rebuilds your app from source, in the background, pushes it to your registry, and periodically diffs 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

Drift pings your webhook; the next push rebuilds from the clean image. Fast lane and audit trail, both real.

measured, not promised

Benchmarked against a real production pipeline.

Real build steps (tsc, pip), 10 runs each. Your build and boot time are the floor; the machinery adds well under half a second.

That last row is not like-for-like: it is a real pipeline deploying a bigger system, and these small apps would run faster through a fresh one. The structural claim is the honest one - a pipeline pays runner queue, checkout and toolchain setup (60-120s) before it builds anything, then an image build, a registry round-trip and a scheduler deploy. hotlane skips that by mutating a machine already running your app. Method, per-run data and caveats.

under fire

398 deploys under constant load. Zero dropped requests.

Six concurrent agents pushed, held test forks and promoted against one daemon for 25 minutes - a verified deploy every 3.8 seconds - while a steady 100 req/s hit the app. On a 2-vCPU VPS.

The honest tail: ~1% of requests stalled 1-2s (p99 1.0s) while docker commit snapshots the live container at each push - delayed, never dropped. Harness, method and raw numbers.

built for agents

The whole loop, about a second per turn.

• hotlane pushdelta → verified → live, ~2s
• hotlane testhold a fork; validate it while users stay on live
• hotlane promoteship the exact instance you tested - nothing rebuilt in between
• hotlane rollbacksub-second undo, no builds
• hotlane mcpnative MCP tools; -json on every command
• status.queuesee the deploy queue before joining it - push now, or go do other work (multiple agents, one box)
• llms-full.txtone fetch teaches an agent the entire contract

install

One binary. It is the daemon and the CLI.

curl -fsSL https://hotlane.dev/install.sh | sh
# or: brew install StefanIancu/hotlane/hotlane  |  npm i -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

Anywhere Docker runs. One binary, one config file, no YAML zoo.