Drop-in, agent-native GitHub Actions that runs locally, or self-hosted.

Verify code at the speed agents write it.

Preloop is an agent-native CI engine, built in Rust. Every job runs in its own hardware-isolated microVM that boots in under 200 milliseconds on macOS, Linux, or Windows. The same engine runs locally or self-hosted: a workflow that passes on your machine passes in CI.

INSTALL_SCRIPT COPY_INSTALL_CMD COPY_AGENT_INSTRUCTIONS

JOB: #8492_AGENT_PR TIME_ELAPSED: 1.16s

00.00 SYS   REQ_RECEIVED PR #402
00.01 PROV  ALLOCATING MICRO_VM (linux-arm64)
00.17 OK    VM_BOOT_COMPLETE [174ms]
00.18 EXEC  PULLING REPO /agent-generated-patch
00.24 EXEC  RUN: cargo test --workspace
01.01 OUT   test result: ok. 142 passed; 0 failed;
01.07 EXEC  RUN: npm run lint
01.14 OUT   All files pass linting.
01.15 OK    WORKFLOW_COMPLETE [1.15s]
01.16 SYS   TEARDOWN_INITIATED

01 THE_BOTTLENECK

THE OLD VERIFICATION STACK WAS BUILT FOR HUMAN-SPEED OUTPUT.

Legacy CI was built for human-speed output: minutes to provision a runner, containers that share your host kernel, and failure pages designed for manual inspection.

When an AI agent ships code all day, every change is untrusted by default. Waiting four minutes for a runner to boot nullifies the advantage of automated generation.

02 EXECUTION_MODEL

[A] GHA_PARITY

{ .YML } → ||

Drop-in GitHub Actions compatibility. Your existing workflows run unchanged, verified against the official runner, not approximated.

[B] MICROVM_ENV

[ μVM ]

Every job gets its own dedicated microVM. A real kernel, hardware-isolated, not a shared one. Boots in under 200 ms on macOS, Linux, or Windows.

[C] LIVE_DEBUG

>_ ↔ █

Pause-on-failure. When a job fails, the machine freezes. Open a shell at the exact failure state, or fork the machine and retry from the step that broke.

[D] DAP_DEBUG

▸_ ↔ DAP

Built-in Debug Adapter Protocol bridge. Attach a DAP client like VS Code to a paused job and step through the failure. Built in, coming soon.

[E] X86_ON_ARM

x86 → arm64

Run x86_64 workflows on an Apple Silicon Mac. Rosetta translation keeps them near native speed, so amd64 CI does not need an amd64 machine.

[F] WARM_STATE

[ ▓▓▓░ ]

After the first run the whole filesystem stays warm. Dependencies, compiled output, and package caches are still there, so the next run skips the install phase entirely.

03 ARCHITECTURE_DELTA

LOCAL-FIRST PARITY The same engine runs on your laptop and on self-hosted workers. If it passes locally, it passes in CI. Zero environment drift. Hand a warm machine snapshot to a bigger host and continue with every cache intact.
FULL STACK OWNERSHIP The runner, the control plane, and the CLI are built in Rust. One fast binary, no Node runtime, no JVM, no orchestration sprawl.

AGENT-OPERABLE API Built to be operated by agents, not just triggered.
DENY-BY-DEFAULT Network is off until you switch it on. Secrets are referenced from the host at launch, so they are never baked into a machine or its snapshots. Agent-generated code stays quarantined.

04 THE_AGENT_LOOP

RUN WHAT IS ON YOUR DISK. preloop run tests your working tree as it is, uncommitted and untracked files included. Checkout inside the job pulls your local tree instead of a pushed commit, and your git index is never touched.
THE FAILED JOB STAYS ALIVE. A failing step holds its microVM open by default, with the checkout, toolchain, services, and warm caches exactly as the test left them. There is nothing to reproduce.
FIX IT, RETRY THE STEP. preloop debug attaches to the paused step. Edit the code, run :retry, and only that step runs again. Build caches survive, the debris from the failed attempt does not.
TAKE THE FIX WITH YOU. Edits you made inside the VM come back to your workspace as a patch with preloop debug --export. Add --json and an agent drives the identical loop.

PRELOOP CLI LOOP: RUN → FIX → VERIFY

$ preloop run
→ VERDICT: FAILED, step 3/8 (cargo test)
→ VM PAUSED, caches warm, services up
$ preloop debug
› :retry
→ RE-RAN STEP 3/8 ONLY
→ VERDICT: PASS [1.2s]
$ preloop run --sync
→ PUSHED TESTED SHA, PR #402 UPDATED

05 NO_WEBHOOK_REQUIRED

THE SHA THAT LANDS ON GITHUB IS THE SHA THAT WAS TESTED.

Every other CI waits for GitHub to hand it a webhook. When that delivery path breaks, a tunnel drops, a secret rotates, or GitHub has an incident, CI goes dark and the missed events never come back.

Preloop inverts it. You submit the run straight to the server and it starts immediately. GitHub becomes the place results land, not the thing runs wait on.

PUSH_CONFIRM. preloop run --sync runs CI on your workspace, then pushes the tested commit and confirms it on the PR with check runs. The push happens after the verdict, not before.
ONLY TESTED CODE GETS PUSHED. When the run finishes, the CLI pushes the exact commit it tested. Fast-forward or a new branch only. A force push never happens on its own.
THE PR UPDATES ITSELF. The server opens or updates the pull request, draft by default, and reports check runs against the tested commit.
SAFE TO REPLAY. GitHub unreachable? The push retries on its own, and preloop sync replays the whole thing. Every step is idempotent.

06 SYSTEM_SPECS

GHA_COMPATIBILITY	Drop-in for existing workflows. Property-tested, formally verified, with wire compatibility steps.
COLD_START_LATENCY	< 200 ms to a running microVM
PLATFORMS	macOS (Apple Silicon) · Linux · Windows
WORKSPACE	Runs your working tree, uncommitted and untracked files included

CONTROL_PLANE	Rust end to end: runner, control plane, CLI
ISOLATION	One dedicated microVM per job; network off by default
MEM_FOOTPRINT	Elastic. The host commits only what a job actually uses
SELF_HOSTING	preloop serve runs the control plane and microVM pool on your own box

07 DEMOS

[A] DROP_IN

An existing GitHub Actions workflow, run as-is. No config changes, no rewrites.

[B] DEBUG_LOOP

A failing job, a split terminal. Fix the file on the host, rerun, and the same warm machine goes green.

[C] AGENT_LOOP

An agent drives the loop: submit, read the verdict, patch, resubmit. Machine-readable end to end.

08 ACT_VS_AKSH

ACT REIMPLEMENTS THE RUNNER. WE REIMPLEMENTED THE CONTROL PLANE AND THE RUNNER, WITH THE REAL WIRE PROTOCOL BETWEEN THEM.

act is a pragmatic Go binary that runs steps in Docker containers on your host kernel. Fast to start, but it cannot guarantee parity: no wire protocol, no OIDC, no concurrency groups, no debugger. On the same 39-scenario benchmark, act gets 29/39 right, aksh gets 31/39 — with typical runs in 400-800 ms.

FEATURE	ACT	AKSH
SCOPE	Runner only (Go CLI)	Control plane + runner (Rust)
FIDELITY	Behavioral, mostly works	Official wire protocol, the runner cannot tell the difference
EXECUTION	Docker containers on your kernel	One dedicated microVM per job
VERIFICATION	Community bug reports	Golden wire captures replayed, differential + property tests
BENCHMARK	29/39 scenarios (74%)	31/39 scenarios (79.5%), sub-second typical runs
DEBUGGING	None	DAP debugger, breakpoints, stepping
OIDC + CONCURRENCY	Not supported	Full OIDC provider, concurrency groups
PLATFORM	Linux Docker only	macOS, Linux, Windows

FULL COMPARISON → DOCS/ACT_VS_AKSH.MD (act vs agent-ci vs aksh vs Gitea Actions, with the full 39-scenario benchmark)

INSTALL_CLI

curl -fsSL https://preloop.dev/install.sh | sh