# epho

> Epho runs Claude Code, Codex, or OpenCode coding agents in the cloud via a single HTTP API — no SDK, no daemon, no infrastructure required on your side.

Epho is a cloud API that turns coding-agent harnesses into a simple HTTP endpoint. Built by Bruin Data Limited, it lets developers POST a prompt and receive streamed agent output — with repos cloned, files staged, and MCP servers wired in — without managing any infrastructure. The service is actively available, with API keys issued on signup and a usage-based credit model.

## What It Is

Epho sits between your code and AI coding agents like Claude Code (Anthropic), Codex (OpenAI), and OpenCode (open-source). Instead of running these agents locally or managing cloud VMs yourself, you send a single JSON request to `POST /api/v1/chat`, and Epho boots a fresh sandbox, clones your repos, connects your tools, and streams the agent's work back as server-sent events. The core abstraction is "agents as an API" — one endpoint, one JSON body, and the agent does the work in the cloud.

## How the Execution Model Works

Every request runs as a **turn** inside a durable **chat**:

- Epho accepts a team-scoped API key and queues the turn
- An isolated sandbox boots (or resumes) with the chosen harness installed
- The agent receives the prompt and your provider API key
- Progress is persisted as events — tool calls, edits, text output
- The final answer and file artifacts are saved and returned
- The sandbox stops immediately, ending compute billing

Chats are durable: pass the same `chat_id` on a follow-up request and the sandbox resumes with the same filesystem, checkout, and agent session. If the underlying box is gone, Epho boots a replacement and restores the session snapshot.

## Context and Configuration

Epho's request body carries everything the agent needs:

- **repos** — up to 32 repositories (GitHub, GitLab, Bitbucket), each with an optional branch and per-repo token
- **input_files** — up to 20 files, inline base64 or fetched from a URL, staged to `/tmp/inputs`
- **mcp_servers** — local stdio processes or remote URLs (Linear, Figma, custom internal servers), set once and inherited by every turn
- **env** — environment variables baked into the sandbox at creation
- **system_prompt** — stacked on top of the harness's own system prompt
- **effort** — `low`, `medium`, `high`, or `xhigh` where the harness supports it

Provider API keys ride along per-request and are torn down with the run — Epho never stores them between turns.

## Streaming and Async Modes

Two endpoints cover the same underlying execution path:

- `POST /api/v1/chat` — opens a streaming SSE connection; tokens, tool calls, diffs, and a final `done` event with artifacts arrive in real time
- `POST /api/v1/chat/async` — returns `202` with `chat_id` and `turn_id` immediately; results are collected via polling or a `webhook_url`

Every event is persisted, so a dropped connection is not a lost run. Reconnecting to `/chat/{id}/events/subscribe` replays missed events before resuming the live tail.

## Harness and Model Support

Epho supports three coding-agent harnesses selectable via the `harness` field:

- **claude** — Anthropic's Claude Code agent; requires an Anthropic provider key
- **codex** — OpenAI's Codex agent; requires an OpenAI provider key
- **opencode** — the open-source agent; OpenCode Zen models ending in `-free` run without any provider credential, making a single Epho key the only requirement

## Why It Matters for CI and Automation

Because the API is plain HTTP with no SDK dependency, Epho integrates directly into GitHub Actions, cron jobs, Discord bots, Slack bots, and bash scripts. The async endpoint and webhook support make it suitable for event-driven workflows — for example, turning a GitHub issue labeled `agent` into a pull request, or streaming a PR review into a side panel. Each chat gets its own isolated environment, so concurrent fan-out is supported; teams start with five active turns, with additional turns queued at no cost until a slot opens.

## Features
- Run Claude Code, Codex, or OpenCode agents via a single HTTP endpoint
- Durable chats with persistent sandboxes across multiple turns
- Clone up to 32 repos per request with per-repo branch and token support
- Attach up to 20 input files (base64 or URL) per turn
- MCP server support (local stdio or remote URL), inherited by every turn
- Server-sent event streaming with full event replay on reconnect
- Async mode with webhook delivery
- Usage-based billing metered per second from boot to teardown
- Free OpenCode Zen models with no provider key required
- Artifacts returned with presigned download URLs on the done event
- Effort levels: low, medium, high, xhigh
- Custom system prompt stacked on harness defaults
- Environment variable injection into sandbox
- GET /credits endpoint for real-time balance monitoring
- Concurrent agent runs with per-chat isolation

## Integrations
Claude Code (Anthropic), Codex (OpenAI), OpenCode, GitHub, GitLab, Bitbucket, MCP servers (Linear, Figma, custom), GitHub Actions, Slack, Discord, Webhooks

## Platforms
LINUX, WEB, API, CLI

## Pricing
Paid

## Links
- Website: https://epho.io
- Documentation: https://epho.io/docs
- Repository: https://github.com/acme/api
- EveryDev.ai: https://www.everydev.ai/tools/epho