Epho

Product Introduction

1. Definition: Epho is a cloud-based API platform for AI-powered coding agents. It is a serverless orchestration layer that abstracts the underlying infrastructure required to run agents like Claude Code, Codex, and OpenCode in secure, ephemeral sandboxes.
2. Core Value Proposition: Epho exists to eliminate the operational complexity of running AI coding agents. It provides a single, unified API endpoint to launch, manage, and interact with stateful agent sessions, handling sandbox provisioning, context management, tool integration, and event streaming so developers can focus on outcomes, not infrastructure.

Main Features

1. Agents-as-an-API: The core feature is a single HTTP POST endpoint (/api/v1/chat) that accepts a JSON payload and returns a Server-Sent Events (SSE) stream. This endpoint is the entire integration surface, requiring no SDK, daemon, or custom infrastructure. It accepts configuration for the agent harness, model, prompt, repositories, input files, and MCP (Model Context Protocol) servers.
2. Durable Chat Sessions: Epho introduces the concept of a stateful chat_id. A chat represents a persistent conversation with an attached sandbox environment. The sandbox is paused between turns but retains its filesystem, git checkout, and agent session state. Subsequent requests with the same chat_id resume the session, enabling multi-turn collaboration. The session is snapshot-restorable, allowing the conversation to survive the termination of the underlying compute instance.
3. Comprehensive Context Injection: The platform is engineered for high-context agent performance. It automatically clones specified Git repositories (up to 32, including private ones with tokens), stages input files (up to 20 via URL or base64), connects to declared MCP servers (for tools like Linear, Figma, or custom APIs), and injects environment variables and system prompts before the agent begins execution. This creates a fully-contextualized workspace from a cold start.
4. Resilient & Observable Execution: Runs are designed for reliability and observability. The event stream delivers real-time tokens, tool calls, and file diffs. If a connection drops, events are persisted and can be replayed via a dedicated subscription endpoint (/chat/{id}/events/subscribe). The system also handles sandbox failures by automatically re-queuing runs on fallback infrastructure. An asynchronous endpoint (/chat/async) with webhook support enables fire-and-forget execution.

Problems Solved

1. Pain Point: The significant DevOps overhead and fragility of self-hosting AI coding agents. Developers must manually provision and manage sandboxes (e.g., e2b, VMs), install and configure agent harnesses, wire authentication for models and tools, handle retry logic, and ensure secure file transfer—all for a single agent run.
2. Target Audience: Software engineers and development teams seeking to automate coding tasks; DevOps and platform engineers building internal AI tooling; startups and indie hackers integrating AI agents into products without a dedicated infra team; QA engineers automating test generation and fixes.
3. Use Cases: Automated code review by streaming PR diffs to an agent; transforming GitHub issues labeled "agent" into pull requests; building internal tools like a Slack bot that performs code analysis in a thread; batch processing data (e.g., CSV reconciliation) using an agent with specific tool access; running parallel, isolated agent sessions for load testing or experimentation.

Unique Advantages

1. Differentiation vs. Raw Sandboxes: Unlike provisioning a bare Linux sandbox, Epho delivers a pre-warmed, fully-configured agent environment with a single API call. It manages session persistence, automatic fallbacks, and artifact retrieval, whereas with a raw sandbox, context is lost on failure, and file management is manual. Epho abstracts the queue, pool, and retry logic required for running multiple concurrent agents.
2. Key Innovation: The Ephemeral, Stateful Session Model: Epho's core innovation is decoupling the durable agent "session" (memory, context, intent) from the ephemeral sandbox "instance" (compute, memory, disk). This allows the system to tear down expensive resources immediately after a turn ends (saving cost) while maintaining the conversational state for resumption on a fresh, cheap instance. This hybrid model enables both cost-efficiency and persistent collaboration.

Frequently Asked Questions (FAQ)

1. How does Epho handle billing and model costs? Epho uses a granular, per-second billing model for sandbox resources (vCPU, memory, disk). Model token costs are not billed by Epho; the user's own provider_api_key is passed through directly to the model provider (Anthropic, OpenAI, etc.), so users pay their provider's standard rates with no markup.
2. Can Epho agents work on private GitHub or GitLab repositories? Yes. The repos field in the API request accepts a token parameter for each repository URL. This supports private repos from GitHub, GitLab, and Bitbucket. Repository tokens are scoped per-turn and can be rotated or changed in subsequent messages within the same chat.
3. What happens if the AI agent fails or the sandbox crashes during a run? Epho is designed for resilience. If the underlying sandbox crashes mid-run, the system detects the failure, automatically re-queues the turn, and executes it on a healthy fallback sandbox. The agent's session snapshot is restored, minimizing context loss and ensuring task completion.
4. Is there a free tier or way to test Epho without a paid API key? Yes. Epho offers a starting credit upon signup. Furthermore, when using the opencode harness with a Zen model that ends in -free (e.g., opencode/zen-1-free), no provider_api_key is required. This allows testing the full platform workflow using only an Epho API key.
5. How does file transfer work with Epho agents? Files can be sent to the agent via the input_files array (base64 or URL), which are placed in /tmp/inputs. Files generated by the agent are returned as "artifacts" in the final done event of the stream. These artifacts include a pre-signed download URL valid for approximately ten minutes, which can be re-minted via the API if needed.