Cloud agents
Ellipsis runs Claude Code in isolated cloud sandboxes with your repos cloned and your toolchain installed. Sessions survive the closed laptop, credentials are minted per session, spend is capped, and every step is recorded. It is the upgrade path from one agent on one machine to a governed fleet.
What are we shipping today?
JavaScript was built in 10 days. It now runs most of the visible internet. Sleep well.
Every session gets its own GitHub token, scoped to the repos and permissions you grant and expiring in an hour, plus an API token scoped to that session. Spend runs under hard caps per session, per agent, and per developer. No standing credentials, no surprise bills.
Permissions minted per session, spend capped before compute starts
A cloud session is a durable conversation. It idles when it finishes, wakes when you message it, and picks up with the working tree and transcript intact. Hand off uncommitted local work with one command and the agent keeps going in the cloud.
$ agent session handoff "finish the validator; tests fail on shift boundaries"
pushed working tree snapshot · uncommitted changes included
session_3Fw8dK1r · continuing in the cloud · splitshift-api
✓ safe to close the laptop, the session keeps working
Idle conversations cost near zero and wake in seconds
Each session runs in its own isolated sandbox with repositories pre-cloned and dependency installs baked into a cached image, so repeat sessions start in seconds. Parallel agents spawn the full stack and run the tests without clobbering each other.
Isolated sandboxes with your toolchain installed, cached across sessions
Watch any session live, or answer which agent session produced PR #123 months later. Every turn, tool call, and thinking block lands in one transcript the whole team can search, and the exact instructions each run launched with are auditable next to what it did.
Transcripts outlive the sandbox
Start a session from a terminal, POST /sessions from CI, mention @ellipsis on GitHub, Slack, or Linear, or let a Sentry alert or a cron schedule start it for you. Every entry point produces the same governed session.
One session model behind every entry point
Prompt, model, sandbox, permissions, and budget live in one version-controlled file, deployed with git push. Your existing review process becomes the change-control process for your fleet.
ellipsis: version: v1 name: Feature builder description: Implement the change described on the issueclaude: model: claude-opus-4-8 system: | Implement the change the issue describes. Read the surrounding code first, follow the conventions you find, and run the test suite before you open the pull request.trigger: type: react issue: on: [opened] labels: [agent]sandbox: repositories: - name: splitshift-apibudget: session: 2.00 day: 20.00Define once, governed everywhere
The managed layer around every session, so none of it is each developer's job.
Every session gets its own Linux container. Parallel agents never share state.
The repositories the config names are checked out before the agent starts, with gh authenticated.
Dependency installs bake into a cached image, so repeat sessions start in seconds.
Minted per session with exactly the repos and permissions the config grants, expiring in an hour.
Stored values inject by name into allowed sandboxes and can never be read back out.
Per-session caps plus trailing limits per account, agent, and developer, enforced before compute starts.
Watch any session over a WebSocket with lossless resume, from the dashboard or the CLI.
Every turn, tool call, and thinking block is recorded and searchable by the whole team.
The complete history exports as first-party records, so audits read a ledger.
Re-run any session with its frozen original config, or override the model, budget, or prompt.
Open a real editor into a live sandbox to review the diff and run tests where the agent worked.
Sessions can exit through your JSON schema, so pipelines get typed data instead of prose.
A coding agent that runs in a managed cloud sandbox instead of on a laptop. Ellipsis creates an isolated container with your repositories cloned and your toolchain installed, runs Claude Code inside it, and records everything it does. The session outlives the terminal that started it.
It is the same agent, managed. Sessions keep working when the laptop closes, the config is shared and version controlled instead of living in one person’s setup, credentials are minted per session instead of being your own, spend runs under hard caps, and every session is recorded and searchable by the team.
Yes. Each session gets its own GitHub token, minted with exactly the repositories and permissions the agent config grants, down to read-only, and expiring in an hour. GitHub enforces the scope at the mint, so nothing running in the sandbox can exceed it.
Every session runs under a hard cap, with trailing daily, weekly, and monthly limits per account, per agent, and per developer. A session that reaches its cap stops cleanly and records budget_hit, and a session blocked by a trailing limit never even creates a sandbox.
Every turn, tool call, and thinking block is recorded into a searchable transcript, along with the exact instructions the session launched with. You can watch a session live, search the whole history, download the complete log, or replay the session months later.
Through the Ellipsis GitHub App. The repositories an agent needs are cloned into its sandbox at session start using a scoped, short-lived installation token. Your code exists only inside the sandbox and is deleted when the sandbox is torn down.
A terminal command, a POST to the REST API, an @ellipsis mention on GitHub, Slack, or Linear, a repository or Sentry event, a cron schedule, or the dashboard. Every entry point produces the same governed, recorded session.