An agent-native cloud, at home

Your agent ships.
You approve.

redone is one MCP server in front of a small home cloud. Tell your agent what to build. It plans the deploy, you sign off, and the app is live on a microVM of its own.

Connect your agent See the flow

claude · ~/dev/guestbook

put the guestbook up

Uploading the source…   ✓ 14 files
● redone · plan_deploy  guestbook
  Create guestbook at https://guestbook.run.inevitable.fyi
    port: 8080 · health: /health
    files: 14 added, 0 changed, 0 removed
  ◐ waiting for you: redone.arugula.io/approve/plan_8Yo…

                  … you tap Approve …

● redone · apply_plan   ✓ applied
● redone · app_status   building → deploying → serving

It's live: https://guestbook.run.inevitable.fyi

Four steps. One of them is yours.

Your agent does the work and you make the one decision that counts. Nothing reaches the cloud until you've seen exactly what will change.

Upload

The agent sends the app's source, a directory with a Dockerfile, straight to redone. The source never passes through its context window.

Plan

redone compares it with what's live: settings changed, files added, changed and removed, and any secrets that still need a value.

You

Approve

You open the link, read the plan, and approve it with your approver key, which is not your agent's token.

Apply

The agent ships it. The image builds, a microVM boots, and the agent watches status and logs until it's serving.

Built for an agent at the controls.

An agent with a cloud account will eventually do something you didn't mean. redone is built so the worst case is a plan you reject.

It can't approve its own plans.Approving takes a key that only you hold. The agent's token can plan and apply, and that's all.
Plans go stale on purpose.If anything ships to the app after a plan was made, that plan is refused. Plans you don't act on expire after an hour.
Secrets are write-only.Your agent can set a secret, and nobody can read it back through redone, including the agent.
Your apps are yours.Each person's apps belong to them alone. Nobody else's agent can plan, read or touch them.
Every ship is a commit.Each deploy is recorded in git, with who shipped it, so you can always roll back.

What your app gets

Anything with a Dockerfile that serves HTTP.

Its own microVM

Each app is a Firecracker VM, isolated from every other app and from the cluster.

Sleeps when idle

After five quiet minutes it snapshots to disk, and the next request wakes it.

A real URL, with TLS

https://<app>.run.inevitable.fyi, as soon as it's serving.

Logs your agent can read

Stdout and stderr from the last hour. Reading them never wakes a sleeping app.

Rollback

Ship any earlier deploy again. It goes through a plan and your approval, like any other change.

A way to graduate

When an app earns it, promote opens a pull request to move it into the cluster, where it stays awake.

Connect your agent

redone is invite-only. Ask Jake for a token for your agent and an approver key for you. Then add it to any MCP client:

# Claude Code
claude mcp add --transport http redone \
  https://redone.arugula.io/mcp \
  --header "Authorization: Bearer $REDONE_TOKEN"

Codex, Cursor and other clients take the same URL and header. Then just ask: “put this up on redone.” The server tells the agent everything else.

plan_deployapply_planapp_statusapp_logsset_secretplan_rollbackpromote

The honest part

This isn't AWS. It's three machines in Jake's house, run for him and his friends.

No database on microVMs yetApps there have no volume and no Postgres. A stateful app has to be promoted to the cluster.

No SLAIt's one home internet connection and a few servers. It's usually up and fast, but not always.

Friends onlyEvery account is someone Jake knows. There's no sign-up and no billing.

Your agent ships.You approve.