Epho Review (2026): Pricing, Features & Honest Verdict

Epho is a cloud API that runs Claude Code, Codex or OpenCode against your repositories. You POST a prompt, it boots a sandbox with the harness already installed, and streams the work back. Best for developers wiring coding agents into CI, bots or scripts. Price: from $0.059 per vCPU-hour, no free plan but $10 of signup credit. Rating: 7.5/10.

What is Epho?

Epho turns a coding agent into an HTTP endpoint. You send one POST request with a prompt, a harness name and your own model API key. Epho boots a Linux sandbox in the cloud, installs the harness, clones your repositories into it, stages any files you attached, wires up your MCP servers, and streams every token and tool call back over server-sent events. There is one endpoint. That is the whole integration surface.

It launched on Product Hunt on 21 August 2026 and ranked fifth for the day. The footer credits Bruin Data Limited, the company behind Bruin, and the contact address is an @getbruin.com one. That matters for two reasons: Epho is not a weekend project by an anonymous account, and it is also not the team’s only product. Two makers are credited on the launch, Burak Karakan and Sabri Karagonen. The site itself names nobody, which is a small gap for a service you hand repository tokens to.

What are Epho’s key features?

One endpoint, three harnesses

You pick your agent with a single field. Set harness to “claude”, “codex” or “opencode” and the request shape stays identical. Swapping from Claude Code to Codex is a one-word diff. Epho makes a point of this on the homepage, and it is the right call: most teams want to benchmark harnesses against the same task, and every other route to that involves maintaining three separate setups. There is no SDK, which the FAQ answers with a shrug: it is a single POST, so paste the curl into an LLM if you want typed helpers.

Chats that outlive the machine

A chat is a durable conversation with a sandbox attached. The box stops when a turn ends and resumes for the next one with the same filesystem, the same checkout and the same agent session. Hand back the chat_id and keep going. If the underlying box is gone, Epho boots a replacement and restores the session snapshot. This is the part you would otherwise build yourself, badly, and it is the clearest argument for paying Epho instead of renting a raw sandbox.

Your keys, your provider bill

Your model key rides along on each request. Tokens land on your Anthropic or OpenAI bill at your provider’s price, with no markup and nobody in the middle. The key is used for that run and nothing else, and you resend it on every turn. There is also a keyless path: OpenCode Zen models ending in -free run without any provider credential, so an Epho key and a curl is the entire setup for a first test.

Everything the agent needs on one request

Context is where agent APIs usually get thin. Epho takes up to 32 repositories per turn, each with an optional branch and its own token, and GitHub, GitLab and Bitbucket tokens are all handled. It takes up to 20 input files as base64 or a URL, drops them in /tmp/inputs and appends their paths to the prompt. MCP servers can be a local stdio process or a remote URL, set once when the chat is created and inherited by every later turn. Artifacts come back on the done event as presigned URLs, good for about ten minutes and re-mintable.

How much does Epho cost?

Epho meters sandbox time from boot to teardown, billed by the second. CPU is $0.059 per vCPU-hour, memory is $0.019 per GiB-hour, and disk is $0.00013 per GiB-hour. The default instance is 2 vCPU, 2 GiB and 10 GiB, which works out at roughly $0.158 an hour, or about $0.0026 for a one-minute run. New accounts start with $10 of credit. Model tokens are never billed by Epho.

There is no monthly plan, no seat price and no free tier. When your balance hits zero, turns are refused with a 402 and you top up. You can read the meter any time with a GET to /credits, and every run reports its own cost_usd on the final event, which is the single most useful thing a usage-priced product can do.

Do Epho’s published numbers actually reconcile?

We checked, because plenty of vendors publish a per-second rate and a per-hour rate that disagree. Epho’s do not. The site lists $0.0000164 per vCPU per second, and multiplied by 3,600 that is $0.05904, matching the stated $0.059 per vCPU-hour. Memory at $0.0000053 per GiB per second gives $0.01908, matching $0.019. Disk at $0.000000036 per GiB per second gives $0.0001296, matching $0.00013.

The default instance claim holds too. Two vCPU plus two GiB plus ten GiB of disk comes to $0.00004376 per second against a published $0.0000438. And the signup credit: $10 divided by that per-second rate is about 63 hours, against a claim of “roughly 60 hours”. Every figure on the page is either exact or rounded conservatively in the buyer’s favour. That is rarer than it should be, and it earns most of this review’s score.

How does Epho’s rate compare to a raw sandbox?

Epho invites the comparison itself with a table arguing that a sandbox hands you a box while Epho hands you a running agent. Fair. But the box still has a market price, and Epho is above it.

E2B charges $0.000014 per second for a single vCPU, which is $0.0504 per vCPU-hour, and $0.0000045 per GiB per second, which is $0.0162 per GiB-hour. Daytona, one of the backends Epho itself integrates with, publishes exactly the same two numbers: $0.0504 per vCPU-hour and $0.0162 per GiB-hour, with storage at $0.000108 per GiB-hour after the first 5 GiB free. So Epho’s $0.059 and $0.019 are about 17 percent above the going rate on both meters, and its disk rate is 20 percent above Daytona’s with no free allowance.

In absolute terms this is small. The default box costs about $0.158 an hour on Epho against roughly $0.133 on either rival, a difference of two and a half cents an hour. You would burn more than that in your own time installing a harness once. The gap that matters more is the welcome credit: Epho gives $10, E2B gives $100 with no card required, and Daytona gives $200 in free compute. Epho’s $10 buys about 63 hours of the default box, which is enough to evaluate properly, but it is the smallest opening allowance in the category by a wide margin.

Why does Epho publish no terms or privacy policy?

This is the real problem. We requested /terms, /privacy, /legal and /security on epho.io and all four returned 404. The footer links only to docs and a contact email. There is no data processing agreement, no retention statement, no security page and no SOC 2 claim of any kind.

Now look at what the API accepts: your model provider key, up to 32 git tokens, arbitrary environment variables that the docs themselves illustrate with a DATABASE_URL, and MCP server headers. The FAQ says your key “is used for that run and nothing else” and that the sandbox stops the moment the turn ends. We have no reason to doubt it. But that sentence is the entire published commitment, and a sentence in an FAQ is not a policy. Any team with a procurement process will stop here, and they should. The parent company publishes a privacy policy at getbruin.com; Epho does not point to it.

One more limit to know before you build on it: teams start with five active turns. Anything past the cap queues, emits a queued status and costs nothing until a slot opens, which is the correct way to handle a cap. But the site never says how you raise it, or whether raising it is a purchase or a conversation. If you are planning to fan out twenty agents, ask first.

Who is Epho best for?

Use Epho if you are wiring a coding agent into something that is not a terminal. A GitHub Action that turns labelled issues into pull requests, a Slack bot with one chat per thread, a review service that streams a diff read into a side panel. The async endpoint with a webhook makes all of those about fifty lines of code, and the per-second billing means an idle integration costs nothing.

Use it if you want to compare Claude Code against Codex against OpenCode on identical prompts without maintaining three environments.

Skip Epho if you need full machine control, since a raw sandbox is cheaper and less opinionated. Skip it if your security review requires a DPA, a retention policy or a compliance report, because none exist yet. And skip it if your workload is one long-running box rather than many short bursts, because the 17 percent premium compounds when the meter never stops.

Best Epho alternatives

E2B is the closest raw-sandbox comparison. It charges $0.0504 per vCPU-hour and $0.0162 per GiB-hour, has a free Hobby tier with a one-time $100 of usage credit and no card required, and a Pro plan at $150 a month. You install and babysit the harness yourself.

Daytona publishes identical compute rates to E2B, gives $200 in free compute, bills per second, and offers startups up to $50,000 in credits. Epho runs on it as one of its backends, so choosing Daytona directly means paying the underlying rate and building the agent layer yourself.

Modal is cheaper still on raw compute at $0.0000131 per core per second, about $0.047 per core-hour, with memory at roughly $0.008 per GiB-hour and 1 TiB a month of free storage. It is a general serverless platform rather than an agent host, so you are further from a working agent on day one.

Final verdict: is Epho worth it?

Epho is the most honestly priced product we have looked at in weeks. Every published number reconciles against every other published number, the per-second rate matches the per-hour rate, the signup credit buys what the site says it buys, and each run tells you what it cost. It charges no markup on model tokens and says so plainly. The durable-chat design, where the conversation survives the machine it ran on, is the feature that justifies paying above raw sandbox rates.

The 17 percent premium over E2B and Daytona is defensible, because you are buying a preinstalled harness, session persistence and a fallback when a box dies. What is not defensible is shipping an API that ingests git tokens and database URLs with no terms of service, no privacy policy and no security page at all. Fix that and this is an easy recommendation for any team. As it stands, use it for side projects, internal tooling and evaluation, and hold off on pointing it at a production repository until the legal pages exist.