epho
Run Claude Code, Codex or Opencode in cloud with your repo
Epho runs Claude Code, Codex, or Opencode in the cloud against your own repo. It is API-first rather than a desktop app: you POST a message and stream the work back, while Epho manages the underlying serverless sandboxes, fallbacks, event streaming, and agent configuration — no SDK and no daemon on your side. You bring your own model API keys, so what you pay Epho for is the machine, metered per second rather than per seat; free models are available through Opencode without a key. For developers whose CLI coding agents are limited by a laptop that sleeps, or who want to launch agent sessions programmatically.
What is epho?
Epho turns CLI coding agents into an HTTP API. You POST a prompt, and Claude Code, Codex, or OpenCode runs against your repo in an isolated cloud sandbox that Epho boots, manages, and tears down — results stream back as server-sent events or land asynchronously via webhook, with no SDK, daemon, or infrastructure on your side. Billing is two-layer: Epho meters the machine per second, while model tokens ride on your own provider key at your provider's price.
Key features
- Agents as an HTTP endpoint: POST /v1/chat streams the turn as text/event-stream, POST /v1/chat/async returns a chat id immediately and delivers results by webhook; an event-replay endpoint lets you reconnect after a dropped stream.
- Three interchangeable harnesses — Claude Code, Codex, and OpenCode — swapped by changing a single field, with the request structure otherwise unchanged.
- Repositories are cloned into the sandbox before the agent starts; up to 32 repos per request, including private ones, each with its own per-repo authentication token.
- Sandbox state persists across turns: the same filesystem and agent session carry over, and session snapshots restore the environment if a replacement sandbox has to boot.
- Run configuration is set once and inherited by every turn — harness, model, effort, system prompt, instance size, MCP servers, and environment variables — and provider keys or repos can be swapped mid-conversation.
- Connects local or remote MCP servers, and accepts up to 20 input files per request supplied as base64 or by URL.
- Per-second metering that runs only from sandbox boot to teardown, so nothing idles or is stored; balance is readable via GET /credits and requests are rejected with HTTP 402 once it hits zero.
- No client-side infrastructure: any HTTP client works, which makes it usable straight from bash, cron, or GitHub Actions.
Who it's for
- Running Claude Code or Codex against a repo from CI or a cron job, when the blocker is not having a machine that stays awake.
- Embedding a coding agent inside your own product or internal tool, where you want an API call rather than a subprocess to supervise.
- Running several agent conversations in parallel, each in its own isolated environment with its own repo set.
- Comparing the same prompt across Claude Code, Codex, and OpenCode by changing one field in the request.
- Long multi-turn work on one codebase where the sandbox filesystem needs to survive between turns.
When not to use it
It is an API, not an interactive terminal or IDE, and concurrency is capped: one live turn per chat and up to 5 concurrent active turns per team, with everything beyond that queued — so heavy parallel fan-out or a sit-and-watch workflow will hit a wall.
FAQ
How does Epho bill, and does it mark up model tokens?
Billing is two separate layers. Epho charges only for infrastructure, metered per second: $0.0000164 per vCPU-second, $0.0000053 per GiB-second of memory, and $0.000000036 per GiB-second of disk. The default 2 vCPU / 2 GiB / 10 GiB instance works out to about $0.0000438 per second, or roughly $0.0026 for a one-minute run. Model tokens are never billed by Epho — they ride on the provider_api_key you supply, at your own provider's price. New accounts get $10 in credit on signup, which the site describes as roughly 60 hours of the default instance. The meter runs only from sandbox boot to teardown.
Do I have to install an SDK or run a daemon?
No. Epho describes itself as agents-as-an-API: you talk HTTP and the agent talks to your repo, with no SDK, no daemon, and no infrastructure on your side. Any HTTP client works, so it can be driven from a bash script, a cron job, or a CI pipeline such as GitHub Actions.
What happens to my code and session state between turns?
Each chat gets its own isolated environment, and the sandbox persists across turns with the same filesystem and the same agent session; if a replacement sandbox has to boot, a session snapshot restores it. Compute is metered only while the sandbox is up — the docs describe the sandbox being stopped after a turn settles so billing ends, and the pricing section states that nothing idles or is stored.
Which agents, repos, and tools are supported?
The runtime supports three harnesses — claude, codex, and opencode — selected per request. You can attach up to 32 repositories per request with per-repo authentication tokens, up to 20 input files as base64 or URLs, and local or remote MCP servers. Provider credentials are supplied per run as your own OpenAI, Anthropic, or OpenCode Zen key, alongside a team-scoped Epho API key.
Share this launch
Embed this badge
<a href="https://orangebot.ai/product/epho" target="_blank" rel="noopener noreferrer"> <img src="https://orangebot.ai/api/badge/epho.svg" alt="Featured on OrangeBot" width="200" height="54" /> </a>