statefoldJoin the waitlist

Coding agents that keep working while you’re away.

Cloud sandboxes for the coding agents you already pay for. Hand off a task, close the laptop, merge from your phone.

Runs the five harnesses you already pay for

  • Codex
  • Claude Code
  • OpenCode
  • Pi
  • Gemini CLI

One thread, from your terminal to a merged pull request

  1. You hand off from the terminal

    statefold “fix the token refresh race”

  2. A sandbox boots

    Its own container, with your uncommitted work. Codex starts on your subscription.

  3. Codex delegates

    Claude Code plans the fix. OpenCode reviews the diff.

  4. Pull request #482 opens

    The thread subscribes to its checks, then goes quiet.

  5. CI fails, the thread wakes

    auth.spec.ts rejects an expired token. Fix pushed in 7e02b1d.

  6. Checks pass, the sandbox sleeps

    A sleeping thread costs nothing.

  7. Your phone says Ready to review

    One notification, with what the agent said. You merge from the train.

Diffs, a terminal and the running app, beside the thread

The sandbox is a real machine with Docker. Read what changed, run a command yourself, or open the app the agent just started, on a private link.

Review the diff

src/auth/refresh.ts+3−1
41 export async function refresh(session: Session) {
42-  const next = await rotate(session.token);
42+  await store.lock(session.id, { timeout: LOCK_MS });
43+  if (isExpired(session.token)) throw new ExpiredToken();
44+  const next = await rotate(session.token);
45   return save(session, next);
46 }

src/auth/refresh.test.ts88+test("concurrent refresh takes one lock", async () => {
89+  await Promise.all([refresh(session), refresh(session)]);
90+  expect(store.locks).toBe(1);
91+});

maya on line 42
Can we keep the lock timeout configurable?

Thread woke and pushed 7e02b1d

Open a terminal

tmux · api
$ bun test src/auth
✓ rejects an expired token
✓ rotates once under load
✓ concurrent refresh takes one lock

3 pass, 0 fail · 2.4s
$

Open the running app

private links
  • 3000webOpen preview
  • 5432postgres, in Docker
  • 6006storybook, stopped

Merge from your phone

web push
Needs you

Migrate billing webhooks: which Stripe account?

Ready to review

Fix token refresh race: #482 checks passed. “Moved the rotate under the lock and added a concurrency test.”

ReviewMerge #482

One thread can hire other harnesses

A Codex thread asks Claude Code to plan and OpenCode to review, waits for both, then carries on with their results. Each child gets its own sandbox and history. There is no pipeline to build.

CodexWorking

Fix token refresh race

Waiting on 2 child threads
Claude Code4m 12s

Plans the fix

Lock the session, reject expired tokens before rotating, add a concurrent-refresh test.
OpenCode2m 51s

Reviews the diff

One finding: the lock timeout is hard-coded.

Threads wake on events, not on you

Say “watch CI and email me when it’s green” once. When a check, a review, a schedule or a mention fires, the same thread wakes with its full history and picks the work back up.

  • A CI check finishesGitHub
  • A reviewer commentsGitHub
  • You write @statefoldGitHub
  • An issue is assignedLinear
  • Weekdays at 9:00Schedule
  • A script calls the APIAPI token
InboxDelivered at the next safe turn
Migrate billing webhooks

Woke 21:21 · CI failed on #479

Same sandbox, same history, no new thread.

Every new thread starts with your project’s context

Conventions, tools and credentials carry over between threads and between harnesses.

  • ProjectSession refresh goes through store.lock().

    FeedbackKeep pull requests under 400 lines.

    YouPrefers Vitest for new tests.

    Remembers project decisions

    Opt-in memory saves conventions and your feedback after each turn. Inspect, edit or forget any note.

  • $ship-checklistskill

    $review-migrationsskill

    @Fix token refresh racethread

    #482pull request

    Loads your skills and MCP servers

    One skills library for all five harnesses. MCP sign-ins and project secrets stay on Statefold’s side.

  • Shares a thread by link

    Send a teammate the whole run: every message, command and diff, on an unlisted page.

Full access inside the sandbox. Your keys never enter it.

Agents run without approval prompts because each thread is isolated. The container only ever holds a placeholder; the real credential is swapped in as the request leaves, for hosts you approved.

Sandbox, one per threadOPENAI_API_KEY=sf_ph_8f2…

The agent and its tools see a placeholder.

Egressswapped here
api.openai.comBearer sk-proj-••••••

Billed to your account, never shared.

  • One container per thread

    Asleep when idle, with a snapshot of the workspace.

  • GitHub tokens last minutes

    Minted per request, scoped to repositories you can reach.

  • Passkeys and two-factor sign-in

    Export every thread or delete the account at any time.

Pay for machines, not tokens

Credits pay for sandbox time, billed per second while the machine runs. Model tokens come from your own subscriptions and keys, with no markup. A sleeping thread costs nothing.

Machine rates per hour
MachineSizePer hour
standard-10.5 vCPU · 4 GiB · 8 GB disk$0.10
standard-21 vCPU · 6 GiB · 12 GB disk$0.20
standard-3default2 vCPU · 8 GiB · 16 GB disk$0.30
standard-44 vCPU · 12 GiB · 20 GB disk$0.55

$3starter credit for a new account, about 10 hours on the default machine.

  • $10, $50 or $100 a monthEach plan grants its price in credits.
  • Top up from $10Purchased credit carries over.

Also in every workspace

Docker on demand
Run Postgres, Redis or a browser inside the sandbox.
Four machine sizes
Move a thread to a bigger machine when it runs out of memory.
Sleep and wake
Snapshots keep the workspace; a message wakes it.
Fork and rewind
Fork from any finished turn, or edit a message and resend.
Queue and steer
Queue follow-ups, reorder them, or steer a running turn.
Dictation
Speak a prompt from your phone.
Installable app
Push notifications, a badge and a share target.
Teams
Share projects and skills with a few people.

Questions

No. Statefold runs the native harnesses you choose (Codex, Claude Code, OpenCode, Pi and Gemini CLI) and gives them a sandbox, git access and a thread that persists. The agent is still the agent you know.

Credits pay for machine time, from $0.10 to $0.55 an hour depending on size, billed per second while the sandbox runs. Model tokens come from your own subscriptions and keys and are never marked up. A new account gets a $3 starter credit.

No. Every thread runs with full access inside its own isolated sandbox, so commands and edits never wait on you. Agents are told to make reasonable, reversible decisions and only ask when they genuinely can’t proceed. They ask before force-pushing or merging.

Yes. Connect your own harness subscriptions and API keys. They stay outside the container and are swapped in at egress, and you can see health and quota per connection.

Status is derived from what’s running and linked: Working, Needs you, Ready to review, Done, Failed or Limited. A thread is Done when its pull request merges. You get one notification when it goes idle while you’re away and one when it needs you.

By delegation. A thread can start child threads on any harness or model, wait for their results and continue. You can also fork a thread from any finished turn, or attach another thread as context with @.

With memory on for a project, threads save durable notes after completed turns: conventions, decisions and your feedback. New threads recall what’s relevant on any harness. Personal preferences stay private, and you can inspect, edit or forget any note.

No. The CLI hands off your current checkout, including uncommitted work, without touching your local branch.

Your next task, shipped while you’re away

Private alpha. Bring your own subscriptions and keys.