Remote agent control · early access
roam runs autonomous agents on your own servers over SSH — detached, budgeted, sandboxed. The moment one reaches for something destructive, it stops and asks. Approve or deny from your phone. No Docker, no runtime, no per-seat subscription.
How it works
roam send --to prod-01 --goal "…" ships the binary to the box and runs the
agent detached. One static binary — no Python, no Node, no Docker on the server.
Hit rm -rf, git push --force, DROP TABLE, shutdown…
and the agent freezes and asks. Budgets and a workdir sandbox bound the rest.
Approve, deny (the agent adapts), or stop. See every agent across every box — live status, token cost, the full journal — in one self-hosted panel.
Use cases
Schedule an agent every night: clone the repo, run the full test suite, summarize
failures, and post a report to Slack. If a test fix is obvious, the agent opens a PR
and parks on git push for your morning approval.
Dispatch an agent to check disk usage, identify old logs and rotated archives, and
clean them up. The confirm gate parks rm commands so you see exactly what
will be deleted before it happens. Run it on a schedule across every server.
--confirm · Safe: destructive commands parkedAn alert fires (PagerDuty webhook). The agent SSHes into the box, pulls recent logs, checks service status, correlates timestamps, and posts a diagnostic summary to the on-call channel. You get context before you even open your laptop.
"Replace all deprecated foo() calls with bar() across the
codebase." The agent reads every file, makes the changes, runs the tests, and opens
a PR. You review the diff and approve the push — the agent never touches prod
without you.
--confirm on git pushSet "selector":"gpu=true" on the agent spec. Start workers on your GPU
boxes with --label gpu=true. The hub only sends those runs to GPU
workers. CPU-only tasks go to CPU boxes. One tenant, one wallet, routed
automatically.
Run 10 workers across 10 servers with the same token. Each pulls a different run from the queue. Patch configs, rotate certs, restart services, run health checks — all in parallel, all journaled, all billed through one peage wallet. Scale workers up and down without touching the hub.
Why roam
Proven end-to-end
A roam agent was dispatched with the goal "add a unit test to the machin repo
and open a PR." It cloned the repo, wrote a passing Go test, parked on
git push for out-of-band approval, and filed a PR that was reviewed and
merged.
A debri agent was dispatched locally with --confirm. It parked in the
panel for approval. The operator clicked Approve from the web UI. The agent
started a Devin session, created /tmp/roam-test.txt, and finished.
Self-host or hosted
Self-host the approval panel — it's the same binary, MIT licensed, zero config. Or use the hosted hub: agents phone home, you approve from anywhere, and you only pay for runs that actually execute. No monthly seat, no vendor lock-in.
Cost calculator
Pay per run. No monthly fee. Self-host the CLI free.
FAQ
roam is one static binary. You run roam send --to prod-01 --goal "..." and it
copies itself to the target, starts a detached worker, and runs an LLM-backed agent loop.
The agent calls tools (shell, file I/O, finish), journals every step, and parks destructive
commands for your approval if --confirm is set. You watch with
roam attach and control with roam approve / roam stop.
Yes. Start roam worker --hub <url> --token <rhw_...> on as many
machines as you want. They share one worker token and pull from the same queue. Each worker
gets a different run — the hub's atomic claim guard prevents double-claiming. This is
horizontal scaling: more workers = more parallel runs, all billed through the same peage
wallet.
Yes. Set a selector on the agent spec (e.g., "selector":"gpu=true")
and start the worker with matching labels: roam worker --label gpu=true --name gpu-box-01.
The hub only hands a run to a worker whose labels satisfy the agent's selector. Empty selector
= any worker. This lets you keep GPU agents on GPU boxes, Docker agents on Docker hosts, etc.,
all within a single tenant.
Per run, no monthly fee. The hub proxies every LLM call through its own key (workers hold
no model keys), meters exact tokens from the upstream response, and charges your peage wallet:
€0.01 flat + token_cost × 1.3. A typical coding task costs
€0.02–€0.10. You top up your wallet with a card via Stripe. Self-hosting is
free — bring your own API key.
The hub reclaims it. If a run has no worker activity for 15 minutes, it goes back to the queue for another worker to pick up. After one reclaim attempt, the run is declared lost and billed only for what it actually metered. Your webhook (if set) hears about the loss — never silence.
Yes — that's the primary mode. The CLI is MIT-licensed and the panel is self-hostable with roam-panel. Bring your own Anthropic/OpenAI key, run workers on your own machines, approve from the panel or your terminal. The hosted hub is for when you don't want to manage keys, billing, and worker coordination yourself.
Anthropic (Claude), OpenAI-compatible (GPT, DeepSeek, Llama, etc. via OpenRouter), and
debri/Devin delegation. Self-hosted: set ANTHROPIC_API_KEY or
ROAM_API_KEY on the target. Hosted: the hub proxies through OpenRouter with
its own key — you pick the model per agent.
roam is one binary, no Docker, no daemon, no agent installed on the target. It copies itself over SSH and runs. The confirm gate parks destructive commands for human approval — you see exactly what the agent wants to do before it does it. The hosted hub bills per run (€0.02–€0.10) instead of per seat ($99/mo). And it's MIT-licensed — self-host free, hosted when you want convenience.
Early access
The roam CLI is free and open source today. Join the waitlist for the hosted panel — approve from anywhere, fleet view, per-run billing. No monthly subscription.
✓ You're on the list — we'll be in touch.
Self-host free (MIT, bring your own key) · Hosted: €0.01 + token cost × 1.3 per run · No monthly fee