Coding agents don't belong on your laptop.
They belong in Orbs.
An Orb is a dedicated remote machine where Amp agents run without supervision. Your repository, plugins, databases, and dependencies live in the cloud—so agents build, test, and migrate code across a parallel fleet while your laptop sits closed in your backpack.
amp -ox "your prompt" --orb-size a1.small
The Laptop Trap: Local Execution
Running autonomous agents directly on your developer machine cripples your day:
- Hardware Exhaustion: 6,000 RPM fan noise, battery drained from 100% to 15% in 40 minutes while Docker, Vite, and tests grind.
- The Closed-Lid Catastrophe: Close your laptop to catch a train or step into a meeting, and the 45-minute migration halts and dies.
- Serial Bottlenecks: Only 1 agent can safely run at a time without thrashing your working directory, git state, and port bindings.
The Amp Paradigm: Isolated Cloud Orbs
Agents work in disposable, dedicated cloud machines that you orchestrate effortlessly:
- True Asynchronous Autonomy: Shut your laptop down. The orb finishes the migration, verifies with tests, and creates the PR remotely.
- Parallel Fleet Scaling: Launch 5 orbs simultaneously. Five separate agents refactor five services in parallel for pennies.
- 5-Minute Auto-Pause ($0/h): Sleep instantly when idle. Wake instantly upon access with 24-hour setup snapshot caching.
Four Ways to Launch an Orb
Trigger remote execution seamlessly from wherever you write software:
1. Web Thread
Click "Create New Thread" at ampcode.com, select a repository, and enter your prompt.
2. Terminal CLI
Run amp -ox "your prompt" or add --orb-size a1.small for explicit hardware sizing.
3. Interactive TUI
Open the command palette in the Amp TUI and choose thread: new in orb.
4. Plugin SDK
Invoke programmatically: agent.createThread({ executor: 'orb' }).
What actually lives inside an Orb?
Creating a new thread gives you a fresh Debian 12 virtual machine containing your code, your plugins, and the tools the agent needs. You retain full hands-on control while the agent executes remotely.
Repository Lifecycle Scripts
Deterministic configuration via repo scripts:
.agents/setup: Runs once while an orb is being prepared. Installs dependencies, generates files, seeds databases, verifies tools. Logs to/home/user/.cache/amp/logs/setup.log..agents/resume: Runs every time an existing orb wakes. Must be fast and idempotent, with a strict 10-second timeout. Logs toresume.log.AGENTS.md: Repository instructions guiding agent decisions.
5-Min Auto-Pause & Snapshots
Economics built around dormant efficiency:
- 5-Minute Auto-Pause: Idle orbs sleep automatically after 5 minutes of inactivity or when thread is archived. Sleeping orbs cost exactly $0.00/min.
- Instant Resume: Any CLI access or portal request wakes the orb immediately.
- 24-Hour Snapshots: After first setup, the sandbox state is snapshotted and reused for subsequent orbs, achieving sub-2-second spinups.
Full Hands-on Control & Sync
You are never locked out of the agent's environment:
- Live In-Orb Terminal: Open an interactive bash terminal inside the remote orb anytime.
- File Browser & PR Approval: Inspect, diff, and approve changes directly from the thread UI without pulling them down.
amp sync <thread-id>: Stream remote orb edits live to your laptop workstation in real-time while the agent keeps working remotely.
Interactive Pre-Installed Environment Explorer
Click any pre-installed package to inspect its role and test simulated CLI execution:
The Remote Fleet Workstation
Don't just read about Orbs—orchestrate a live fleet. Spawn orbs, size them, assign tasks, and watch parallel agents complete a full workday while you sleep.
Active Fleet Cluster (3 / 8 slots)
Click an orb card to inspect or trigger actionsBeat The Laptop: Local Machine vs. 4-Orb Remote Fleet
Run the exact same heavy workload: "TypeScript 5.6 Migration + 3,800 Vitest Suites + Docker Postgres Re-seed". Experience what happens when you shut the laptop lid mid-flight.
Local Developer Laptop (Single Agent)
ReadyAgent locks up local processes. Fans spin up to maximum throttle.
Amp 4-Orb Parallel Fleet
ReadyWork split across 4 remote a1.large orbs with gigabit interconnection.
Five Compute Sizing Tiers, Billed by the Minute
Pick the exact compute footprint needed for each prompt or lifecycle step. Orbs pause after 5 minutes of inactivity and resume in seconds.
| Orb Size | vCPUs | RAM | NVMe Disk | Hourly Rate | Per-Minute Rate | Best Workloads |
|---|---|---|---|---|---|---|
| a1.tiny | 1 Core | 2 GB | 40 GB | $0.08 / hr | ~$0.0013 / min | Linting, documentation lookups, simple PR reviews |
| a1.small (Default) | 2 Cores | 4 GB | 40 GB | $0.17 / hr | ~$0.0028 / min | General feature coding, bugfixes, component tests |
| a1.medium | 4 Cores | 8 GB | 40 GB | $0.33 / hr | ~$0.0055 / min | Integration tests, Next.js / Vite compiles, Postgres seeding |
| a1.large | 8 Cores | 16 GB | 40 GB | $0.66 / hr | ~$0.011 / min | Large test suites, E2E browser runs, monorepo migrations |
| a1.xxlarge | 16 Cores | 32 GB | 40 GB | $1.32 / hr | ~$0.022 / min | Heavy C++/Rust compiles, massive data processing, batch ffmpeg |
Agent Modes & Reasoning Tiers
Select the depth of autonomous reasoning per prompt:
Low Mode Fast
Lightweight edits, doc updates, and mechanical lint repairs. High speed, minimal reasoning latency.
Medium Mode Standard
Balanced reasoning for feature implementation, test drafting, and refactors across 3-8 files.
High Mode Deep
Deep architectural planning, multi-step migrations, and complex root-cause debugging across repos.
Ultra Mode Maximum
Autonomous multi-agent swarms, exhaustive boundary sweep testing, and zero-compromise monorepo upgrades.
For Individual Engineers
Everything needed for autonomous daily development.
- ✓ 750 hours of
a1.smallremote orbs included - ✓ $20 of included agent reasoning usage
- ✓ Access to Low and Medium agent modes
- ✓ Web, Terminal TUI, and Mobile Phone access
- ✓ 24-hour setup snapshot caching
For Power Developers & Swarms
Maximum compute for massive repos and parallel fleets.
- ✓ 1,000 hours of
a1.xxlargeorbs included - ✓ $200 of included agent usage
- ✓ All agent modes: Low, Medium, High, Ultra
- ✓ Multi-agent swarm coordination across orbs
- ✓ Instant warm snapshots & priority port portals
For Teams & Enterprises
Elastic scale with zero artificial concurrency caps.
- ✓ Unlimited concurrency across all 5 orb tiers
- ✓ Dedicated VPCs and self-hosted orb runners
- ✓ Team audit logs, RBAC, and centralized billing
- ✓ Custom Debian base images and private npm registries
- ✓ 99.99% uptime SLA & dedicated support
Portals: Expose In-Orb Web Apps to Authenticated URLs
Portals expose HTTP servers running inside an orb as authenticated, secure URLs.
Declare services in .amp/services.yaml, start them with amp orb services ensure, and test changes live in your browser.
Live Portal Request Simulation
When an orb is paused ($0/hr), visiting its authenticated Portal URL automatically wakes the machine, resumes billing, and serves the request in under 2 seconds!
.amp/services.yaml Config
# Declare long-lived services exposed via Portals
services:
web:
command: pnpm run dev --port $PORT
port: 3000
ready_endpoint: /api/health
api:
command: python -m uvicorn app:app --port $PORT
port: 8000
docs:
command: bun run docs --port $PORT
port: 4000
Each service automatically receives $PORT, $AMP_THREAD_ID, and $PUBLIC_URL. Services can reference each other's URLs seamlessly.