Build a very beautiful, elegant, and genuinely accessible explainer website about **Amp Code Orbs** — the remote machines that Amp (https://ampcode.com/) gives its coding agents to work in — and about how orbs supercharge agentic development. The visitor should arrive not knowing what an orb is and leave with a vivid, concrete, correct mental model: what an orb actually is, what lives inside one, what happens when an agent is placed in one, why moving agents off the laptop changes the economics and the ambition of the work, and what a developer's day looks like once many agents can run in parallel, unsupervised, while the laptop is closed.
Gamify it wherever gamification genuinely teaches rather than decorates. The strongest version of this site is not a page you scroll — it is a page you *play*, where the mechanics of the game are the mechanics of orbs. Consider letting the visitor actually run a workday: spawn orbs, size them, assign real tasks to them, watch agents work in parallel across a fleet, feel the difference between one local agent blocking the machine and five remote agents grinding through a migration at once, watch orbs auto-pause when idle and wake instantly when work returns, and see a live meter of minutes burned versus work completed. Scoring, streaks, unlocks, achievements, a challenge or scenario ladder, a "beat the laptop" head-to-head race, or a light strategy layer about which orb size to spend on which job are all fair game — as long as every mechanic maps to something true about how orbs work. A visitor who plays well should have learned the product; a visitor who only reads should still get a complete, well-written explainer.
Ground every product claim in fact. These details are verified from ampcode.com and should be reflected accurately; you may verify, deepen, and extend them against the live site, and you should, because the explainer's credibility is the whole point:
- Orbs are remote machines where Amp agents run without supervision. Creating a new thread gives you a fresh orb containing your code, your plugins, and the tools the agent needs. Agents in orbs are not on your machine, but you control them exactly as if they were.
- They exist for long builds, large test suites, repository migrations, and any task you do not want eating your local machine. Agents keep working when you are not sitting at your computer.
- Ways to launch one: on the web, click "Create New Thread" at ampcode.com, pick a project, enter a prompt; from the CLI, `amp -ox "your prompt"`; from the TUI, `thread: new in orb` in the command palette; from a plugin, `agent.createThread({ executor: 'orb' })`.
- Five sizes, billed by the minute: `a1.tiny` (1 CPU, 2 GB RAM, 40 GB disk, $0.08/hr), `a1.small` (2 CPU, 4 GB, 40 GB, $0.17/hr), `a1.medium` (4 CPU, 8 GB, 40 GB, $0.33/hr), `a1.large` (8 CPU, 16 GB, 40 GB, $0.66/hr), `a1.xxlarge` (16 CPU, 32 GB, 40 GB, $1.32/hr). Pick a size with `amp -ox "prompt" --orb-size a1.small`. Enterprise pricing runs 50% higher.
- Orbs auto-pause after 5 minutes of inactivity and pause when a thread is archived. Paused orbs cost nothing and resume automatically the moment they are accessed. After first setup, the sandbox is snapshotted and the snapshot is reused for up to 24 hours for new orbs, which makes them start fast.
- Inside: Debian 12, with an authenticated `gh` and `amp`, Git, SSH, tmux, ffmpeg, ImageMagick, vim, jq, fzf, ripgrep, PostgreSQL and Redis, Bun, Node.js, npm, pnpm, Yarn, Python and pip, and agent-browser. Anything else installs with `apt`.
- Repository lifecycle scripts: `.agents/setup` runs once while an orb is being prepared — install dependencies, generate files, seed databases, verify tools; it logs to `/home/user/.cache/amp/logs/setup.log`. `.agents/resume` runs every time an existing orb wakes, must be fast and idempotent, and has a 10-second timeout; it logs to `/home/user/.cache/amp/logs/resume.log`. `AGENTS.md` carries repository guidance for the agent.
- You keep full hands-on control: browse files on the orb, open a terminal inside it, review and approve the agent's changes straight from the thread without pulling them down, and mirror the orb's changes to your laptop with `amp sync thread-id` while the work continues remotely.
- Portals expose web servers running inside an orb as authenticated URLs. Declare long-lived services in `.amp/services.yaml`, start them with `amp orb services ensure`; each service receives `$PORT`, `$AMP_THREAD_ID`, and `$PUBLIC_URL`, services can reference each other's URLs, and only thread viewers can reach a portal. A request to a portal wakes a paused orb and resumes billing.
- Agents can spawn other agents across orbs, local machines, and remote machines, sharing messages and files to parallelize work, offload tasks, and coordinate across projects.
- Amp runs on the web, in the terminal, and on the phone. Agent modes are `low`, `medium`, `high`, and `ultra`. Plans include Megawatt at $20/month (750 hours of small orbs, $20 of included agent usage, low and medium modes) and Gigawatt at $200/month (1,000 hours of xxlarge orbs, $200 of included agent usage, all modes), plus an Unconstrained pay-as-you-go option for teams and enterprises.
Make it beautiful with intent, not with noise. Orbs invite a real visual language — spheres, containment, light, dormancy and waking, a fleet moving in parallel — and the site should commit to a coherent, confident aesthetic built on that idea rather than reaching for generic gradient-and-glow filler. Take the visual cue from ampcode.com itself: study the real site, borrow its restraint and typographic personality, and fetch whatever external assets genuinely make the point — logos, marks, fonts, screenshots, imagery, icons. Every asset you use must be downloaded and stored as a local file inside the delivered folder, never hotlinked from a remote origin, so the site renders identically with no network at all. Keep the delivered folder inside a conservative static-hosting envelope: at most 1,000 files, no single file above 5 MiB, and no more than 100 MiB in total.
Accessibility is a hard requirement of this brief, not a finishing touch, and it must survive the gamification. Build on real semantic structure with a sane heading outline and landmarks. Every interactive element — every orb you can spawn, size, assign, pause, or inspect — must be reachable and fully operable by keyboard alone, with a visible, well-designed focus indicator and a logical tab order. Give the game a genuine non-visual path: live regions that announce state changes, meaningful names and roles on controls, text equivalents for anything conveyed by color, motion, or position, and a readable summary of any state the visitor would otherwise have to see to understand. Meet or beat WCAG AA contrast in every theme you ship. Honor `prefers-reduced-motion` with a version of the experience that is still complete and still fun rather than a stripped fallback, and never trap focus, never rely on hover alone, and never let a timed mechanic lock out someone who needs longer. The experience must work well from small phones to large desktops, with touch targets sized for fingers and layouts that reflow rather than break.
Carry the piece all the way through. That means the quiet states as much as the loud ones: what the page looks like before anything has been spawned, mid-flight while agents are working, at the moment an orb pauses, when a task fails or a test suite goes red, when the fleet is saturated, and when the visitor has finished everything there is to finish. It means honest, well-edited prose — a real explainer someone could learn from — sitting alongside the interactive layer, not replaced by it. It means motion that has weight and timing rather than default easing, feedback for every action, considered empty and error states, and small details that reward a second visit.
Do not take shortcuts, do not settle for a cookie-cutter scrolling landing…