Console
Login to ChatLogin to Console
Capability · Agent Harness

Real coding agents, running in the cloud for you

Each agent is a full Claude Code or Codex instance in its own isolated sandbox, with a shell, a persistent workspace, and git.

Talk to it from chat or drive it over the API. Close your laptop mid-task: the sandbox sleeps, wakes on your next message, and the work it packages as apps keeps running on schedules and webhooks.

Open ChatRead the docs
Sandbox management

A sandbox that sleeps, wakes, and never loses its place

The container stops when the thread goes idle and resumes on your next message with the same conversation, the same files, and the same signed-in agent. Your work stays put between sessions, so you can pick up exactly where you left off.

Persistent workspace

/workspace is a real volume shared across a project's threads. Repos, files, and data survive sleep, wake, and restarts.

Git, done right

Install the GitHub App and agents clone and push with short-lived tokens scoped to a single repo. No durable secret ever enters the sandbox.

Your own subscription

Connect Claude or ChatGPT once per thread. The agent runs on your plan, with the real model catalog your account offers.

Guardrails included

Every model call leaves through the Outgate gateway, so PII detection, routing, and observability apply to agent traffic too.

Apps

Conversations end. Apps keep going.

Describe a recurring job and the agent packages it as an app: a manifest, triggers, and a published page on its own URL. From then on the platform wakes the agent on schedule, so nobody needs to keep the tab open.

cron
Scheduled runs
5-field UTC schedules. The sandbox is woken, the agent does the job, the page updates, the run is reported.
webhook
Fire from anywhere
Fire-only tokened endpoints. GitHub pushes, Zapier, or a plain curl: a POST starts a run.
ingest
Data without a run
Ingest-mode webhooks append events straight into workspace data files, and the agent processes them in batches on its next run.
schema
Contracts at the edge
Agents declare a JSON Schema per webhook; non-matching payloads are rejected before they ever reach the app.
Agents API

Everything chat does, your code can do

Chat is customer #0. It runs on the same public REST API you get. Create agents, stream their output, and wire webhooks from your own product.

  • Async creation: get a thread instantly, watch it go live over events.
  • Region-direct long-poll for sub-second output streaming, with no websockets to babysit.
  • Signed org webhooks for turn completions, errors, and permission requests.
  • Scoped gw_ API keys with read/write separation and one consistent error envelope.
/threads/events/webhooks/files/git/workspaces/apps/models
Explore the API reference →

Put an agent to work today

Start a conversation in chat, or create your first agent over the API in a couple of curl calls. The harness handles the sandbox, the lifecycle, and everything the agent leaves running.

Open ChatRead the docs

Frequently asked questions

A full agentic CLI, either Claude Code or Codex, in an isolated container with a shell, a persistent /workspace volume, git, and model access routed through the Outgate gateway. It is the same tooling the agent would have on a developer machine.
After an idle period the container stops; the conversation, workspace, and provider sign-in are preserved. Your next message wakes it in seconds and the thread continues where it left off, so you can come back days or weeks later.
Install the Outgate GitHub App on the repos you choose. When a thread touches one, a short-lived token scoped to that repo is minted on demand and handed to git inside the sandbox. The agent never sees a durable credential, and revoking is one click.
No. Apps are woken by the platform: cron schedules and webhook fires start runs (or ingest data) whether or not anyone is online. Runs are visible in the thread afterwards, and failing apps pause themselves after three consecutive failures.
Yes. The public Agents API covers the full surface: create and drive threads, stream events, manage workspaces, files, git, and apps. Chat itself is built on exactly these endpoints.