Aether

Aether runs autonomous AI coding agents inside cloud development environments you can actually watch. The problem it goes after is trust. A lot of AI coding services are black boxes, so you hand off a task, wait, and hope the result is right, often while paying a markup on the model doing the work. Aether flips that by putting the whole workspace on screen. You see the terminal, the file changes, and a live preview, and you can step in mid-run instead of waiting to be surprised by a pull request at the end.

The core unit is a devbox, an isolated Firecracker microVM where a single task runs and then gets destroyed when it's done. Instead of bundling its own model at a marked-up rate, Aether lets you bring your own subscription to Claude Code, Codex, or OpenCode, with access to a wide range of models through OpenCode. Each task gets its own clean machine, so runs stay separated and reproducible, and there's nothing left lying around afterward. While an agent works you watch live terminal output, file diffs, and port previews, and you can steer it, pause it, or take full control at any point.

In practice teams point it at the kind of work that eats engineering time. It can fix failing tests, review pull requests, triage backlog items, and respond to production errors. Pull request review runs as an iterative feedback loop, and a multi-agent review pass can vet the code before it ships, so a second set of eyes checks the first agent's work rather than trusting it outright. When a change is visual, Aether can attach video proof of what actually happened in the browser, so a reviewer isn't left guessing whether the screenshot matches the diff. The point throughout is oversight, so the agent stays accountable rather than opaque, and the person merging can see the reasoning instead of a summary someone hopes is accurate. That observability is really the core of the pitch. Where a black-box service asks you to trust the output, Aether shows the terminal, the file diffs, and the running app as the work happens, and it does that inside a machine that gets thrown away when the task ends. Because each run lives in its own short-lived microVM, a mistake stays contained to that box, and nothing an agent does bleeds into the next task or lingers on shared infrastructure. For teams that have hesitated to let an agent touch a real repo, that combination of visibility and isolation is meant to make the whole thing feel safe enough to actually use.

It's built to fit into a real workflow rather than live in a separate tab. Runs can be scheduled to fire hourly, nightly, or weekly, which suits recurring chores like dependency bumps or nightly test triage. It connects to Slack for live updates and steering through replies, Linear for issue assignment and status sync, Sentry for auto-fixing when a production error fires, and GitHub for pull request review and push triggers. A skills system lets you encode repo-specific conventions so the agent follows your house style instead of relearning your patterns on every run, and there are CLI, REST, and WebSocket APIs when you want to script it or wire it into something you already run. Because the integrations reach into the tools where issues and errors already live, work can be assigned from Linear or triggered by a Sentry alert without anyone opening a separate console.

The audience is software engineers and development teams who want autonomous coding help but not vendor lock-in or pricing they can't see through. Because you bring your own agent subscription, you keep the model relationship you already have and avoid paying a premium on top of inference. The watch-and-steer design is aimed at people who have been burned by agents that go off the rails unseen, and who would rather keep a hand on the wheel than trust a summary after the fact. If you have wanted to let an agent grind through a backlog overnight but never felt safe doing it blind, this is the gap it tries to close.

Getting started leans on tooling engineers already use. There's a CLI you install and drive with a run command, plus REST and WebSocket APIs for automation and live status. Since devboxes are ephemeral and one-per-task, you can fan out several runs without them stepping on each other, and warm slots keep environments ready so a run starts quickly instead of cold every time.

Access is freemium. A free plan gives you a monthly pool of credits and a single warm slot so you can try the workflow at no cost, and paid plans add more credits and more warm slots as you scale, moving through Starter, Pro, and Max tiers. Credits meter only active runtime, roughly six minutes of a medium devbox per credit, and idle time is free, so you're paying for work done rather than machines sitting around. Combined with bring-your-own model, the pricing is meant to stay legible instead of hiding a markup you can't inspect.