Questions, answered without hedging

Promigence is a sandbox platform for AI agents: production-grade, fully isolated sandboxes that start in milliseconds, stay fast at a thousand at once, and bill by the second. It runs coding agents, background agents, evals and RL environments, each in its own sandbox built from your repository.

An environment runtime treats the execution environment as the product: it proves the environment works before anything runs in it, reproduces it exactly from a hash, and forks it many times over. A sandbox provider gives you a box that starts; an environment runtime gives you an environment that is known good.

Promigence solves silently broken environments. In a thousand-episode run some environments fail to install or come back cold, and that shows up as the agent failing the task, which corrupts the eval number and poisons the reward signal in RL. Promigence verifies every environment first and reports environment failures separately from task failures.

Promigence is for teams that run AI agents: agent companies building products on them, eval and platform engineers, benchmark producers and RL environment vendors. Any agent work fits, from one interactive sandbox to thousands of episodes at once.

No. Promigence is the execution plane eval platforms run on, it has no datasets, scorers, judges or experiment tracking, which belong to your eval tools. It provides the verified environment the episode runs inside, and plugs in as a backend for those harnesses.

A validity report is what Promigence returns after every run: how many environments were verified, which failed, and whether each failure was the environment's or the task's. Most teams running evals today cannot produce that number, which means they cannot say how much of their result is real.

An episode is one environment's life in Promigence: fork, execute, terminate: 15 minutes by default, up to an hour in the private beta. Usage is metered per second, like the rest of the market, but the episode is the unit a quote and a spend cap are written against, so the maximum cost of a run is a multiplication you can do before you start it.

Yes. A sandbox pauses when it goes idle, wakes on the next request, and bills only while it is awake.

Promigence is built around four things together: sandboxes that are ready in milliseconds and stay fast at a thousand at once, environments verified before an agent runs in them, a report that labels every failed run as the task's, the environment's or Promigence's, and a bill that is quoted and capped before the run starts. Runs that fail because of Promigence are not billed when our side can show the failure was ours.

Because a do-it-yourself setup cannot tell you how many of your environments were broken on the last run. What Promigence adds is verification, reproducibility, burst scheduling and nobody on call.

Promigence meters per second at $0.0504 per vCPU-hour plus $0.0162 per GiB-hour, the market's standard list rate. That works out at $0.17 an hour for a small sandbox (2 vCPU, 4 GB), $0.46 for medium (4 vCPU, 16 GB) and $0.92 for large (8 vCPU, 32 GB). New accounts get $50 of free credit for 30 days: $10 straight away with no card, and $40 more once a card is added (card payments open after the private beta).

Per second, at the market's standard list rate, because that is what the market meters and a price nobody can compare against is worth very little. The episode survives as the unit you are quoted in: promigence run quote returns the maximum a run can cost before it starts, and --cap refuses one that would go past your ceiling.

Yes. promigence run quote returns the exact maximum cost before any environment starts, and --cap refuses a run that would exceed your ceiling rather than stopping halfway through. Paused time is not invoiced, and nothing accrues before an environment is handed to you.

Yes: $50 of free credit for 30 days, $10 straight away with no card and $40 more once you add one (card payments open after the private beta), with 20 concurrent sandboxes and sessions up to an hour. During the private beta, signing up needs an invite code. Separately, any team can send their environments in for 1,000 verified episodes, a validity report and an exact bill quote, free and once.

Promigence runs one primitive: verify, snapshot, fork, exec, report. You declare a container image, setup steps (a clone of your repository at a pinned commit among them) and a verify command. The snapshot is stored only if verification passes. You then copy it N times into warm environments and get back a validity report and a bill that never exceeds the quote you saw first.

Each environment is fully isolated from every other, and nothing is shared with another customer. We test that boundary by attacking it rather than asserting it, and runs can start with no network at all.

Promigence copies an environment that has already finished installing and building, instead of booting and installing it again. A copy takes 39 ms, and a hundred at once still land at 122 ms.

The same snapshot hash returns a bit-identical environment on any later date, so an eval you ran in October can be re-run in March and the comparison means something. That is stronger than a recipe that re-resolves package versions underneath you on every build.

Yes. Adapters for common eval harnesses are in pre-release, and the TypeScript SDK exposes a compatibility Sandbox class with the familiar sandbox calls, so existing call sites run unchanged.

You store a secret once and name it on the runs or commands that need it (--secret NAME). It is encrypted at rest, given only to the commands that name it, and removed from logs and outputs. It is never written into a snapshot you build, and a snapshot of a sandbox that was given a secret is refused unless you force it.

Not as a self-serve product today. If your data cannot leave your boundary, talk to us about running it in your own cloud account.

Promigence records the failure as the environment's in the validity report. A sandbox that fails before hand-over is retried once automatically; one that fails mid-run can be re-run with promigence run replay, as a new sandbox billed under the run's cap. A run with a 3% environment failure rate reports 3%, instead of quietly reporting a 3% worse agent.

Every figure on the benchmarks page states its date, its sample size and the conditions it was measured under, and the free validity report runs your own workload so you can check the numbers yourself.

Promigence is in a private beta: signing up needs an invite code, and support@promigence.ai is where to ask for one. New accounts get $50 of free credit: $10 straight away with no card, and $40 more once a card is added (card payments open after the private beta). Teams who want a number on their own workload first can send their environments in for a free 1,000-episode run and a validity report.

No. Promigence is not owned by a lab or a hyperscaler and runs any vendor's agent. Neutrality is a requirement rather than a stance: a cross-lab evaluation cannot run inside one lab's harness.