Ampcode Release Notes

Follow

169 release notes curated from 57 sources by the Releasebot Team. Last updated: Nov 19, 2026

Get this feed:
  • Nov 17, 2026
    • Date parsed from source:
      Nov 17, 2026
    • First seen by Releasebot:
      Nov 19, 2026
    Ampcode logo

    Ampcode

    Amp for Windows

    Ampcode releases a Windows app, expanding its native app availability for users.

    We now have a Windows app: Read the docs, or see all Amp native apps.

    Original source
  • Nov 12, 2026
    • Date parsed from source:
      Nov 12, 2026
    • First seen by Releasebot:
      Nov 13, 2026
    Ampcode logo

    Ampcode

    Bye Bye, Dial

    Ampcode replaces the Dial with a model selector that lets users choose a model and effort, see billing sources, and switch models mid-thread. Staff Pick offers a recommended default, while model-specific prompts and tools adapt automatically.

    Today we're saying goodbye to the Dial and its four modes: low, medium, high, and ultra.

    A model selector takes its place:

    You can now pick the model and its effort for each thread. And you can now also switch both in the middle of a thread.

    The model selector now also shows you which of your subscriptions or API keys will be billed for each model, or whether it uses Amp credits.

    If you don't want to pick the model yourself, use the Staff Pick, which is the model we would choose.

    Yes, We Changed Our Mind

    In January we explained why Amp does not have a model selector. In July we then shipped the Dial so you could focus on how hard a task is instead of thinking about model names and version numbers. And it worked: when we changed the default model behind the Dial, nobody complained.

    But then we added the ability to Amp to bring your own subscriptions and keys, and Amp became free when you do. That changed what the selected model does. Not only is it what produces the tokens, but it also started to decide who gets billed. medium on the Dial could use your Claude plan, or your ChatGPT plan, or Amp credits, and it became very hard to tell who's paying for which model when.

    And that's not to speak of all the settings we had to add to the Dial to make it work in every combination.

    So we decided to stop hiding the model and now have a model selector. Now, when you pick it yourself, you know where the tokens come from and who's paying.

    And yet, it's still not just a model you pick. An agent is more than a model. You pick the model, and we build the harness around it: each model in the selector gets a system prompt and tools optimized for it, and both switch when you switch models in a thread.

    Switch Models in a Thread

    With the Dial, a thread kept the mode (and model) it started with. We did that because a model became confused when it continued a conversation that another model had started. But now models are good enough to recover from that.

    Now you can change the model mid-thread by opening the selector and making the change. After your next message the new model will be used and the transcript will show a record: "Switched to GPT-6.1 Sol · High".

    But some things haven't changed. A model switch still has a price. Prompt caches belong to one model, so the new model reads the whole thread uncached, and the first message after a switch costs more.

    Threads that run an agent from a plugin keep that agent.

    Staff Pick

    New threads start on Staff Pick by default. (Except if you had previously configured the Dial to have a default mode.)

    Staff Pick is the model we would pick ourselves, which is Claude Opus 5.5 today. We keep benchmarking models, and we'll change the pick when another model does better.

    In Settings → Model Selector, under New Threads Start On, you can also start new threads on the model you picked last, or on one fixed model you choose.

    What Happens to Your Dial

    Until today everyone used the Dial, so this applies to you.

    New threads start on Staff Pick, whichever mode you used last.

    Existing threads keep working. A thread you started in high continues on the model it ran.

    Dial settings don't carry over. If you changed the model behind a mode in Tune Modes, pick that model in the selector now. If you put your own agents on the Dial in Build Dial, you find them under Other Models.

    If you never changed those settings, these are the models your modes ran. The first three are at the top of the selector, and Claude Fable 5.2 is under Other Models:

    • low: GLM-5.3-Flash
    • medium: Claude Opus 5.5
    • high: GPT-6 Astra
    • ultra: Claude Fable 5.2

    Pin your models in Settings → Model Selector, or leave the selector on Staff Pick.

    Read the Model Selector docs for everything the selector and its settings do.

    Original source
  • All of your release notes in one feed

    Join Releasebot and get updates from Ampcode and hundreds of other software products.

    Create account
  • Nov 10, 2026
    • Date parsed from source:
      Nov 10, 2026
    • First seen by Releasebot:
      Nov 11, 2026
    Ampcode logo

    Ampcode

    Boxes

    Ampcode introduces Boxes, always-on virtual machines where users can deploy multiple applications, share them with teammates, and run agents to manage live apps and data. Boxes offer configurable sizes, per-minute billing, and scheduled uptime.

    Today, we're introducing something new to Amp: boxes.

    A box is an always-on computer to which you can deploy the many delightful things you've built with Amp.

    Boxes are small and cheap (the smallest one is $18 per 30 days). But they're full-on computers. You can run anything you want on them. They come with an agent running on them, too. And agents are great at running on computers.

    Today, with hyper-individual software being created nearly as fast as someone can dictate a prompt, a small machine goes a long way and can serve most personal or internal software. Software that you build for yourself and people you work with doesn't need to scale to thousands of users. All it needs to be is available for everyone you want to share with and within reach of an agent.

    That's what boxes are: a home for what you build with your agents.

    Here's Thorsten showing how he deploys applications to boxes and then modifies their production data using agents:

    (Note: prices shown in the video refer to Enterprise plan prices. Personal and Team boxes are cheaper. See Pricing.)

    How It Works

    You develop your software in orbs. You test and share work in progress in portals. When you're ready, you ask the agent to spawn a box for you.

    A box is a single VM to which you can then deploy multiple applications. Each application gets its own URL. The box is permanent and will stick around, it doesn't turn off, and you can deploy to it multiple times from however many orbs you want. (If you want to save money, you can ask the agent to turn the box on and off on a schedule.)

    It's worth pointing out that there are no containers or other abstractions involved. A box truly is... just a computer. Because, again, agents are great at using those.

    If you want, you can make deployments private or require visitors to Sign In With Amp. Ask the agent to do it for you, it'll know how.

    Shared Boxes

    You can share boxes with your workspace, so you can run your internal software on a box and everyone on the team can deploy new versions.

    Runners on Boxes

    Each box comes with its own runner. That means you can leverage how good agents are at using computers by spawning them right there, on the box.

    Ask them to clean up the team wiki's database, for example. Or add a new entry based on a screenshot you took. Or ask it to analyze the data everyone added.

    Why build elaborate admin interfaces when you can just ask the agent, right there, to modify the state of the running applications?

    Pricing

    Boxes come in different sizes. They're billed by the minute. By default, they're always on. But you can turn them on and off on a schedule, if you want to save money.

    Size Machine Per hour 30 days, always on 30 days, on 6am to 9pm b1.tiny 0.5 vCPU (bursts to 2), 2 GB $0.025 $18 $11.25 b1.small (default) 1 vCPU (bursts to 2), 4 GB $0.042 $30 $18.75 b1.medium 2 vCPUs, 8 GB $0.069 $50 $31.25 b1.large 4 vCPUs, 16 GB $0.139 $100 $62.50

    Getting Started

    Ask your agent to create a personal box for you and then ask it to deploy an application to it. Read the docs if you want to find out more.

    Original source
  • Nov 9, 2026
    • Date parsed from source:
      Nov 9, 2026
    • First seen by Releasebot:
      Nov 10, 2026
    Ampcode logo

    Ampcode

    Portals on Your Runner

    Ampcode brings Portals to local machines, letting users open dev servers and websites from a thread’s Portal tab. Portals are private by default, with an option to share them across a workspace.

    Portals, which you know and love from using them in orbs, now work on your local machines too.

    You can ask Amp to start a dev server or build a website on your machine and open it from the thread's Portal tab, regardless of where you are.

    Turn on Allow Portals under Settings › Runner in the macOS app, or start your runner with amp --no-tui --remote-control-portals.

    Portals on your runner are only accessible to you. To share them with your workspace, start a shared runner with --share, or turn on Share With Workspace in the macOS app, and everyone in the workspace can open its portals.

    Read Portals on Your Runner for more details.

    Original source
  • Nov 6, 2026
    • Date parsed from source:
      Nov 6, 2026
    • First seen by Releasebot:
      Nov 7, 2026
    Ampcode logo

    Ampcode

    Close the Loop

    Ampcode now supports a website feedback widget that lets users annotate page elements and send change requests directly into a new Amp project thread, where they can review and ship the resulting changes.

    You can now send feedback to Amp directly from your website.

    Enable the feedback widget in the settings for your project and add one script to your website.

    Then visit the site with ?amp appended, and the annotation widget is displayed.

    Click on any part of the page and write instructions for Amp.

    Once you are done, send the feedback to Amp. The first time, you sign in with Amp. Then Amp starts a new thread in your project and makes the change.

    You ship it from the thread like any other change.

    Use It

    By default the widget is invisible: it only shows up when you open the site with ?amp, or when you have used the widget before.

    Click the widget, then click an element on the page and write what you want changed. Click New Comment to comment on another one.

    When you're done, click Send. The first time, Amp asks you to connect your account: click Continue with Amp, sign in, and approve the consent screen.

    Then click Start in Orb. Amp starts a new thread in your project with your comments, and Open Thread takes you there.

    After that, the widget shows up on this site without ?amp, until you hide it.

    Read more about the feedback widget in the docs.

    Original source
  • Similar to Ampcode with recent updates:

  • Nov 6, 2026
    • Date parsed from source:
      Nov 6, 2026
    • First seen by Releasebot:
      Nov 7, 2026
    Ampcode logo

    Ampcode

    Spaces

    Ampcode launches spaces, a new way to coordinate multiple agents through one conversation. Spaces delegate work into threads, support team collaboration, and help manage feature launches, user issues, and security reviews from a shared workspace.

    Today we're launching spaces, a new way to interact with agents and your team in Amp.

    A space is a conversation with a single agent whose job is to spawn and coordinate agents for you. You no longer have to create and organize threads yourself; the agent in a space will do it for you.

    It's a new, higher-level way to work with many agents.

    After using spaces for the past few weeks, we think this might be the future of interacting with agents. There's something special about this way of working. You operate with a bird's-eye view but can still dive into the weeds when necessary. It's more like sitting in the captain's chair than down in the trenches.

    We also found that we naturally moved into the space to communicate with each other. Instead of Slack, we found ourselves taking video calls and discussions into the space.

    Here are some examples of how we've been using spaces at Amp.

    Collaborate on a New Feature

    Spaces were built in a space. Tim, Lewis, Nicolay and the rest of the team shared one called "Spaces v1", dropped feedback, bugs and new ideas into the chat, and the agent delegated them into threads. When they needed to talk, they used comments to chat and then tagged in Amp when they were ready.

    Launching and Supporting a Feature

    Lewis ran the launch of service accounts from one space. From the space, Lewis could roll out the feature, monitor X, Slack, and bug reports for issues, fix incoming bugs, and send out emails and refunds to affected users. The space monitored user issues and system health for the rest of the week.

    Regular Security Reviews

    Will gave a space a goal: review recent changes for security issues. Its first run split the codebase into 16 areas, reviewed each in its own thread, checked every finding in another, and kept a summary artifact in the space for Will to review and track.

    To start a space, use the + in the Spaces section of the sidebar, set a title and a project, and then tell your agent what to work on.

    Original source
  • Nov 5, 2026
    • Date parsed from source:
      Nov 5, 2026
    • First seen by Releasebot:
      Nov 6, 2026
    Ampcode logo

    Ampcode

    GitLab Integration

    Ampcode adds GitLab integration for cloud and self-managed instances, letting agents work from repositories, open and review merge requests, follow CI updates, and create dedicated orbs for new issues and merge requests.

    Amp now integrates with GitLab, on gitlab.com and on self-managed instances.

    Connect your GitLab account and you can start projects from your GitLab repositories. Orbs clone and push as you and come with glab signed in, so the agent can open merge requests, comment on them, and read issues and pipelines.

    Amp can also subscribe to comments and CI for a merge request it opens. A reviewer's request or a failed pipeline lands in the thread that wrote the code, so Amp already has the context.

    A New Orb for Every New Merge Request or Issue

    Ask Amp to start a new orb for every new merge request or issue in a project. You don't need to keep the thread where you set it up. See Create an Orb Spawner.

    Each new merge request or issue gets its own orb, which reads it and has a summary ready when you open the thread. Later comments go to that same thread. Workspace admins can also run a spawner as a service account.

    You manage all of these in Settings → Integrations & MCP → GitLab under Event Subscriptions, where you can pause or delete them, edit a spawner, and see the orbs each spawner started.

    Set It Up

    Each person connects GitLab in Settings → Integrations & MCP. Then a group Owner installs Push Updates once for the workspace, with one button in Workspace Settings → Integrations & MCP.

    Amp also supports self-managed GitLab. See Self-Managed Instances.

    Connect GitLab to get started.

    Original source
  • Nov 3, 2026
    • Date parsed from source:
      Nov 3, 2026
    • First seen by Releasebot:
      Nov 4, 2026
    Ampcode logo

    Ampcode

    Service Accounts

    Amp releases Service Accounts, workspace-owned accounts with dedicated API keys and credentials. Teams can share and steer their threads for tasks like pull request reviews, documentation maintenance, and CI workflows, keeping ongoing work accessible beyond any one user.

    Amp now has Service Accounts. A service account is a workspace-owned account that's not tied to a single user.

    Service accounts are created by workspace admins. They have their own API keys and third-party credentials.

    Each thread created under a service account can be viewed by other members of the workspace. These threads are multiplayer too, so workspace members can send messages in them.

    Since anyone in the workspace can drive a service account's threads, make sure to only assign credentials to it that you would be happy bestowing on all workspace members.

    When to Use Service Accounts

    Service accounts fit any work that belongs to the team rather than to one person. For example, threads with automations that workspace members want to have access to, even if the person who set them up is on vacation.

    We've found two patterns where service accounts work especially well.

    Codebase Review and Maintenance

    Reviewing every pull request or keeping docs accurate is work that belongs to the team, not to a single user. When a service account owns that work, anyone on the team can step into its threads and steer them.

    Here are some example prompts for setting that up via Puck:

    Trigger a Workspace-Scoped Orb for New GitHub PRs

    Hey Puck, let's set up a listener so that any new PR that lands triggers a new orb and reviews the changes. The orbs should be owned by the whole team, not just me.

    Amp knows how to set up github PR listeners like this. Because the user asked for the threads to be owned by the workspace and not by the user, Amp will use a service account for these threads.

    A Recurring Review of Public Docs

    Hey Puck, start a workspace-owned thread which scans our public documentation every 24hr and checks it's up to date. If you find an issue, @ mention the person responsible for the change.

    Service accounts are useful for continuous clean up and maintenance tasks like this, which are shared by a team rather than an individual.

    Programmatic Work

    There's work that starts from a script, like a CI job that spawns a thread via amp -ox every time a build fails. By using a service account's API key for that amp invocation, the thread it starts belongs to the service account instead of whoever set up the pipeline.

    Here's an example:

    A Review Bot Running in CI

    run_tests
    if tests_failed; then
    AMP_API_KEY=<SERVICE_ACCOUNT_API_KEY> \
    amp -ox "Tests failed. Is this a real regression or a flaky test?"
    fi
    

    CI and programmatic invocation of Amp is another useful use case for service-accounts, which should not be tied to any individual user.

    Original source
  • Nov 2, 2026
    • Date parsed from source:
      Nov 2, 2026
    • First seen by Releasebot:
      Nov 4, 2026
    Ampcode logo

    Ampcode

    Artifacts

    Ampcode now supports shared, editable Artifacts in agent threads, where users and teammates can review plans, reports, and findings alongside the conversation. Agents incorporate edits, making it easier to collaborate and compare work in one place.

    Agents in Amp can now collaborate with you in Artifacts. These are documents that belong to a single thread and that the agent, you, and your teammates can all edit.

    Here are two examples from our real threads.

    This one is from Nicolay's thread, where he asked whether Amp wastes model calls while it waits on a long shell command. The agent went through 60 of our threads and wrote up what it found: how much the waiting costs, why, and a plan to fix it in two steps. Reading it gets you up to speed on the problem before you decide what to build:

    Artifacts also work well for pulling together what several threads found. In Beyang's thread, a user had asked for a rendered preview of Markdown files in the Changes pane. Beyang had the agent build two versions at once, each in its own orb. When both reported back, the agent put them side by side in one artifact, with what each costs and which one to ship first:

    You don't have to ask for one. When the agent has something for you to read, like a plan, a report, or notes from a call, it writes an artifact instead of a long reply. The artifact opens next to the thread. Edit it like any document: tick off a checklist, fix a table, rewrite a paragraph. When the agent comes back to it, it reads your edits first and works them in instead of writing over them.

    Open Views → Artifacts in any thread, or just ask Amp to write one. More in the docs.

    Original source
  • Oct 29, 2026
    • Date parsed from source:
      Oct 29, 2026
    • First seen by Releasebot:
      Oct 30, 2026
    Ampcode logo

    Ampcode

    macOS Satellites

    Ampcode launches macOS Satellites, pairing Linux development orbs with fresh cloud Macs so Amp can build, run, and test iOS and Mac apps. The beta streams the Mac screen to your thread, lets you watch or take control, and reuses a Mac briefly for follow-up work.

    Amp now has a Mac: ask it to work on your iOS or Mac app and watch it build, test, and run the app.

    Port to iPhone Duo

    New Mac App Feature

    Penny runs on iPhone 17 Pro. Amp has it open in DeviceHub on a Mac next to the thread.

    Amp checks Penny on the iPhone Duo and fixes the layout for both screens.

    Then it opens the new build on the Duo, closed.

    Amp unfolds the Duo, and Penny switches to the side-by-side layout.

    It taps a transaction to open it.

    Amp's report: what it checked on the Duo.

    Amp recorded the Mac while it checked: closed, unfolded, tapped.

    Amp runs the iPod app for the Mac as it is today.

    Amp adds a Model setting for the black and red U2 iPod.

    Then it drives the app: Settings, Model, U2.

    Music, Artists, scroll to The Avalanches.

    The Avalanches, “Since I Left You.”

    Now playing on the U2 iPod.

    Amp's report: what it built and how it checked it.

    Amp recorded the Mac while it played the song itself.

    How It Works

    Your thread still runs on a Linux orb, next to your dev server and toolchain. The Mac is a second machine attached to that orb. Amp can automatically start a Mac, run commands on it, and read and write files, so it decides on its own when the work needs a Mac.

    When it does, our server boots a fresh Mac in the cloud with Xcode and the simulators installed, in about 30 seconds. Your orb connects to it and keeps your code in sync, so Amp still edits on the orb and only builds, runs, and tests on the Mac. Screenshots, logs, and builds come back to the thread, and the app on the Mac reaches your backend on the orb through portals.

    The thread's Mac tab streams the Mac's screen. Watch Amp's work, or take control of the Mac and try the app yourself.

    Every Mac starts fresh, and nothing on it is saved. When Amp is done with a Mac, it keeps it running for 20 more minutes. If you send a follow-up in that time, Amp reuses the same Mac and its build cache instead of starting a new Mac and building from scratch. After that, the Mac is deleted. To delete it right away, archive the thread or ask Amp to stop the Mac.

    Morbs Are Dead, Long Live macOS Satellites

    Before shipping macOS Satellites, we tried out Morbs: orbs that ran the whole thread on a Mac. But we ran into issues that made the approach unfeasible for a wider rollout. Docker and your backend took minutes to start there,[^1] and keeping a Mac disk around for every thread got expensive.

    So we split the thread across two machines. Everything that runs well on Linux stays on the orb and starts fast, and a Mac only shows up for the work that needs macOS.[^2] We're calling them macOS Satellites because they orbit your orb.

    Pricing

    Size CPUs Memory Price mac.medium 6 14 GB $2/hour mac.large 12 28 GB $4/hour

    macOS Satellite time comes out of the same orb usage your plan includes, just at a higher rate. Once that runs out, it comes out of your Amp credits, the same way orb time does.

    Every Mac starts as a mac.medium. If you need more, ask Amp for a mac.large, or turn off mac.medium under Mac Satellites in Settings → Experimental Features.

    Join the Waitlist

    macOS Satellites are in beta and opening up as we add Macs. Join the waitlist in Settings → Experimental Features. Each day you click Move Me Up moves you up the line.

    Go point Amp at that app you've been meaning to build! Find out more in the docs.

    New to Amp? Sign up and get started on your Apple apps.

    Original source
  • Oct 29, 2026
    • Date parsed from source:
      Oct 29, 2026
    • First seen by Releasebot:
      Oct 30, 2026
    Ampcode logo

    Ampcode

    Visualize This

    Ampcode now lets users ask Amp to create interactive charts, timelines, diagrams, and mockups directly in a thread, making visual ideas easy to explore and click through.

    You can now ask Amp to visualize or build something for you and it will do it, right in the thread: charts, timelines, diagrams, and mockups you can click through.

    Here are some examples, from our real threads. Go ahead, hover and click through them:

    Open the post on ampcode.com to see the chart of last month's commits that Amp drew.

    Here, for example, is an excerpt from Quinn's thread, where he asked for ways to fit a diff stat into a small button:

    Open the post on ampcode.com to try Quinn's sixteen diff stat buttons.

    And here's what went into building this feature:

    Open the post on ampcode.com to see the history of this feature that Amp drew.

    Original source
  • Oct 28, 2026
    • Date parsed from source:
      Oct 28, 2026
    • First seen by Releasebot:
      Oct 29, 2026
    Ampcode logo

    Ampcode

    Your Own Self-Hosted Orbs

    Ampcode lets users add personal self-hosted orb providers outside workspaces and labels them Personal in new threads.

    You no longer need to be in a workspace to self-host orbs. Up until now, only workspace admins could manage self-hosted orb providers. Now, you can add a provider in your personal Settings → Orbs and set it up the same way as a workspace provider. When you create a thread, it shows up under Self-Hosted, marked Personal.

    Original source
  • Oct 27, 2026
    • Date parsed from source:
      Oct 27, 2026
    • First seen by Releasebot:
      Oct 28, 2026
    • Modified by Releasebot:
      Oct 29, 2026
    Ampcode logo

    Ampcode

    Amp on Android

    Ampcode launches its Android app, now available to download and install from its website.

    We now have an Android app:

    Download and install from ampcode.com/app, or scan this QR code:

    Original source
  • Oct 22, 2026
    • Date parsed from source:
      Oct 22, 2026
    • First seen by Releasebot:
      Oct 23, 2026
    Ampcode logo

    Ampcode

    Self-Hosted Orbs

    Amp releases self-hosted orbs, letting teams run resumable AI coding environments on their own infrastructure. Custom providers and a Kubernetes Helm chart support a range of compute platforms, with free access for individuals and teams.

    You can now self-host orbs. You provide the compute and Amp turns it into orbs.

    If you have compute that can

    • quickly start new machines
    • put them to sleep and resume them equally fast
    • keep them around for a long time
    • scale them to zero, so no one has to worry about having a lot of them sleeping

    then you are now able to replicate the orb experience within your own infrastructure.

    How It Works

    You run amp orb provider inside your infrastructure. The orb provider then reaches out to Amp and waits for requests to spawn, pause, or delete orbs. Like this:

    How you satisfy those requests is up to you, because amp orb provider will dispatch the requests for orb operations (spawn to create or resume orbs, pause, and delete) to a program that you provide, like so:

    $ amp orb provider ./dispatch.sh
    

    In that program, you can do whatever works best for your infrastructure. Here are some illustrative examples:

    • Docker
    • E2B
    • K8s
    • Apple containers
    • Modal
    • Vercel
    • Daytona
    • exe.dev
    #!/usr/bin/env bash
    # dispatch.sh
    set -euo pipefail
    case "$ORB_OPERATION" in
    spawn)
    docker start "$ORB_ID" 2>/dev/null ||
    docker run --platform linux/amd64 -d --name "$ORB_ID" \
    "$ORB_IMAGE" sleep infinity
    docker exec -d --env ORB_TOKEN "$ORB_ID" amp orb bootstrap
    ;;
    pause)
    docker stop "$ORB_ID"
    ;;
    delete)
    docker rm -f "$ORB_ID"
    ;;
    esac
    
    Install the E2B CLI and the e2b package, set E2B_API_KEY, and build a template:
    
    echo 'FROM us-central1-docker.pkg.dev/amp-prod-0/amp-orb/amp-orb:latest' \
    > e2b.Dockerfile
    e2b template create amp-orbs --dockerfile e2b.Dockerfile \
    --cpu-count 4 --memory-mb 8192 --ready-cmd true
    export E2B_TEMPLATE=amp-orbs
    
    #!/usr/bin/env node
    // dispatch.mjs
    import { Sandbox } from 'e2b'
    const {
    ORB_OPERATION, ORB_ID, ORB_TOKEN, AMP_URL, E2B_TEMPLATE,
    } = process.env
    const metadata = { orbId: ORB_ID }
    const [existing] = await Sandbox.list({
    query: { metadata, state: ['running', 'paused'] },
    }).nextItems()
    if (ORB_OPERATION === 'spawn') {
    const timeoutMs = 60 * 60 * 1000
    const sandbox = existing
    ? await Sandbox.connect(existing.sandboxId, { timeoutMs })
    : await Sandbox.create(E2B_TEMPLATE, {
    metadata, timeoutMs, lifecycle: { onTimeout: 'pause' },
    })
    const envs = { ORB_TOKEN }
    if (AMP_URL) envs.AMP_URL = AMP_URL
    const bootstrap = await sandbox.commands.run('amp orb bootstrap', {
    user: 'user', envs, background: true, timeoutMs: 0,
    })
    await bootstrap.disconnect()
    } else if (ORB_OPERATION === 'pause' && existing) {
    await Sandbox.pause(existing.sandboxId)
    } else if (ORB_OPERATION === 'delete' && existing) {
    await Sandbox.kill(existing.sandboxId)
    }
    
    #!/usr/bin/env bash
    # dispatch.sh
    set -euo pipefail
    export PATH="/usr/local/bin:/opt/homebrew/bin:$PATH"
    # "$ORB_IMAGE" is the Amp orb image.
    ids=$(container list --all --quiet)
    exists() { grep -Fxq "$ORB_ID" <<<"$ids"; }
    case "$ORB_OPERATION" in
    spawn)
    if exists; then
    container start "$ORB_ID"
    else
    container run --detach --init --rosetta \
    --platform linux/amd64 --cpus 4 --memory 8G \
    --name "$ORB_ID" "$ORB_IMAGE" sleep infinity
    fi
    # A bare --env NAME copies the value from the host.
    container exec --detach --env ORB_TOKEN --env AMP_URL \
    "$ORB_ID" amp orb bootstrap
    ;;
    pause)
    if exists; then
    container stop "$ORB_ID"
    fi
    ;;
    delete)
    if exists; then
    container delete --force "$ORB_ID"
    fi
    ;;
    *)
    exit 1
    ;;
    esac
    
    #!/usr/bin/env python3
    # dispatch.py
    import os
    import modal
    # Needs `pip install modal` plus MODAL_TOKEN_ID and MODAL_TOKEN_SECRET.
    APP = "amp-orbs"
    app = modal.App.lookup(APP, create_if_missing=True)
    snapshots = modal.Dict.from_name("amp-orb-snapshots", create_if_missing=True)
    orb_id = os.environ["ORB_ID"]
    try:
    sandbox = modal.Sandbox.from_name(APP, orb_id)
    except modal.exception.NotFoundError:
    sandbox = None
    match os.environ["ORB_OPERATION"]:
    case "spawn":
    if sandbox is None:
    # Modal has no pause, so resume from the last snapshot.
    snapshot = snapshots.get(orb_id)
    if snapshot:
    image = modal.Image.from_id(snapshot)
    else:
    image = modal.Image.from_registry(os.environ["ORB_IMAGE"])
    sandbox = modal.Sandbox.create(
    "sleep", "infinity", app=app, name=orb_id, image=image,
    cpu=4, memory=(16384, 16384), timeout=24 * 60 * 60,
    )
    # Modal execs run as root; point bootstrap at the image user's home.
    bootstrap = "setsid amp orb bootstrap </dev/null >/dev/null 2>&1 &"
    sandbox.exec(
    "bash", "-c", bootstrap,
    env={
    "ORB_TOKEN": os.environ["ORB_TOKEN"],
    "AMP_URL": os.environ.get("AMP_URL"),
    "HOME": "/home/user", "USER": "user",
    },
    ).wait()
    case "pause":
    if sandbox:
    image_id = sandbox.snapshot_filesystem(timeout=120).object_id
    snapshots[orb_id] = image_id
    sandbox.terminate()
    case "delete":
    if sandbox:
    sandbox.terminate()
    snapshots.pop(orb_id, None)
    
    #!/usr/bin/env node
    // dispatch.mjs
    import { APIError, Sandbox, Snapshot } from '@vercel/sandbox'
    const { ORB_OPERATION, ORB_ID, ORB_IMAGE, ORB_TOKEN, AMP_URL } = process.env
    const credentials = {
    token: process.env.VERCEL_TOKEN,
    teamId: process.env.VERCEL_TEAM_ID,
    projectId: process.env.VERCEL_PROJECT_ID,
    }
    if (ORB_OPERATION === 'spawn') {
    const sandbox = await Sandbox.getOrCreate({
    ...credentials,
    name: ORB_ID,
    // Copy Amp's image to VCR, then set ORB_IMAGE to its VCR URL.
    image: ORB_IMAGE,
    resources: { vcpus: 4 },
    timeout: 60 * 60 * 1000,
    persistent: true,
    snapshotExpiration: 0,
    keepLastSnapshots: { count: 1, expiration: 0, deleteEvicted: true },
    })
    const setup = await sandbox.runCommand({
    cmd: '/bin/bash',
    args: ['-c', 'hostname localhost && mkdir -p /vercel/sandbox'],
    sudo: true,
    })
    if (setup.exitCode !== 0) throw new Error(await setup.stderr())
    await sandbox.runCommand({
    cmd: '/usr/bin/setpriv',
    args: [
    '--reuid=user', '--regid=user', '--init-groups', '--',
    '/usr/bin/env', `ORB_TOKEN=${ORB_TOKEN}`,
    ...(AMP_URL ? [`AMP_URL=${AMP_URL}`] : []),
    'HOME=/home/user', 'USER=user', '/bin/bash', '-lc',
    'exec amp orb bootstrap',
    ],
    sudo: true,
    detached: true,
    })
    } else if (ORB_OPERATION === 'pause' || ORB_OPERATION === 'delete') {
    try {
    const sandbox = await Sandbox.get({
    ...credentials, name: ORB_ID, resume: false,
    })
    if (ORB_OPERATION === 'delete') {
    if (sandbox.status === 'running') await sandbox.stop()
    for await (const saved of await sandbox.listSnapshots()) {
    if (saved.status !== 'created') continue
    const snapshot = await Snapshot.get({
    ...credentials, snapshotId: saved.id,
    })
    await snapshot.delete()
    }
    await sandbox.delete()
    } else if (sandbox.status === 'running') await sandbox.stop()
    } catch (error) {
    if (!(error instanceof APIError && error.response.status === 404)) {
    throw error
    }
    }
    }
    
    #!/usr/bin/env python3
    # dispatch.py
    import os
    from uuid import uuid4
    from daytona import (
    Daytona, DaytonaNotFoundError, CreateSandboxFromImageParams,
    Resources, SessionExecuteRequest, SandboxState,
    )
    daytona = Daytona()
    operation = os.environ['ORB_OPERATION']
    try:
    sandbox = daytona.get(os.environ['ORB_ID'])
    except DaytonaNotFoundError:
    sandbox = None
    if operation == 'spawn':
    if sandbox is None:
    sandbox = daytona.create(CreateSandboxFromImageParams(
    name=os.environ['ORB_ID'], image=os.environ['ORB_IMAGE'],
    os_user='user', resources=Resources(cpu=4, memory=8, disk=10),
    auto_stop_interval=0, auto_delete_interval=-1,
    ), timeout=240)
    elif sandbox.state != SandboxState.STARTED:
    sandbox.start()
    env = {key: os.environ[key] for key in ('ORB_TOKEN', 'AMP_URL')
    if key in os.environ}
    sandbox.update_env(env, unset=['AMP_URL'])
    session = str(uuid4())
    sandbox.process.create_session(session)
    sandbox.process.execute_session_command(session, SessionExecuteRequest(
    command="bash -lc 'exec amp orb bootstrap'", run_async=True,
    ))
    elif operation == 'pause' and sandbox:
    if sandbox.state == SandboxState.STARTED:
    sandbox.stop()
    elif operation == 'delete' and sandbox:
    sandbox.delete()
    
    #!/usr/bin/env bash
    # dispatch.sh
    set -euo pipefail
    # Pause/resume currently requires access enabled by exe.dev support.
    status=$(ssh exe.dev ls "$ORB_ID" --json |
    jq -r --arg id "$ORB_ID" '.vms[] | select(.vm_name == $id) | .status')
    case "$ORB_OPERATION" in
    spawn)
    if [[ -z "$status" ]]; then
    ssh exe.dev new --name="$ORB_ID" --image="$ORB_IMAGE" \
    --cpu=2 --memory=8G --no-email
    elif [[ "$status" == paused ]]; then
    ssh exe.dev resume "$ORB_ID"
    fi
    {
    printf 'export ORB_TOKEN=%q\n' "$ORB_TOKEN"
    if [[ -n "${AMP_URL:-}" ]]; then
    printf 'export AMP_URL=%q\n' "$AMP_URL"
    fi
    cat <<'BOOTSTRAP'
    sudo -u user --preserve-env=ORB_TOKEN,AMP_URL bash -lc \
    'cd "$HOME"; nohup amp orb bootstrap </dev/null >.amp-bootstrap.log 2>&1 &'
    BOOTSTRAP
    } | ssh "$ORB_ID.exe.xyz" bash -s
    ;;
    pause)
    if [[ "$status" == running ]]; then
    ssh exe.dev pause "$ORB_ID"
    fi
    ;;
    delete)
    if [[ -n "$status" ]]; then
    ssh exe.dev rm "$ORB_ID"
    fi
    ;;
    esac
    

    Use Amp's Helm chart to run orbs on GKE, EKS, or AKS.

    Under the hood, it runs amp orb provider with a supplied dispatch program that handles spawning, pausing, and deleting orbs. You don't need to write a dispatch script yourself.

    • Create a custom orb provider in your Amp workspace and copy its token.
    • Prepare a dedicated cluster with worker nodes and snapshot storage. Paused orbs are saved to storage and can resume on another worker node.
    • Download the Kubernetes setup files.
    • The ZIP includes gke.md, eks.md, and aks.md with the setup and Helm commands for each cloud, plus Terraform examples. Use the instructions for your cloud to install the chart and test your first orb.

    These examples use Amp's pre-built ORB_IMAGE, which includes the Amp CLI and other dependencies. You can use a different Linux image as long as you can start amp orb bootstrap in it (and it has the dependencies for other features). That process connects the orb to Amp so Amp can set up the environment and run the agent's tools.

    Once you have your dispatch program, go to your workspace settings (individuals can create a workspace for free), add a Custom Orb Provider, copy the token, and run amp orb provider:

    $ chmod +x dispatch.sh
    $ export AMP_ORB_PROVIDER_TOKEN="<copied-token>"
    $ amp orb provider ./dispatch.sh
    

    Once that runs, open ampcode.com or the Amp macOS or iOS applications and create a new thread. Expand Orb and choose your provider under Self-Hosted.

    And then submit your prompt. Amp will send a request to your provider to spawn an orb, clone your repository, run your setup files, and start the agent.

    And thus begins, as they say, orbin' time. Self-hosted.

    You Probably Shouldn't Self-Host Orbs

    All that said: you probably shouldn't self-host orbs.

    We built self-hosted orbs for enterprises that can't use the orbs we host, because regulations might restrict where their code runs, because they need access to internal networks, or because they need custom hardware attached.

    If you're on an Enterprise plan, let us know and we'll help you set it up.

    That's why the interface is so open: we want to support all the infrastructure our enterprise customers might have, as long as it meets the qualitative requirements above (fast-to-start, resumable machines that scale to zero, etc.). But that also means we only support our end of the contract, not every possible piece of infrastructure you can plug in.

    Pricing

    Self-hosted orbs are free for individuals and teams. Enterprises will be charged standard orb pricing starting October 29. Until then, self-hosted orbs are free for every workspace.

    Getting Started

    For more information on self-hosted orbs and how to run self-hosted orbs on Kubernetes, see the documentation.

    Original source
  • Oct 19, 2026
    • Date parsed from source:
      Oct 19, 2026
    • First seen by Releasebot:
      Oct 21, 2026
    Ampcode logo

    Ampcode

    Assign It To Amp

    Ampcode brings its agent into Linear, letting teams assign issues or mention @Amp to start sessions, follow progress, and continue the conversation in Amp. Install the agent and connect your Amp account to get started.

    Amp is now an agent in Linear.

    Assigning an issue to Amp starts a new Agent Session in Linear and spawns a new orb. You can also mention @Amp to kick off a session. Amp sends its response back to the same session and replies to messages sent along the way. The Agent Session also appears in your Amp sidebar and is fully viewable in Amp.

    • Assign Amp an issue in Linear.
    • Follow its progress in the Agent Session.
    • Then open the same conversation in Amp.

    To get started, install the Amp agent in your Linear workspace and connect your Amp account to the Linear MCP in Settings → MCP & Integrations.

    Read the docs to learn more.

    Original source
Releasebot

Curated by the Releasebot team

Releasebot is an aggregator of official release notes from hundreds of software vendors and thousands of sources.

Our editorial process involves the manual review and audit of release notes procured with the help of automated systems.