agents as
an api.

epho spins up claude code, codex, or opencode in the cloud. you POST a message, the work streams back. no sdk, no daemon, no infra on your side.

get an api key read the api

POST /v1/chat
{
  "harness": "codex",
  "message": "Write a haiku about the ocean.",
  "provider_api_key": "sk-proj-••••••••"
}

$ epho explain --how-it-works

you talk http.
the agent talks to your repo.

one request boots a fresh cloud environment with the harness you picked, hands it your message, and pipes everything back to you as it happens.

┌───────┐
│  you  │
└───────┘

your script

POST /v1/chat

┌────────┐
│  epho  │
└────────┘

boots & routes

runs

┌─────────────┐
│ claude code │
├─────────────┤
│    codex    │
├─────────────┤
│  opencode   │
└─────────────┘

in a cloud box

text/event-stream — tokens, tool calls, diffs

post a message

one endpoint, one json body. pick a harness, write a message, pass your provider_api_key.

we boot the agent

epho spins up a fresh cloud environment with your harness installed and drops the message in.

watch it work

the response streams back over sse — tool calls, edits, the final answer. like stdout over http.

$ epho features --why

small surface.
serious mileage.

the whole product is one endpoint and good defaults. everything below falls out of that.

POST /v1/chat 200 text/event-stream

one endpoint

that's the api. if you can write json, you've finished the docs.

claude code codex opencode

pick your fighter

swap harnesses with one field. same request shape, different brain.

"provider_api_key": "sk-…"

byo keys

your provider key goes with the request. your tokens, your provider bill — epho never sits between you and the model.

data: {"type":"delta",…} data: {"type":"done",…}

streams like a terminal

pass -N and watch. server-sent events from first byte to done.

⠿ agent running… lid closed

cloud, not your macbook

agents run on our boxes. close your lid, board your flight — it keeps typing.

ci cron bash

scripts & ci friendly

it's just http. pipe it into github actions, cron, a discord bot, five lines of bash.

$ epho compare raw-sandbox

a sandbox hands you a box.
epho hands you an agent.

you can absolutely run claude code yourself on a raw sandbox — e2b, daytona, a vm you rent. people do. here's what you sign up for.

raw sandbox

epho

what you start with

raw sandboxan empty linux box

ephoa running agent — harness installed, warmed up

setup

raw sandboxinstall the harness, wire auth, babysit the process

ephoone POST. that's the setup

a dead box mid-run

raw sandboxthe run dies with it. you notice, you retry

ephothe run re-queues on a fallback sandbox backend

your provider key

raw sandboxbaked into the box's env

ephorides along per-request, torn down with the run

ten agents at once

raw sandboxyou build the pool, the queue, the retries

ephofire ten requests

need full machine control? use a sandbox. need work done? use epho.

$ epho pricing --per-hour

at cost.
by the second.

you pay what the sandbox underneath costs — epho adds nothing on top while in beta. the meter runs from boot to teardown and stops when the run does. nothing idles, nothing is stored, nothing keeps billing.

cpu

$0.059
per vCPU · per hour

memory

$0.019
per GiB · per hour

disk

$0.00013
per GiB · per hour

default instance: 2 vCPU · 4 GiB · 10 GiB ≈ $0.1953/h · a one-minute run ≈ $0.0033
starting credit: $20 on signup — roughly 100 hours of the default instance
model tokens: never billed by epho. they ride on your provider_api_key, at your provider's price.

$ epho api --spec

this is the entire
integration.

copy it, swap in your key, change the message. you're now running coding agents in the cloud.

$ curl -N https://epho.terzioglub.com/v1/chat \
    -H "Authorization: Bearer sk_live_••••••••" \
    -H "Content-Type: application/json" \
    -d '{
      "harness": "claude-code",
      "message": "Write a haiku about the ocean.",
      "provider_api_key": "sk-ant-••••••••",
      "instance": {"cpu": 2, "memory": 4, "disk": 10}
    }'

# response — text/event-stream
data: {"type":"status","text":"booting claude-code"}
data: {"type":"delta","text":"Silent waves at midnight —"}
data: {"type":"delta","text":"salt on the tide of the moon —"}
data: {"type":"delta","text":"the sea dreams in slow blue."}
data: {"type":"done","elapsed_ms":8120,"cost_usd":0.0003}

harness

"claude-code" | "codex" | "opencode" — which agent boots

message

string — what you want done, in plain words

provider_api_key

string — your key for the model behind the harness

instance

{cpu, memory, disk} — optional. defaults to 2 vCPU / 4 GiB / 10 GiB

$ epho faq

fair questions.

is there an sdk?

you don't need one — it's a single POST. if you really want typed helpers, paste the curl into your favorite llm and ask. it'll manage.

who pays for the model tokens?

you do. the request carries your provider_api_key, so tokens land on your provider bill at your provider's price. no markup, no middleman.

what does a run cost?

sandbox time, at cost — metered from boot to teardown. size the box yourself with the instance key. every run reports its own cost_usd in the final event.

what can an agent actually do?

whatever the harness does on your machine: read repos, write code, run tests, iterate on failures. it just does it in the cloud, on demand, in parallel.

can i run a bunch at once?

sure — fire off as many requests as you want. each one gets its own isolated environment. fan out as wide as your keys allow.

what happens to my key?

it's used for the run and nothing else. each environment is torn down when the agent finishes.

             _
   ___ _ __ | |__   ___
  / _ \ '_ \| '_ \ / _ \
 |  __/ |_) | | | | (_) |
  \___| .__/|_| |_|\___/
      |_|

$ epho keys create

grab a key. keep the curl.

two minutes from now you could be watching an agent work from your terminal.

get an api key read the docs

you talk http.the agent talks to your repo.