Catch your agents mid-fall.

Coding agents loop, drift and break things when nobody is watching. Run every task in its own workspace, see each step as it happens, and step in the moment a run starts to fall.

SCROLL TO TAKE CONTROL

Know what happens after you hit run.

Follow a task from launch to output. Inspect the steps, see where it stopped, and choose what happens next.

RUN rn_7Q2F Fix flaky checkout total test acme/storefront · main
RUNNING ELAPSED00:00
TRAJECTORY · LIVE AGENT · coder-01
STEP 01 · LAUNCH Illustrative
Event stream0 events
  1. wsworkspace.create ws-0417✓
  2. gitclone acme/storefront@main✓
  3. shpnpm install8.1s
  4. agentplan · 4 steps
  5. editsrc/cart/total.ts +12 −4
  6. testpnpm test cart✓ 41
  7. testpnpm test checkout✕ 3
  8. editsrc/cart/total.ts same patch×2
  9. editsrc/cart/total.ts same patch×3
  10. !loop.detectedflag
  11. yourun.pause
  12. yousnapshot.restore snap_03
  13. younote → agent
  14. yourun.resume
  15. edittest/checkout.spec.ts +3 −1
  16. testpnpm test✓ 128
  17. propen #482✓
Workspacews-0417
Image
node:20-slim
Compute
2 vCPU · 4 GB
Network
github.com, registry.npmjs.org
Timeout
30 min
Snapshots
every step
Agent plan4 steps
  1. Reproduce the failing checkout test
  2. Locate the rounding in total.ts
  3. Patch and re-run the cart suite
  4. Run the checkout suite
Output · pnpm test checkoutexit 1
FAIL test/checkout.spec.ts
  ✕ totals match at 23:59 local time
    Expected 107.99  Received 108.00
  ✕ applies discount before tax
  ✕ rounds per line item
Tests: 3 failed, 125 passed
Snapshotsrestore point
  1. snap_01
  2. snap_02
  3. snap_03
  4. snap_04
  5. snap_05

NOTE → The failure depends on the time zone. Pin the test clock to UTC; don't change total.ts.

Resultpassed
Tests
128 passed · 0 failed
Output
PR #482 · pin checkout test clock to UTC
Diff
1 file · +3 −1
Interventions
1 · restored from snap_03
Illustrative demo · sample data

See it. Bound it. Step in.

Three controls every autonomous run should ship with. Each one maps to something the operator can actually do.

C—01

See the run

Follow execution step by step, open any event, and read the output that produced the current state.

C—02

Set the boundaries

Decide how a task may operate before it starts: time, compute, network and where it can write.

C—03

Step in when needed

Pause a run, roll it back to a snapshot, add guidance and resume. Or stop it outright.

Sample controls. Pause, snapshots and limits are separate capabilities; show the ones your runtime supports.

Bring your agent. Connect the controls.

APHELION sits between your agent and the machine it works on. Your agent keeps its prompts, tools and model; every run gets a workspace, an event stream and an off switch.

Illustrative · not a published SDK
// Start a run in its own workspace
const run = await aphelion.runs.create({
  agent: "./agents/coder",
  repo: "github.com/acme/storefront",
  task: "Fix the flaky checkout total test",
  limits: { timeout: "30m", cpu: 2, memory: "4GB" },
  network: { allow: ["github.com", "registry.npmjs.org"] },
  snapshots: "every-step",
});

// Watch it, and step in when it drifts
for await (const event of run.events()) {
  if (event.type === "loop.detected") {
    await run.pause();
    await run.restore(event.lastGoodSnapshot);
    await run.resume({ note: "Pin the test clock to UTC." });
  }
}
# Start a run in its own workspace
run = aphelion.runs.create(
    agent="./agents/coder",
    repo="github.com/acme/storefront",
    task="Fix the flaky checkout total test",
    limits={"timeout": "30m", "cpu": 2, "memory": "4GB"},
    network={"allow": ["github.com", "registry.npmjs.org"]},
    snapshots="every-step",
)

# Watch it, and step in when it drifts
for event in run.events():
    if event.type == "loop.detected":
        run.pause()
        run.restore(event.last_good_snapshot)
        run.resume(note="Pin the test clock to UTC.")
# Start a run in its own workspace
$ aphelion run ./agents/coder \
    --repo github.com/acme/storefront \
    --task "Fix the flaky checkout total test" \
    --timeout 30m --cpu 2 --memory 4GB \
    --allow github.com,registry.npmjs.org

✓ rn_7Q2F started in ws-0417  · streaming events

# Step in from another terminal
$ aphelion pause rn_7Q2F
$ aphelion restore rn_7Q2F snap_03
$ aphelion resume rn_7Q2F --note "Pin the test clock to UTC."
run.events()rn_7Q2F · live
    0 eventsSample data
    01You bring
    The agent, the repository and the task. Keep your model, prompts and tools.
    02APHELION provides
    A fresh workspace per run with limits, snapshots and a structured event stream.
    03A task starts
    With one API call or CLI command. The run id is your handle for everything after.
    04When it stops or fails
    You get the event, the output and the last good snapshot. Restore, resume or stop.
    01Start
    runs.create()One call starts a task in a fresh workspace with your repo, limits and network policy.
    02Watch
    run.events()Commands, file changes, tests and outputs, streamed as they happen.
    03Step in
    pause · restore · resumeFreeze the run, roll back to a snapshot, add guidance and carry on.
    04Collect
    run.result()The diff, logs and artifacts, plus a record of every intervention.
    01Any agent
    If it can run a shell command, it can run here. Keep your model, prompts and tools.
    02Your repo
    Cloned fresh into every workspace. Nothing carries over between runs.
    03Your rules
    Time, compute, network and write access, set before the run starts.
    04Your alerts
    Webhooks for loops, failures and budget limits, wherever your team already looks.

    Before you let it run.

    Sample answers for this concept. Replace them with your product's real limits and terms.

    01What kinds of tasks and code can execute?

    Anything your agent can drive from a shell: builds, tests, package installs, scripts and headless browsers. Each run starts from your repository and the toolchain image you declare.

    02What is the isolation model?

    One workspace per run, with its own filesystem, processes and network policy. Nothing is shared between runs unless you mount it explicitly.

    03What persists between runs?

    The workspace is discarded when a run ends. Logs, events, snapshots and artifacts are kept for 30 days. Persistent volumes are opt-in.

    04Which execution and recovery controls are available?

    Pause, resume, restore a snapshot, send guidance to the agent, and stop. Snapshots are taken at step boundaries, so a restore rolls back files and the working tree to that point.

    05What limits apply?

    You set runtime, CPU, memory, disk and network per run or per policy. The defaults are 30 minutes, 2 vCPU, 4 GB and no outbound network.

    06How is usage measured and billed?

    By workspace-seconds while a run is active, plus snapshot storage. Paused runs don't use compute.

    Take the controls.

    Run every agent in a workspace you can see into. Step in before a bad run becomes a bad merge.

    TemplateGet this page$79