Recent Product Changes

This page summarizes recent changes that affect how people use SAM. Use it as a quick orientation when returning to the product after a week away, then follow the linked guides for the full workflow.

This cycle: 6 – 13 October 2026

For everyone

Use SAM from Claude and ChatGPT. Connect the AI app you already use to SAM, then ask it what needs your attention, start a chat in a project, reply to one, or answer an agent that’s waiting for you, without opening SAM. → Use SAM from Claude and ChatGPT
Agents can set up automation for you. Ask an agent to create a schedule, GitHub, or webhook trigger, and it appears on the project’s Triggers page like one you made yourself. → Triggers
A chat wakes up as it went to sleep. A chat started since 7 October wakes with the agent, model, and permission mode it started with, and can still ask you for approval if it could before. A Task still commits, pushes, and opens its pull request after a wake. → After a chat wakes from sleep
Fork and Retry open instantly. Fork no longer waits for an AI summary: the new chat is pre-filled with the old session’s IDs, and its agent reads the original conversation itself. Retry pre-fills the original request. → Conversation Forking
An expired chat says so. A chat that slept longer than its saved workspace is kept shows Expired and offers Fork conversation, instead of failing when you try to wake it. → Expired saved workspace
A failed wake keeps the chat asleep. If a VM chat can’t wake, it goes back to sleep on the same task and you can try again, instead of the task failing. → Wake failed
SAM can once again move a session off a VM that runs short of memory. The chat shows Sleeping for a moment and wakes on another machine with its files. These moves had been failing since 9 October. → SAM moved the session to another machine
New models. Claude Haiku 5.5, and more OpenCode models. → New models
A guide to the command line. Install the sam CLI, sign in, and start, follow, and reply to work from a terminal or a script. → SAM CLI

Also changed this week:

Archive works on sleeping VM chats. It used to fail with “Task cannot be closed from status ‘sleeping’”.
Sleeping Instant chats can be woken for the full seven days, instead of only about four hours, and Stop and Archive finish reliably on them.
Long tasks that keep making progress are no longer stopped after eight hours. They run until SAM’s inactivity check or the 24-hour limit.
A new VM that fails to start gets another chance. SAM retries its certificate and setup steps, then replaces the VM once, instead of failing the task on the first error.
Messages and events reach sleeping chats. Wakes triggered by another agent’s message, a scheduled action, or an event no longer fail at random, arrive as soon as the chat is ready, and one pending event no longer silences a chat for a day.
A sleep that can’t finish ends visibly. If SAM can’t confirm a workspace stopped, the chat says so and ends, instead of promising a wake it couldn’t guarantee. → SAM could not finish putting the session to sleep
Claude usage chips work. Readings from many Claude Pro and Max credentials were being dropped, and the rest showed one limit without a percentage. The chip now shows the five-hour and weekly limits. → Usage Limits
Messages between agents arrive as a notice from SAM. The recipient’s chat shows a SAM notice written for its agent, which you don’t need to answer, and the conversation between the two agents is on the project’s Events page. → Messages between agents
A new Chat you start on a VM no longer waits for another workspace on the same machine to finish building.
Messages with @ and a word failed from 9 to 14 October. A message with an email address (bob@example.com), a package name (@types/node), or a decorator (@dataclass) was refused with Agent profile not found unless the word named one of your agent profiles. Fixed on 14 October: an @ that doesn’t name a profile is now ordinary text. → Agent profile not found
Resource history is no longer counted twice when a workspace re-sends it. The duplicate inflated the totals agents read with get_resource_history and could drop that stretch’s detail from the Resources panel. Sessions recorded before the fix keep the inflated totals and gaps.

For self-hosters & admins

Update to v2026.10.15 or later: two regressions affect the releases in between.

Memory-pressure moves: v2026.10.09 to v2026.10.12 can’t move a session off a VM that runs short of memory. Fixed in v2026.10.13, which is also the first release in which a sleep that can’t finish ends visibly.
@ messages: v2026.10.10 to v2026.10.14 refuse messages with @ and a word, as described above. Fixed in v2026.10.15.

There are no new secrets or Cloudflare token permissions; the new database migrations run in the deploy pipeline, and the deploy creates the Connector’s storage.

Variables marked Secret are no longer in the agent’s shell (from v2026.10.14). In a workspace started after you update, the agent sees a placeholder instead of the value and runs commands that need it with exec_with_secrets, which only nodes started after the update support. → Run commands with secrets
The SAM Connector is on after you update (from v2026.10.10). To keep it off, switch off Enable Connector in Admin → Integrations → Connector, or set the CONNECTOR_ENABLED GitHub Environment variable to false before you deploy. Claude’s and ChatGPT’s servers must be able to reach your API, so a Cloudflare Access login wall or a WAF challenge in front of it stops connections. → Self-hosted installations
Chats started before v2026.10.08 wake in Manual. They have no recorded settings, so they wake asking for approval before changing anything (Codex agents never ask). If you haven’t turned agent requests on, those requests are refused, so tell people to fork such a chat rather than keep using it.
Pending accounts are held back everywhere. With signup approval on, an account waiting for approval can no longer use the SAM and project agent chats, manage API tokens, or open workspaces in the browser. → Signup approval
Keep anonymous trials off. Every trial visitor runs under one shared account and can land on the same machine as another visitor, so per-user isolation doesn’t separate them. → First Login & Admin Access
About 180 Worker variables left wrangler.toml. They only repeated SAM’s built-in defaults, so nothing changes when you deploy. If your fork edited one of those lines, syncing will conflict there; keep your value as described in Worker Variables.
Superadmins hear when archiving stops. When a project’s archive circuit breaker opens, every active superadmin gets an Operational Failure notification linking to Admin → Storage, and the hourly storage measurement runs again. → Storage and archive circuit breakers
Agent messages travel over channels on every install. The checked-in wrangler.toml turns on AGENT_MESSAGE_CHANNELS_ENABLED, unless your GitHub Environment sets it to false.
Removed: ACP_TASK_PROMPT_TIMEOUT (long tasks now end only through the inactivity check or the 24-hour limit). If you set it, you can delete it.
New optional settings, with working defaults, for retrying a VM that fails to start (ORIGIN_CA_RETRY_*, ORIGIN_CA_REQUEST_TIMEOUT_MS, CLOUD_INIT_*, TASK_RUNNER_BOOT_MAX_REPLACEMENTS, TASK_RUNNER_FIRST_HEARTBEAT_TIMEOUT_MS; see Fresh VM boot recovery) and for the Connector (CONNECTOR_*; see SAM Connector).
The Pulumi state repair workflow no longer prints raw state. Its export shows resource counts and URNs only. If you ran it before v2026.10.07, delete those workflow runs: their summaries show the start of the raw state, which can include generated keys.

New models

Profiles can now use Claude Haiku 5.5 (1M context) with Claude Code, and with OpenCode Zen and OpenCode Go. SAM’s built-in OpenCode list, which profiles pick from, also adds Exo Free, Step 5 Preview Free, and Mistral Large 4 on Zen and Step 5 Preview Free on Go; on Go, Space Bunny Free is now Space Bunny, and Zen’s Fledge Alpha Free is gone. (Settings → Agents loads OpenCode’s list live from models.dev.) Gemini CLI’s Gemini 3.7 Flash is marked deprecated: Google routes it to 3.8. A profile already set to a model that left the list keeps it, shown as a custom model, so if a profile uses Fledge Alpha Free, or Space Bunny Free on OpenCode Go, choose its model again: OpenCode no longer lists those IDs. See Choosing a model.

Previous cycle: 29 September – 6 October 2026

For everyone

Agents can stop and ask you. When an agent wants permission, has a question, or needs you to open a sign-in link, a card appears in the chat, and the chat is marked Needs input in the session list. Answer on the card; the agent waits until you do. On self-hosted SAM this works once your operator turns it on. Sleep and wake now preserve the request settings of new sessions. → When the Agent Needs You
Claude Code starts in Bypass Permissions. A Claude Code agent with no permission mode set now works without asking, apart from a few safety checks (Codex never asks for permission). The always-ask mode is now called Manual: choose it, or Plan Mode, to approve changes yourself. New sessions keep their resolved mode when they sleep and wake. A mode saved earlier still applies, so if an agent asks when you don’t expect it, check where its mode is set. → Permission mode
See your subscription limits. On a Claude, ChatGPT, or OpenCode Go subscription, a chip under the chat’s title shows how much of each limit is used; select it for reset times. → Usage Limits
Connection problems say what to fix. When an agent’s credential is missing or rejected, or its model isn’t available to your account, the chat names the problem, and for a credential links to the page that fixes it. → The agent or a tool can’t sign in
Resources shows the whole session. The Resources panel draws one timeline across every wake, with zoom, Busiest moments, the running tool’s name when you read a moment, and memory split into what the work used and cache. → Session Resource History
MCP servers can take an API-key header. Add custom HTTP headers to an MCP server — Composio’s x-api-key, for example — in personal or project settings. → Adding a server
A session whose snapshot keeps failing stops trying to sleep. After three failed attempts or 15 minutes, SAM either puts a VM session to sleep on a saved Git checkpoint and says what wasn’t kept, or says it can’t sleep and leaves it running — instead of retrying all day. → SAM could not save a complete snapshot
Copy your own messages. Your messages now have Info and Copy buttons, like the agent’s. → Message Actions
The session list keeps its order. Chats are ordered by their latest message, so archiving or stopping an old chat no longer moves it to the top. → Switching Between Chats
New models. OpenAI GPT-6.1 Sol with Codex, Claude Sonnet 5.5, Gemini 3 Flash Preview, and more OpenCode Zen models. → New models

Also changed this week:

Signing in with GitHub works again. From 23 September to 1 October, signing in from a browser that wasn’t already signed in failed with unable_to_get_user_info. Browsers that were already signed in kept working.
Idle VM sessions go to sleep again. Their snapshots were too large to finish for big repositories, so idle sessions stayed awake and kept their machines running. Snapshots now leave out history that is already on your default branch, and a session awake for more than a day can still save one.
SAM stops nudging a stuck agent. After three check-ins with no progress, SAM pauses its check-ins and posts what to look at, instead of nudging the agent all day. → SAM paused automatic check-ins
A turn that hangs for hours is ended. When a VM task or chat has been awake for more than four hours and the agent’s turn has shown nothing for an hour, SAM checks it, and fails the task if the turn is clearly wedged. Pending requests are protected until their response deadline, and SAM tries to save a stalled task’s workspace before removing it. → SAM ended a stalled turn
A message sent right after you stop the agent goes through. A follow-up sent within about five seconds of stopping a prompt could be killed along with it, failing the task.
A sleeping VM conversation keeps its task. Waking one used to create a new task behind the scenes, so a sub-task could lose its link to the agent that started it. Sleeping tasks now stay on the dashboard’s Active Tasks list, other agents can still message them, and the agent that started one can stop it without waking it.

For self-hosters & admins

Decide on agent requests before you update. Before v2026.10.01, SAM approved every permission request automatically, whatever mode an agent was in. From v2026.10.01 each request goes to the person running the chat — or, unless you turn agent requests on, it is refused, on new and updated installations alike.

Turn agent requests on first, with three GitHub Environment variables (Let agents ask in chat), so the update’s deploy picks them up. If you leave them off, agents need Bypass Permissions, and Amp, Gemini CLI, and Claude Code in a devcontainer that runs as root ask even then.
Update to the newest release (Updating an existing instance). v2026.10.05 is the first where Claude Code agents with no mode set start in Bypass Permissions; on v2026.10.01 to v2026.10.04 they ask, and with requests off are refused every time. The check-in cap, usage chips, the Codex upgrade for GPT-6.1 Sol, and sleeping tasks on Active Tasks arrive in v2026.10.06.
If you left requests off, find the saved modes that will be refused — in profiles, skills, projects’ Agent Overrides, and users’ Settings → Agents, where saving on a release before v2026.10.05 stored the old always-ask default, now shown as Manual. Let agents ask in chat has a query that lists them.

Fresh GitHub sign-ins fail on v2026.09.24 to v2026.10.01 (fixed from v2026.10.02).
Codex questions and links ship with the deploy. Every deploy publishes SAM’s own Codex build to your R2 bucket, and Instant images include it; Codex sessions use it once questions or links are on. No setup.
New limits, with their defaults. The sleep-failure budget, SESSION_SLEEP_FAILURE_MAX_ATTEMPTS (3) and SESSION_SLEEP_FAILURE_MAX_ELAPSED_MS (15 min), can be set as GitHub Environment variables. The rest are read only from [vars] in apps/api/wrangler.toml, so changing one means editing your fork (Worker Variables): check-ins, TASK_RECONCILIATION_MAX_CHECKINS (3); stalled-turn checks, STALLED_TASK_CLASSIFIER_* (Workers AI, on); callback-token renewals, RATE_LIMIT_CALLBACK_TOKEN_RENEWAL (12 an hour); and TASK_RUN_ABSOLUTE_CEILING_SLEEP_GRACE_MS (1 h), the longest the 24-hour runaway-cost ceiling now waits for a sleep that keeps retrying.
Failed snapshot uploads are cleaned up. Uploads from snapshot attempts that can never finish are deleted from R2 instead of piling up. Ones already left behind are not removed.
A project at the 10 GB storage cap can be recovered. A superadmin API frees space by removing the search index of old, finished sessions. → When a project reaches the 10 GB storage cap

Otherwise, updating needs no action: there are no new secrets, and the new database migrations run in the deploy pipeline. TASK_RUN_HARD_TIMEOUT_MS is gone (it had no effect); if you set it, you can delete it.

Agents ask you before they act

Until this cycle, SAM approved every permission request an agent made, whatever its permission mode, so “ask me first” did nothing. Now the request reaches you as a card in the chat: the command or change the agent wants to make, and the agent’s own choices — for Claude Code a command usually offers Yes, Yes, and don’t ask again for …, and No. Agents can also ask a question with a short form (Claude Code’s multiple-choice questions arrive this way), and a tool can send you a sign-in link to open.

Only the person who started the chat can answer, each request has a deadline shown on the card, and an unanswered request counts as a no. No notification is sent: watch for Needs input in the session list.

Because asking is now real, a Claude Code agent with no mode chosen starts in Bypass Permissions. Pick Manual or Plan Mode to approve its changes yourself, or Accept Edits to approve only the commands it runs. See When the Agent Needs You and Permission mode.

See how much of your subscription is left

Claude Max, ChatGPT plans, and OpenCode Go limit how much you can use in five hours, a week, or a month. Until now you found out when the agent hit one and stopped. Now a chip under the chat’s title — for example Claude · 5h 78% · Week 31% — shows how much of each limit is used; select it for reset times. The same chip appears on your credentials in Settings → Advanced, and agents can read the numbers to pause work until a reset. See Usage Limits.

Sleep gives up instead of looping

A session sleeps by saving a snapshot of its workspace. For a large repository that snapshot could never finish, so idle sessions stayed awake, kept their machines running, and retried every few minutes, sometimes for more than a day. Snapshots now leave out history that is already on your default branch, which makes them small again.

If a snapshot still keeps failing, SAM stops after three attempts or 15 minutes. For a VM session whose earlier snapshot saved the repository’s exact commit and uncommitted changes, SAM sleeps the chat on that and says in the chat what wasn’t kept; waking it starts the agent fresh from the transcript. Otherwise — and always for Instant sessions — the chat says SAM couldn’t put it to sleep, and the session keeps running until you act. See SAM could not save a complete snapshot.

Resources shows the whole session

The Resources panel used to show one 15-minute slice at a time, which made it easy to misread a long session. It now draws the whole session as one timeline across every wake, from per-minute summaries, and fetches 5-second detail only when you zoom in. Hover or tap to read a moment, including which tool was running; Busiest moments jumps to the peaks; and memory is split into used (what the work needed) and + cache. See Session Resource History.

New models

Profiles can now use OpenAI GPT-6.1 Sol with Codex (whether your ChatGPT plan can use it is up to OpenAI), Claude Sonnet 5.5 (1M context) with Claude Code, Gemini 3 Flash Preview with Gemini CLI, and GPT-6.1 Sol, Claude Sonnet 5.5, Fledge Alpha Free, and Ling 3.1 Flash Free with OpenCode Zen. SAM also upgraded the Codex it installs, so a profile set to GPT-6.1 Sol starts instead of being rejected. See Choosing a model.

Earlier cycle: 23–29 September 2026

For everyone

A failed task keeps its work. When a task fails while its workspace is still running, SAM snapshots the workspace and puts the chat to sleep instead of deleting it. Reply in the same chat to carry on with the files restored. → When a task fails
Wake failures tell you why. A chat that can’t wake is marked Wake failed in the session list, with a system message giving the reason. → Wake failed
One page for when things go wrong. Session Troubleshooting covers wake failures, failed tasks, machines that stop responding, and interrupted messages, for Instant and VM sessions.
Switching chats no longer waits on the network. Up to 20 recently opened chats open at once from a browser cache, load their newest messages first, and keep your unsent draft while you visit other chats. → Switching Between Chats
The dashboard shows what’s live. Active Tasks shows your six most recently active tasks, instead of every conversation that is still asleep. → Come back later
Silent machines are cleaned up. A VM that stops responding gets a notice in its chats after about 10 minutes and is deleted within about 30, instead of sitting unhealthy — and billed — for hours. → SAM lost contact with the machine
Diagrams and PDFs render properly. Mermaid diagrams are drawn as safe, static pictures; labels that used to be invisible in kanban, mindmap, and timeline diagrams now show; and library PDFs preview in Chrome and Edge. → Diagrams
Agent search finds more. Searches match every word you give them, project-wide search can work through all archived history, and results say when they are partial. → Finding Past Conversations
New models. Claude Opus 5.5; OpenAI GPT-6 Astra, Sol, and Luna, and GPT-5.2; Gemini 3.8 Flash; current Mistral Vibe aliases; and a refreshed OpenCode list. → Choosing a model
Long Instant sessions can still push. git and gh stay signed in to GitHub past the first hour of an Instant session.

Also changed this week:

npm-based agents need Node.js 22 in VM workspaces. Claude Code, Codex, Gemini CLI, OpenCode, and Amp now need Node 22 or newer (up from 20). If a devcontainer has an older Node, SAM installs Node 22 before starting the agent, which can change the node your project uses there. → Choosing an environment size and profile
Waking a sleeping Instant session — whether it fell asleep on its own or you put it to sleep — no longer fails with “The sleeping container runtime is gone and cannot wake in place”.
Messages no longer go missing from very long chats, and a chat you reopen within seconds shows the messages that arrived while it was closed.
A task that finished or was cancelled can no longer be flipped to failed by a late report from its machine, and an agent’s complete_task pull-request link is now saved on the task.
Tasks waiting in the queue for a machine start as soon as one frees up.
An agent that is still making progress on a long job is no longer cancelled, or failed as “Agent became unresponsive after SAM check-in”. An agent that answers a check-in by asking you a question counts as having responded, and stopping a task yourself no longer records it as unresponsive.
On Hetzner, a sleeping VM conversation no longer fails to wake when Hetzner refuses its machine because the account’s vCPU quota is used up. SAM waits for capacity or, in a pool whose exhaustion policy is Fallback chain, tries permitted machines that need fewer cores but still fit the work. A waking VM conversation also prefers the region it last ran in, but can use a healthy machine elsewhere unless a region was pinned.
Editing an agent profile on a phone no longer loses focus or your typing mid-edit, and the Description field is now a multi-line box.

Removed: the legacy per-node workspace caps (maxCoTenants, “max workspaces per node”). The chat’s infrastructure details no longer print “up to N workspaces per node”, and the CLI’s --max-co-tenants flag now fails with an explanation. Machine sharing is decided by CPU, memory, and disk alone — see Compute Pools.

For self-hosters & admins

Clear a stuck archive migration. Admin → Storage lists failed, poisoned, and frozen migrations, with an Abandon button that works from a phone. → Storage and archive circuit breakers
Unresponsive VMs are released. Silent workspace VMs are drained after 10 minutes and deleted within 30; fleet-wide silence holds everything instead. Settings: NODE_UNHEALTHY_*. → Self-Hosting
Model-tier limits are enforced. A per-user allowedModelTiers restriction now actually blocks SAM-mode models outside those tiers, and the native Anthropic route honours AI_PROXY_ALLOWED_MODELS. → Admin AI Allowances
Spending on summaries and voice is capped. Fork/Retry summaries (30 per hour) and voice transcription (30 per minute) are rate-limited per user: RATE_LIMIT_SESSION_SUMMARIZE, RATE_LIMIT_TRANSCRIBE. (Since 9 October, Fork and Retry no longer generate summaries, so RATE_LIMIT_SESSION_SUMMARIZE is gone.)
Setup stops echoing secrets. Saving the /setup wizard no longer returns the platform secrets in its response.
Fewer duplicate error drafts. Automated triage groups recurring errors that differ only in numbers, IDs, or timings into one draft Idea.
Archive drain three times faster. The ProjectData archive sweep claims a session every 20 minutes instead of hourly: PROJECT_DATA_ARCHIVE_GLOBAL_SWEEP_INTERVAL_MS, PROJECT_DATA_ARCHIVE_DAILY_WRITE_BUDGET.
Quieter idle checks. Projects no longer wake every minute to re-check idle workspaces; inconclusive checks back off to six hours: WORKSPACE_IDLE_BACKOFF_BASE_MS, WORKSPACE_IDLE_BACKOFF_MAX_MS.

Updating to any release from this cycle needs no action, though on v2026.09.24 to v2026.10.01 signing in with GitHub fails in a browser that isn’t already signed in, so update to v2026.10.02 or later instead. There are no new secrets or bindings, and the new database migrations run in the deploy pipeline. Two things are worth a look. A PROJECT_DATA_ARCHIVE_GLOBAL_SWEEP_INTERVAL_MS or PROJECT_DATA_ARCHIVE_DAILY_WRITE_BUDGET variable in your GitHub Environment overrides the faster archive defaults. And if you set MAX_WORKSPACES_PER_NODE anywhere, it has no effect and can be deleted: machines are shared by CPU, memory, and disk alone.

A failed task no longer throws its work away

A task can fail for reasons that have nothing to do with the work itself: the provider’s usage limit ran out, or a question the agent asked you expired. Until now SAM deleted the workspace on the spot, taking uncommitted changes with it.

Now the failure goes through the same sleep path as a finished task. SAM lets the agent’s current turn end, snapshots the workspace, and puts the chat to sleep. The failure card stays, but so does the composer: reply, and the same chat wakes with its files restored. Reply rather than using Retry, which starts a new chat without them. When SAM can’t keep the workspace, the chat says so and why.

See When a task fails.

When a chat can’t wake, it says why

A wake that failed used to disappear into retry state: you sent a message to a sleeping chat, and nothing happened. Now the chat gets a system message starting Wake failed: with the reason, and the session list marks it Wake failed in red until you reply.

The reason decides what to do next. Most causes you can fix, then send your message again: a removed cloud credential, a compute pool that no longer allows a matching machine, a wake still waiting for server capacity when your message’s hour ran out, or a burst of failed attempts that clears after 15 minutes. A few mean the saved session can’t be restored, such as an expired snapshot, and then the answer is to fork the chat. Wake failed covers each reason.

Switching chats no longer waits on the network

Moving between chats in a project used to leave the previous chat on screen while the next one loaded, and a chat you had left for five minutes was fetched from scratch — up to 50,000 messages.

Now up to 20 chats you opened in the last 24 hours paint immediately from a cache in your browser and refresh in the background. Every chat opens on its newest 500 messages; scroll up, or select Load earlier messages, for older history, and jumping to a comment or timeline entry loads what it needs. An unsent message stays with its chat while you look at others. The cache belongs to your account and is deleted when you sign out.

See Switching Between Chats.

The dashboard shows what you’re actually working on

A conversation stays active while it sleeps, so it can be woken for up to a week. The dashboard’s Active Tasks list used to show all of them — dozens of dormant conversations burying the two that were running.

It now shows your six most recently active tasks, ranked by their latest message, with a dot that reads Active, Working, Idle, or Sleeping. A task you just submitted ranks by when it started, so it isn’t pushed off by older conversations. See Come back later.

Machines that stop responding are released

A VM could lose contact with SAM and sit marked unhealthy for hours: no new work landed on it, its agents could not report back, and it still counted against your provider quota until someone deleted it by hand.

Now SAM acts on the silence. After about 10 minutes every chat on the machine gets a message starting “SAM lost contact with node” and SAM asks those sessions to sleep. It deletes the machine once they are all asleep, or after about 30 minutes at the latest, and fails any task still running there, naming the lost node. A node you delete yourself cancels its tasks instead of failing them. This covers the cloud VMs SAM runs for workspaces, including ones created from the Nodes page; machines you enrolled yourself are left alone.

See SAM lost contact with the machine.

Diagrams render safely, and PDFs preview in Chrome

Agents write the diagrams and files you open, so SAM now treats everything it renders from them as untrusted. Mermaid diagrams in chat and in markdown files are drawn with plain SVG text and cleaned before they reach the page, so a diagram cannot run code or switch HTML back on through its own settings. A side effect is legibility: labels that were invisible in kanban, mindmap, and timeline diagrams now show, and wrapped labels read as whole words to screen readers and find-in-page. Math, Venn member lists, and architecture-diagram text icons need HTML labels, so their text no longer appears.

Library PDFs now open in the browser’s own PDF viewer in Chrome and Edge too; before, Chromium refused to show them.

See Diagrams and Security.

Search handles long questions and the whole archive

Ask an agent to find an old discussion and it now searches for every word you give it. A long question used to fail outright; now it works, though a few distinctive words still find more. Project-wide search can work through every archived conversation in pages instead of stopping at a fixed number, and each result says when it is partial, so “nothing found” in a very large project is no longer mistaken for proof.

See Finding Past Conversations.

New models in the picker

Profiles can now use Claude Opus 5.5 (1M-token context); OpenAI’s GPT-6 Astra, Sol, and Luna, and GPT-5.2, with Codex; Gemini 3.8 Flash with Gemini CLI; and Mistral’s current -latest aliases with Vibe. SAM also updated the agents it installs so Opus 5.5 runs instead of being rejected by an older Claude Code. Several older OpenAI models are no longer listed for Codex — o3, o4-mini, GPT-4.1 and 4.1 mini, GPT-5 mini, GPT-5.3 Codex, GPT-5.4 Pro and Nano, and GPT-5.5 Pro. A profile already set to one keeps its setting, shown as a custom model.

If a model you want isn’t in the list yet, type its ID — see Choosing a model.

Earlier cycle: 16–23 September 2026

For everyone

Change	What users notice	Where to use it
Sessions show what they used	A Resources panel with CPU, memory, and I/O history for a session — including whether it was killed for running out of memory — that outlives the machine.	Session tool rail → Resources; Session Resource History
Long tool runs stop burying the chat	A run of consecutive tool calls folds into one card reading “N tool calls”. Tap to expand; failures are counted in the text.	Project chat and workspace chat; Tool Activity Cards
Events sit next to the conversation	The old “Events & schedules” header link became an Events button in the session tool rail that opens a drawer over the chat. The project Events page gained counts, state colours, empty states, and self-refreshing schedules.	Session tool rail → Events; Project → Events
Sleeping chats are searchable	An agent asked to search the project now finds work in sessions that are asleep, not just ones that were stopped — which is most of your recent work.	`search_messages` (agent tool); not the chat-list search box
Wake puts you back on the same commit	A woken session restores the exact saved Git checkout — commit, branch, upstream, working tree, index, and clean local-only commits — or reports degraded recovery instead of quietly continuing somewhere else.	Any sleeping session
One pool, two placement strategies	A compute pool now orders workspace machines and app-deployment machines separately, with a cap on how many nodes Spread may open per user.	Project → Settings → Infrastructure; Compute Pools
Deployment size comes from the manifest	The CPU and memory limits in your Compose services decide which machine a deployment lands on. Environment names do not.	App Deployments

For self-hosters & admins

Change	What it enables	Where to configure it
One-click instance updates	An Update Self-Hosted Instance workflow fetches the latest upstream release, fast-forwards your fork, and deploys. Deploy Production’s commit SHA input is now optional.	Actions → Update Self-Hosted Instance
Dated releases to update to	Upstream tags the latest successful production deploy daily as `vYYYY.MM.DD`, so “update to a known release” is a real option.	GitHub releases on the upstream repository
Storage controls in the admin UI	Admin → Storage lists per-project storage telemetry and archive circuit breakers, with a Close breaker button that works from a phone.	Admin → Storage
Errored deployments recover	An environment parked in `error` is visible to agent deploy tools again, so a new release can bring it back without manual database surgery.	Deployment environments

A session can now tell you what it used

Until now, “the agent died and I don’t know why” had no answer you could check. Every VM-backed workspace now records CPU, memory, disk I/O, and out-of-memory events, and keeps that record for months after the machine is gone. Open Resources in the session tool rail to read it — the amber OOM banner at the top is usually the whole answer.

Session Resource History covers how to read the timeline, how to turn a CPU peak into “how many cores was that”, what the numbers deliberately cannot tell you, and why Instant sessions have no history at all.

Long tool runs no longer bury the conversation

A typical agent turn is a sentence, then thirty tool calls, then another sentence. Rendering every call as its own card pushed the agent’s actual words off the screen.

Consecutive tool calls now fold into a single compact card reading, for example, 18 tool calls. While the run is live the card shows what is executing right now; when it ends, failures are named in the text (18 tool calls · 2 failed). Tap the card to expand the individual calls, tap a call to load its output. Nothing is fetched until you ask for it, so a 40-call run costs nothing to scroll past. Documents an agent shares are never hidden inside a card. The same grouping applies in the standalone workspace chat, not only project chat.

See Tool Activity Cards.

Events moved next to the conversation

Session events used to hang off a small “Events & schedules” link in the chat header — easy to miss, and it navigated you away from the chat to find out what was scheduled against it.

There is now an Events button in the session tool rail that opens a drawer over the conversation, with Subscriptions, Schedules, and Watches for that session, and a View full page link when you want the project-wide view.

The project Events page got the same attention: each section carries an icon and a live count, schedules refresh themselves every 30 seconds while you are looking at them, state badges are colour-coded consistently with the admin inspector, and each empty section explains what would appear there instead of looking like a failed load.

See Scheduled actions and event watches.

Search reaches sleeping sessions

SAM’s chat search indexes conversations by stitching streaming tokens back into whole messages. That pass used to run only when a session stopped, failed, or was cleaned up after going idle — which excluded sleeping sessions, and sleeping is where most of your recent work lives.

The pass now also runs when a session goes to sleep, and it is incremental: each pass reads only what was written since the last one, so indexing a long-running session stays cheap and a session that sleeps and wakes repeatedly does not lose the messages in between. User messages written since the last pass stay reachable through keyword fallback; streaming agent output is only searchable once a pass has run.

Search got narrower in the same week too, and it is worth knowing: under storage pressure SAM now prunes the search index for old terminal sessions to reclaim space, and a pruned session is never re-indexed. See Finding Past Conversations.

Waking puts you back on the exact same commit

A snapshot used to capture the working tree and index. It now captures the Git state: the saved HEAD commit, whether you were on a branch or detached, the canonical upstream metadata, the index, the working tree, and any clean local-only commits.

Restore verifies the result. If SAM cannot recreate the saved commit and ref state, the wake reports degraded recovery rather than silently continuing on a different commit — which is the failure mode that quietly loses work, because everything looks fine until you push.

Plan for one trade-off: the repository bundle is captured first out of a shared snapshot budget (256 MiB by default), so a big working tree can crowd out the agent’s own HOME state. Only commits reachable from the saved HEAD are bundled, so work parked on another local branch is not captured. If a session carries work you cannot lose, have the agent commit and push it.

Update, October 2026: the bundle no longer carries history that is already on your default branch. That history is fetched from origin on wake, so repository history alone no longer crowds out HOME.

See Instant Sessions → What gets restored.

One compute pool, two placement strategies

Agent workspaces are bursty and short-lived; app deployments are steady and long-lived. Ordering machines the same way for both was always a compromise.

A pool now has a Workspace strategy (default Balanced) and a Deployment strategy (default Smallest fit), plus Maximum nodes per user — the point at which Spread stops opening machines and starts packing, and a hard ceiling on managed workspace nodes under every strategy. The credentials, allowed offerings, providers and regions stay shared: you curate one list of machines and only the ordering differs by workload.

Deployment sizing is now driven by the deploy.resources.limits you declare per service in your Compose manifest, summed across services. Environment names carry no weight — naming something production does not buy it a larger machine than preview. SAM reuses a compatible deployment node when the declared reservation fits, and otherwise provisions the smallest allowed machine that can hold it.

Packing itself moved onto explicit resources at the same time. The legacy workspace-count and memory-percentage gates no longer decide placement; declared CPU, memory, and disk reservations do, with disk pressure and CPU saturation as backstops.

See Compute Pools and App Deployments.

Updating a self-hosted instance is one workflow

Updating a fork used to mean syncing main, finding the exact 40-character SHA at the new tip, and pasting it into Deploy Production — a step that was easy to get wrong and impossible from a phone.

Run Actions → Update Self-Hosted Instance instead. Leave release as latest (or name a vYYYY.MM.DD tag), and the workflow fast-forwards your fork’s main to that release and triggers the production deploy. Upstream now tags the latest successful production deployment daily, so those release tags exist to point at. If your fork carries local commits the fast-forward fails loudly rather than doing something surprising — merge manually and use Deploy Production, whose target_commit_sha input is now optional and defaults to your current main tip.

See Self-Hosting → Updating an Existing Self-Hosted Instance.

Admins get a Storage page

When a project’s archive drain fails repeatedly its circuit breaker opens and archiving for that project stops until someone closes it. Nothing closes it automatically, and until now closing it meant a hand-rolled superadmin API call from a desktop browser — so a stopped drain could stay stopped long after the underlying bug was fixed.

Admin → Storage now lists storage telemetry and breaker state — the heaviest projects and any open breakers, not an exhaustive list — with a Close breaker button that works on a phone. Closing a breaker resumes the scheduled sweep for that project; it does not thaw migrations that were already frozen.

See Self-Hosting → Storage and archive circuit breakers.

Earlier cycle: to 15 September 2026

For everyone

Change	What users notice	Where to use it
Comments have somewhere to look	A Comments page in the project nav collects every thread from chat and the library in one place, grouped by whether it is waiting on you. Chat sessions gain a matching count chip and a comments drawer.	Project → Comments; chat session tool rail
Report an issue in-app	A Report button in the session tool rail, and a Report this issue link on the crash screen. You choose whether to attach technical context.	Session tool rail; crash screen
Sessions survive runtime teardown	Sleeping Instant and VM sessions wake from a seven-day snapshot instead of losing harness context or uncommitted work.	Project chat
Starting a chat is durable	Closing the tab while a chat is starting no longer strands it — the launch finishes server-side.	Project chat
Work lands on its own branch	Task workspaces start checked out on the task’s `sam/…` output branch, and publication is agent-directed.	Submitted tasks and agent-dispatched work
Codex has its tools on Instant	Codex sessions on the Instant runtime now get SAM’s MCP tools instead of silently starting without them.	Any Codex profile
Library cards always render	A document an agent shares renders as a rich card no matter which agent sent it.	Project chat timeline
Machines come from a compute pool	Workspaces are provisioned from the exact provider instance types your compute pool allows, and work states what it needs in vCPU, memory, and disk instead of a small/medium/large label.	Project → Settings → Infrastructure; Compute Pools

For self-hosters & admins

Change	What it enables	Where to configure it
In-app issue reporting	Route user reports into a project you watch. The feature stays hidden until you configure it.	Admin → Integrations, with `PLATFORM_FEEDBACK_PROJECT_ID` fallback
Automated error triage	SAM groups recent platform errors hourly and files deduplicated draft Ideas for them.	`PLATFORM_FEEDBACK_TRIAGE_*`
Deployment diagnosis agent	Superadmins can hand an error — or a whole time window — to an AI agent from Admin → Errors, and save the result as a draft Idea.	`DEBUG_AGENT_*`
Durable diagnosis runs	A diagnosis keeps running if you close the tab, with a runs list, status, and retry.	Admin → Errors
Canonical compute pools	Project, user, and installation pools are reconciled from each credential’s live provider catalog, with a placement strategy and an exhaustion policy per pool.	Project/Settings/Admin → Infrastructure; `CAPACITY_POOL_*`

Report an issue without leaving SAM

When an agent misbehaves or a page crashes, you can file a report from where you are. Click Report in the session tool rail on the right edge of the chat, or use Report this issue on the crash screen.

SAM never attaches technical context silently. A consent checkbox lists the exact identifiers it would send — chat session, task, node, error, diagnosis — so you can see them before submitting. Leave it unchecked and only your words are sent. Server-side, references you don’t have access to are dropped, and credential-shaped strings and email addresses are redacted from your text.

Reports become draft Ideas in a project the deployment nominates. If you don’t see a Report button, this deployment hasn’t configured one. See Reporting Issues.

Persistent sessions recover from runtime loss

Persistent sessions now use the same snapshot contract on Instant containers and standard VM workspaces. SAM checkpoints after idle turns and requires a verified final checkpoint before sleep. The snapshot contains the agent’s home directory (including harness session state) and repository work in progress, so a replacement runtime can resume instead of starting blank. Credential files are deliberately excluded and re-provisioned fresh on restore.

VM compute is stopped after a successful sleep checkpoint and may be deleted normally. Users can also put an awake idle conversation-mode session with a workspace to sleep manually from the chat lifecycle control; task-mode sessions keep their task completion lifecycle. A same-chat follow-up atomically provisions one replacement workspace, restores the exact saved harness session, then delivers the queued message. Explicit archive remains destructive, appears after the reversible sleep boundary, and sleeping state expires after seven days.

What you actually see:

A spinner reading “Waking and restoring Instant session…” — a wake or restore is under way. Wait rather than resending.
A message that says your prompt was saved but its outcome is unknown — SAM deliberately does not replay it, because replaying a half-executed prompt duplicates commits and PRs. Read the transcript first, then decide whether to resend.
A terminal stopped state, which closes the composer instead of offering retries against a runtime that can never come back.

Starting an Instant chat is now durable too: SAM accepts the session first and finishes the launch in the background, so closing the tab partway through no longer leaves a chat stuck in a queued state.

Machines come from a compute pool

SAM no longer derives hardware from a small / medium / large label. Each scope — project, user, and installation — has a compute pool: the concrete provider instance types SAM is allowed to rent, discovered from your provider’s live catalog. Work states what it needs (vCPU, memory, disk, and optionally an exclusive machine) and SAM picks a permitted machine that satisfies it.

Two per-pool settings decide the rest: a strategy (balanced, pack, spread, or smallest fit) for which permitted machine wins, and an exhaustion policy (queue, fail, or fallback chain) for what happens when your provider has nothing to give. Legacy size labels still work and are translated for you.

See Compute Pools.

Agent work lands on its own branch

Task workspaces are now checked out on the task’s sam/… output branch from the moment they’re created — cloned from your default branch, then switched. This gives the agent a branch to work on; creating that branch does not publish changes or open a pull request. Ask the agent to commit, push and open a PR when you want to publish.

SAM no longer stages, commits, pushes or creates pull requests at turn end or task completion. Agents publish explicitly; independent sleep snapshots preserve supported workspace files and local commits. Keep repository branch protection rules for agent-directed pushes.

See Where the work lands.

Codex gets its tools on the Instant runtime

Codex sessions running on the Instant runtime never received SAM’s MCP configuration, so they started with no SAM tools at all and couldn’t call get_instructions, dispatch_task, or anything else. They now get it on every runtime. A Codex session that cannot be given a valid MCP token now fails to start with an explicit error instead of quietly launching a tool-less agent.

Superadmins can ask an agent to diagnose errors

Admin → Errors can hand a single error, or a whole filtered window, to an AI agent that reads bounded, redacted evidence and writes an analysis — with the model, turn count, and token usage against a daily budget shown alongside. Useful diagnoses can be saved as draft Ideas so they become tracked work.

Runs are durable: closing the tab doesn’t kill one, a Recent diagnosis runs card shows status, and failed runs can be retried. Separately, SAM runs this same agent automatically once an hour over recent platform errors and files deduplicated draft Ideas.

Before anything reaches the model, SAM strips user IDs, IP addresses, user-agent strings, and credential-shaped values. See Reporting Issues → For superadmins.

Earlier changes

For everyone

Change	What users notice	Where to use it
Guided subscription sign-in	Connect Claude Code or OpenAI Codex to your Claude Max/Pro or ChatGPT subscription with a browser sign-in — no terminal, no token paste.	Settings → Connections
More cloud providers	Bring your own Vultr, DigitalOcean, UpCloud, or Infomaniak account, alongside Hetzner, Scaleway, and Google Cloud.	Settings → Connections
Claude Fable 5.1	Pick Anthropic’s newest frontier model (1M-token context) when you configure an agent profile.	Agent profile model picker
Markdown previews in the library	Markdown an agent saves to a project now renders inline instead of downloading as a file.	Project chat & library
Shared projects & roles	Invite teammates with a link, approve access requests, and share profiles, skills, and secrets. Approved teammates join as admins.	Project Settings → Access
Credential attribution	A Credentials indicator shows which shared work runs on personal keys versus project credentials.	Project navigation (shared projects)
GitLab repository workspaces	Connect a GitLab repository, not only GitHub.	New-project setup, repository step
Project Files	Inspect a branch’s file tree and diff without opening a VM.	Project Files tab
Forkable, task-backed chats	Any chat can be forked, archived, and tracked with task lifecycle behavior.	Project chat sessions
Focus Mode sidebars	Collapse navigation and session sidebars for more room while chatting.	Project chat (desktop)
GitHub event triggers	GitHub issues, comments, pull requests, and pushes can start SAM work.	Project Triggers page
Generic webhook triggers	Any external service can start SAM work by sending an authenticated JSON webhook.	Project Triggers page
GCP for provisioning	Connect Google Cloud with Workload Identity Federation or a service-account JSON key to provision VMs.	Settings → Connections
Deployment custom domains	Attach your own subdomain to a deployed app; SAM verifies DNS and activates the route without a full redeploy.	Deployment environment Domains tab
Cleaner injected system context	SAM-injected bootstrap/context messages are collapsed so the chat reads like user-agent conversation.	Chat timeline

For self-hosters & admins

Change	What it enables	Where to configure it
First-run setup wizard	Configure platform integrations after deploy instead of pre-seeding secrets.	`/setup` on a fresh deployment
Namespaced self-host domains	Run multiple SAM installations in one Cloudflare zone without hostname collisions.	Self-host deploy config (`RESOURCE_PREFIX`)
Default instant container runtime	New deployments use Cloudflare Containers for instant sessions by default.	Self-host deploy config (`CF_CONTAINER_ENABLED`)

Connect a subscription without a terminal

Connecting Claude Code or OpenAI Codex to a paid subscription used to mean running claude setup-token or pasting the contents of ~/.codex/auth.json — steps that are awkward on mobile and impossible without a local terminal. There’s now a guided sign-in: choose Connect with Claude Code or Connect with Codex and open the provider’s sign-in page. Codex uses the short code SAM displays; Claude displays a code#state value that you paste back into SAM. The panel connects itself once the provider confirms.

The manual token/auth.json fields are still there as a fallback, but you no longer need them for the common case. See Connecting a subscription with guided sign-in.

More clouds to bring your own compute

SAM’s Bring-Your-Own-Cloud model now spans seven providers. Vultr, DigitalOcean, UpCloud, and Infomaniak Public Cloud join the existing Hetzner, Scaleway, and Google Cloud support. Each provider brings its own regions and pricing, so you can put workspaces close to you or on the account you already pay for.

Connect one under Settings → Connections: pick a provider, follow the linked console to create a credential, and paste it in. See Bring Your Own Cloud for the full provider table and User VM Costs for per-provider sizes and example pricing.

SAM resolves compute through project, personal, then platform/installation credentials. If none of those are available for your workspace, use an agent profile set to the Instant container runtime — see Instant Sessions.

Infrastructure Compute Pools now expose the concrete provider-native catalog behind those credentials. Project, personal, and installation pools can be reconciled from the full provider catalog, then edited by adding or removing specific instance types and filtering by provider, location, vCPU, memory, and price. Removed entries stay removed until you add them back, and old small/medium/large presets are only used as migration hints for older profiles rather than as the editing catalog.

Claude Fable 5.1 is available

Anthropic’s Claude Fable 5.1 — a frontier model with a 1M-token context window — is now selectable for Claude Code (and through the SAM AI proxy). Choose it in an agent profile: the model you set on a profile is the model that runs when you pick that profile for a chat or attach it to a trigger.

Agent-generated markdown previews in place

When an agent saves a Markdown file to a project’s library — a written report, a plan, a summary — it now renders inline in the chat and file views instead of downloading as a raw file. This is especially useful for instant-container sessions, where those files previously arrived as undifferentiated application/octet-stream downloads. Other agent-generated text files (.txt, .yaml, .csv, and similar) now carry their correct type too, so they download as the right kind of file instead of an opaque blob.

Projects can be shared with a team

A project is no longer single-player. Any member can create an invite link; recipients open it and request access; an owner or admin approves. Members then share the project’s agent profiles, skills, environment variables, secrets, and files, and everyone’s chat sessions appear in one list with a my sessions / all sessions filter.

Two things make shared projects safe to adopt:

Roles — every project has one owner; everyone you approve joins as an admin with full project control except transferring ownership and deleting the project. Invite only people you trust.
Credential attribution — a Credentials indicator in the project navigation shows which shared resources still run on someone’s personal keys, with a Fix link to attach a project-level credential instead.

See the Collaboration & Shared Projects guide for the full flow, including ownership transfer and member offboarding.

GitLab repositories can create workspaces

SAM now supports GitLab repository-backed projects alongside GitHub-backed projects. From a user’s perspective, this means repository selection and workspace creation are no longer GitHub-only concepts: if the platform admin has configured GitLab OAuth, users can connect a GitLab repository and start agent work against it.

For users, the important behavior is:

Pick the GitLab repository when creating or configuring a project.
Start a chat or task as usual.
SAM passes the GitLab repository metadata through workspace provisioning, instant container sessions, and the VM agent credential helper so the agent can clone and work with the repository.

For self-hosted administrators, GitLab must be configured as a platform integration before users can connect GitLab repositories. See Self-Hosting Guide.

Review branches before opening a workspace

The project Files tab is now a branch browser and diff viewer. This changes the review loop: you can inspect what an agent changed from the browser, including on mobile, before deciding whether to open a workspace.

Recommended workflow:

Open the project.
Go to Files.
Select the agent’s output branch.
Start in Changes to review the diff against the default branch.
Switch to Browse when you need the full file context.

See Project Files for details.

Chats are task-backed and easier to fork

SAM now treats chat sessions as task-backed work, including conversation-style and instant-container sessions. The practical result is that chat sessions have more consistent lifecycle behavior:

You can fork from a chat even when it did not start as a traditional task.
Archive and completion controls apply consistently to the underlying work.
SAM can preserve session lineage and task status across more paths.

See Conversation Forking.

The chat surface is less noisy

SAM injects project instructions, policy, and platform context so agents start with the right operating constraints. Those injected messages are now marked as system-origin context and collapsed in the timeline. Users still get the benefit of the context, but the visible conversation is less dominated by platform boilerplate.

If you are debugging an agent session, expand the collapsed system context before assuming the agent did not receive instructions.

Focus Mode gives chat more room

On desktop, the project chat UI now supports collapsible navigation and session sidebars. Use this when you want to stay in a long agent session, compare file output, or read streaming messages without the surrounding project chrome taking over the screen.

The intended mental model:

Normal layout is for switching projects, sessions, and settings.
Focus Mode is for staying with one session.
Zen-style collapsed sidebars are for maximum reading and prompt-writing space.

Triggers: schedules, GitHub events, and webhooks

Project triggers now run from three sources: schedules (cron), GitHub events, and authenticated webhooks. A project can start agent work when matching GitHub issues, issue comments, pull requests, or pushes arrive — or when any external service sends an authenticated JSON webhook to SAM. See Webhook Triggers for the webhook source.

For GitHub events specifically, use this from the project Triggers page:

Create a trigger.
Choose a GitHub event type.
Add filters such as labels, branches, ignored actors, command prefixes, or draft-PR handling.
Write the prompt template the agent should receive when the event matches.
Choose the agent profile, task mode, and concurrency behavior.

Prompt templates can include event fields such as the actor, repository, issue or PR number, title, body, comment, labels, branch, and SHA. Keep the prompt explicit about what the agent should inspect or change; webhook-triggered tasks are only as useful as the context the trigger passes in.

Self-host setup moved more configuration into the app

Fresh self-hosted deployments can be bootstrapped with only the deployment-critical Cloudflare and Pulumi inputs. After deploy, the /setup wizard accepts the one-time setup token and stores platform integration settings in SAM’s encrypted database-backed configuration.

This improves the first-run path:

Deploy the infrastructure.
Copy the setup token from the Cloudflare dashboard link printed by the workflow.
Open /setup.
Configure GitHub App, GitHub login OAuth, and Google login OAuth.
Rotate or update those values later from the superadmin platform configuration UI.

See Self-Hosting Guide.

Self-hosted domains are namespaced

SAM self-hosting now derives a Cloudflare resource namespace from the base domain. The goal is to prevent collisions between Worker names, DNS hostnames, storage resources, and VM/deployment routes.

For a single installation, use the generated RESOURCE_PREFIX from the setup flow instead of inventing one. If you later run multiple installations in the same Cloudflare account and zone, each installation needs its own explicit namespace so app, API, workspace, port, VM, and deployment hostnames remain distinct.

See Self-Hosting Guide.

Deployed apps can use your own domain

When SAM hosts an app deployment, each public route gets a SAM-owned hostname. You can now attach your own subdomain to that route from the deployment environment’s Domains tab: SAM shows the exact CNAME target, verifies it over DNS-over-HTTPS, and then activates the custom hostname on the running app without a full redeploy — verification queues a route-only update and TLS is provisioned automatically.

The Domains tab now shows each domain’s live state (waiting for DNS, routing, serving, inactive, deactivating, or recheck-required), and saved domains stay visible even when the environment is stopped, so you don’t lose your DNS setup across a stop/start. See App Deployments → Custom domains.

Instant sessions use Cloudflare Containers by default

New self-hosted deployments default CF_CONTAINER_ENABLED to true. That means matching instant-session profiles can start on Cloudflare Containers instead of provisioning a full cloud VM first.

What users notice:

Lightweight conversations can start faster.
Sessions can sleep and wake while preserving enough state for the agent to continue.
Long-running or full-devcontainer work still uses VM-backed workspaces when that is the selected profile or runtime path.

If your deployment cannot use Cloudflare Containers, set CF_CONTAINER_ENABLED=false in the GitHub Environment before deploying. See Instant Sessions.