Keep the workflow YAML, actions, expressions and environment files you already use. preloop runs each job on an isolated runner, caches what it can reuse, and skips the tests a change doesn't affect. When a job fails, you can open it, fix it in place and retry from any step.
A GitHub Actions workflow arrives unchanged. preloop resolves expressions and matrices, runs each job on a fresh isolated machine, and keeps the actions, environment files and cache keys your repository already uses. It records what each step read, which tests ran, what the run produced and why work was reused or skipped.
Use one capability or combine them. The CLI drives runs, logs and debugging from a terminal or an agent. Runners provides isolated machines and shared caches. Incremental reuses work when its inputs are unchanged. Test Intelligence detects affected tests and selects them. Debug keeps a failed job available for inspection and retry. Code Workflows generates standard workflow YAML from code. Optimize proposes measured workflow changes for review.
Steps and jobs whose inputs have not changed are not run again. You get the same result without paying for the same work twice.
Explore Preloop Incremental
Run only the tests your change can affect. Suites finish sooner, and flaky tests are caught instead of retried.
Explore Preloop Test Intelligence
Test your local, uncommitted changes on preloop before you push, for a much faster feedback loop.
Explore Preloop CLI & APIChange one line and your jobs run on gaming-class CPUs and the latest dedicated AMD hardware — up to 3x faster, with no cap on how many run at once. Every job gets its own microVM, and every run is measured as it happens.
Explore Preloop Runners
Your existing cache steps get faster without a single edit. preloop sits in the path of the cache calls your actions already make and serves them from NVMe beside the runner, backed by replicated object storage.
Explore Preloop CacheIn addition to being able to shell into your running job, the preloop debugger lets you set breakpoints and retry from any step in your workflow, all drivable by your agent.
Explore Preloop Debug
Write your workflows in the language your team already uses. preloop turns them into the standard workflow files GitHub runs.
Explore Preloop Code Workflows
Agents watch your CI and propose changes that make it faster and cheaper. Each one comes with the evidence, so you only merge what pays off.
Explore Preloop Optimize
| Layer | Detail |
|---|---|
| Execution | Every job runs on a hosted machine. `plp ci run` uploads a git bundle of your working tree, including uncommitted files, so a job can run before you push. |
| Runner | A static runner binary inside a single-use microVM on dedicated hardware. |
| Isolation | One environment per job, built from the official GitHub runner image and destroyed when the job ends. |
| Cache | One cache pool serves eighteen cache protocols, namespaced per repository and ref. |
| Records | Canonical JSON signed with RS256; public keys are published. Records append per organization. |
| Runner platform | Linux on amd64 and arm64, on dedicated hardware. |
| Startup | A job starts in a fresh environment straight away; there is no machine to boot or provision. |
| Job deadline | Every job has a 60-minute hard deadline. A newer push cancels stale runs for the same pull request. |
| Submission | You can debounce submission per repository and workflow: quiet for 60 seconds, wait at most 600, one submission for the latest commit. Off by default. |
| Output | Jobs can emit SARIF, so results show up as code-scanning annotations on the pull request. |
Every run operation is available through the API. Submit, stream, inspect, pause, retry, attach and attest without reading a rendered page. The dashboard uses these same operations.
Submit a run and receive its id and resolved plan before jobs start.
Stream NDJSON events or live logs over SSE.
Attach to a job paused with --debug, read its state, retry from any step and detach. One writer lease at a time; everyone else reads.
Read why work was skipped: step reuse, test selection or cache lookup. Every skip has a reason code.
Publish a signed record of what ran and verify records the same way.
Yes. Keep the workflow YAML, actions, expressions, environment files and cache keys. Move execution by changing the runner label; no second workflow format is required.
Yes. plp ci migrate scans your repository, writes a plan and opens a pull request that changes the runner label. Review it like any other PR.
Stock actions/cache keeps working with the same keys, restore keys and semantics. preloop serves it from one cache pool, so the same file is not stored again under every key.
No. Pricing follows execution: runner-seconds held and cache bytes stored. Skipped and reused work costs nothing.
Point one workflow at preloop and run it once. That run gives later reuse decisions a history and gives you a record to compare with the provider result.
Change one runner label and run the workflow. Add other capabilities after you can see the first run.