Cloud agents for Claude Code, Codex & OpenCode
Not a black box. A devbox.
Local oversight. Cloud superpowers. Autonomous coding agents that run in a cloud devbox you can watch, steer, and verify. On your own subscription. From GitHub, Slack, Linear, your terminal, or the API.
Bring your own subscription. Your agent, your keys.
Demo: a failing test is reproduced, fixed by the agent, tests pass, and a reviewed pull request opens.
tasks start in ~5s · 0 credits while idle · per-second metering
Everything in the box.
A review agent reads every diff the moment it lands and leaves real comments in GitHub. Push a fix and it reviews again, until it approves. Answer its comments and it answers back.
Give a prompt a schedule: hourly, nightly, or every Monday at 9. Triage the backlog while you sleep, chase flaky tests every morning, and wake up to PRs instead of a to-do list.
Mention Aether in the thread where the bug was reported and a devbox spins up on the spot. Progress posts back to the same thread; reply to steer it, or say stop to pull the plug.
Assign an issue to Aether like a teammate. The ticket moves to In Progress while it works, the PR links back automatically, and the agent's session notes land in the issue.
A new production error becomes a fix task before you finish reading the alert: stack trace, breadcrumbs, and offending line included. The fix arrives as a PR with the receipts.
When a run needs your call, the question lands in your inbox. Answer the email and the agent picks up exactly where it stopped. Unblock overnight work without opening a laptop.
brew install, then aether run streams a cloud task into your prompt. Tasks, files, git, secrets, and billing are all commands, and the whole devbox is one aether ws ssh away.
Everything on this page is scriptable: a REST API with platform keys for projects, tasks, and automations, plus a WebSocket feed of the live workspace, terminal to git.
Commit a SKILL.md and every agent that touches the repo follows it: your test conventions, your review bar, your deploy rules. Personal skills follow you across projects.
Every port the agent opens gets its own URL. Click into the running app and test it like localhost, hot reload included, or hand the link to a teammate. Private by default.
The agent has a real browser on a real display. It clicks through what it built, records the session, and embeds the MP4 and before/after screenshots in the PR description.
Claude Code, Codex, or OpenCode, on your own subscription, with 40+ models behind them. Pick the model and reasoning effort per task; hot-swap mid-session when you need more.
Turn on what you want. It all composes.
Start tasks where you already work.
brew install the CLI and aether run streams a cloud task into your prompt. Mention Aether in Slack, assign it a Linear issue, or hit the API with a platform key: every surface reaches the same loop.
Oversight
A loop you can watch and take over.
The whole devbox is open while the loop runs: terminal, file editor, port previews, Docker. Watch every command live. Jump in mid-run, type in the same terminal, steer, or take the wheel entirely. Autonomy that never asks for blind trust.
- Plan mode: the agent proposes, you approve, then it executes
- Queue follow-ups mid-run and the agent folds them in without restarting
- Stop the agent anytime and the devbox stays alive, yours to use
Demo: while an agent streams commands in the devbox terminal, a human clicks in and types a command; the agent pauses, a chip flips to "you're driving," then control hands back.
AI that never ships its first draft.
Shipped by an agent. Reviewed by an agent. Approved by you.
Turn on Aether review and every PR the agent opens runs a gauntlet before it reaches you: a review agent tears the diff apart in GitHub, the author fixes and pushes, and the review runs again until the code holds up. What lands in your repo has already survived review, with a video to prove it works.
The review agent re-checks every push until it approves.
Demo: Aether opens a pull request, its review agent finds a double-charge bug and requests changes, the author agent pushes a fix, the review approves, and the pull request resolves with passing checks and a demo video.
Seeing is shipping.
Every PR arrives with the receipts: a Playwright video of the change actually running, screenshots, green checks, and the full review thread. You review evidence, not promises.
Idempotency guard verified against the duplicate-delivery test. Approving. ✓
The loop starts everywhere.
Anything that means "something needs doing" can kick it off.
Triggers: CI fails, Sentry alert, Linear ticket, On a schedule, PR comment, Merge conflict. Each can start the loop.
Your subscription, multiplied.
You already pay for Claude Code, Codex, or OpenCode. On your laptop that buys one agent, one task, your attention, your battery. Point the same subscription at Aether and it becomes a fleet: parallel isolated devboxes, each ready in seconds, running while you sleep, wired into GitHub, Slack, Linear, and Sentry. The model is yours. We're everything around it.
Local gives you control. The cloud gave it away. Aether gives you both.
Local agents see everything but can't scale. Black-box agents scale but lock you out, and lock you into a model you didn't pick.
- Runs in the cloud, isolated
- Run a fleet in parallel
- Instant start, no env setup
- Lives in your workflow (Slack, Linear, GitHub, Sentry)
- Fixes CI, conflicts & PR comments on its own
- Automated review on every PR
- Video proof it works, on every PR
- Your own agent + subscription(rented, often weaker)
- Full terminal, editor & port access
- Run a fleet in parallel
- Instant start, no env setup(cold starts)
- Lives in your workflow (Slack, Linear, GitHub, Sentry)
- Fixes CI, conflicts & PR comments on its own
- Automated review on every PR
- Video proof it works, on every PR
- Watch it work & jump in anytime
One column checks every box. That's the whole point.
Don't pay for intelligence twice.
Black-box agents rent you a model at a markup and hide it inside an opaque meter. Aether charges only for compute: the intelligence runs on the subscription you already own.
- VM timebundled
- model inferencebundled, marked up
- networkingbundled
- computemetered, visible
- model inference$0 to us (your own subscription)
- idle time0 credits
Comparison uses list pricing for the leading black-box agent as of July 4, 2026.
- Small: 8 shared vCPU, 2 GB
- Medium: 8 shared vCPU, 4 GB
- Small: 8 shared vCPU, 2 GB
- Medium: 8 shared vCPU, 4 GB
- Large: 2 performance vCPUs, 8 GB
- XL: 4 performance vCPUs, 16 GB
- Small: 8 shared vCPU, 2 GB
- Medium: 8 shared vCPU, 4 GB
- Large: 2 performance vCPUs, 8 GB
- XL: 4 performance vCPUs, 16 GB
- Small: 8 shared vCPU, 2 GB
- Medium: 8 shared vCPU, 4 GB
- Large: 2 performance vCPUs, 8 GB
- XL: 4 performance vCPUs, 16 GB
1 credit = 6 minutes on a Medium devbox. Small = 0.5×, Large = 2×, XL = 4×. Idle and suspended devboxes bill nothing.
Credit packs: 100 for $10, 250 for $25, 500 for $50, 1,000 for $100. Packs expire 12 months after purchase.
Every size runs Docker.
Cancel anytime via the billing portal.
Under the hood
FAQ
Encrypted at rest with AES-256-GCM under a key derived per user, and injected into your isolated VM only for the duration of a session. They're never written to logs, and you can revoke them at any time.
Connect a repo. Bring your agent. Go.
First PR in minutes.
Stop firing agents into the void.
Run your first agent in a devbox you can actually see. Free.
Bring your own subscription. Your agent, your keys.