langsmith-sandboxes: keep free_while_idle false, refresh last_verified
Nothing in the data changed. The event wanted free_while_idle flipped to true for LangSmith Sandboxes, and I fetched the three cited pages before deciding. LangChain's pricing page (https://www.langchain.com/pricing) bills sandbox storage at 0.000123 LSU per GiB-hour, with all rates billed per second and no exemption for stopped sandboxes, and the SDK docs (https://docs.langchain.com/langsmith/sandbox-sdk) show a stopped sandbox keeps its filesystem until a deletion sweep that typically fires 14 days after the stop, so a stopped sandbox can still accrue charges. The GA announcement (https://www.langchain.com/blog/langsmith-sandboxes-generally-available) says idle sandboxes pause so you don't pay for resources that are doing anything; that launch-post sentence never states a stopped sandbox costs nothing, and the event's own reasoning concedes the sources don't detail retained-storage charges. I kept free_while_idle false and refreshed last_verified to 2026-10-28. All three citation URLs were already in sources, so the list is unchanged.
agent-compute-engine: keep free_while_idle and usage_billed null
agent-compute-engine: keep free_while_idle and usage_billed null
The event proposed setting free_while_idle and usage_billed to true for Google Cloud Agent Compute Engine, citing the deep dive's sentence that idle sessions scale down to near-zero active compute and that you don't pay for idle VMs. I fetched the cited post and confirmed the sentence appears verbatim. I left both fields null. Google scopes the claim to interactive and enterprise agents, and the same post states its design goal as an idle agent that costs almost nothing, which falls short of saying a sleeping sandbox costs nothing; ACE is also still pre-preview, and Google has published no pricing for it. The page says nothing about how running sessions are metered, and Beam, Daytona, and Islo all cost nothing while idle yet bill reserved capacity while running, so the idle clause cannot settle usage_billed either. The cited URL was already in the file's sources, and I verified both listed sources today, so the only change is the last_verified date.
agent-substrate: keep usage_billed false; GKE bills reserved nodes
The event proposed setting usage_billed to true, quoting the GKE About page: idle agents are suspended and use no CPU or memory, so you pay for compute only when agents actively process tasks. I fetched the page and the sentence is there, but it sits in a benefits list about running more agents on fewer shared Workers, not in a pricing statement. The provider's pricing pages govern: the install page says Agent Substrate on GKE is offered at no extra charge with GKE pricing applying to created resources, and the GKE pricing page bills Standard node pools for their underlying Compute Engine instances until the nodes are deleted. Agent Substrate on GKE runs on Standard clusters, so the bill follows reserved node capacity rather than active agent use, which is the false case for this field. The 2026-10-26 turn weighed this same sentence and set it aside for the same reason, and the event cites no new source. I left data/providers/agent-substrate.json unchanged, so usage_billed stays false and last_verified stays 2026-10-27; the cited URL was already in sources. Verified today against https://docs.cloud.google.com/kubernetes-engine/ai-ml/about-agent-substrate, https://docs.cloud.google.com/kubernetes-engine/ai-ml/install-overview-substrate, and https://cloud.google.com/kubernetes-engine/pricing.
nvidia-openshell: no change; Rust SDK still documented
nvidia-openshell: no change; Rust SDK still documented
The event proposed dropping Rust from the sdks field, saying the OpenShell repository now lists only Python, TypeScript, and Go. The cited pages do not support that. The SDKs table in the repository README (https://github.com/NVIDIA/OpenShell) still has four rows, Python, TypeScript, Go, and Rust, with Rust installed by cargo add openshell-sdk, and the second citation, https://docs.nvidia.com/openshell/latest/sdks.md, returns a Page Not Found page. NVIDIA's Rust SDK docs also remain live at https://docs.nvidia.com/openshell/sdk/rust.md. I left data/providers/nvidia-openshell.json unchanged, so sdks stays Python, TypeScript, Go, and Rust, and I added no sources.
Beam: kept isolation value; refreshed last_verified only
Beam: kept isolation value; refreshed last_verified only
The event proposed rewording Beam's isolation to "Container isolated with gVisor". I verified both cited pages: the sandbox overview describes a sandbox as "a container you control through process, filesystem, networking, and snapshot APIs", and Beam's blog states "Beam runs each sandbox under gVisor" and lists Beam's isolation as "gVisor + runc" in its comparison table. The file already records "gVisor + runc", the exact table value from that same blog, so the proposal is an equally supported rewording rather than a better-sourced change and the field stays unchanged. Both citation URLs (docs.beam.cloud/v2/sandbox/overview and www.beam.cloud/blog/mcp-server-sandbox) were already in sources, so nothing was added. last_verified moved to 2026-10-28 after verification.
aws-agentcore-runtime: wake_on_request already true, no data change
aws-agentcore-runtime: wake_on_request already true, no data change
The event proposes wake_on_request: true, and
data/providers/aws-agentcore-runtime.json already records true, so I edited
no field. I fetched both cited pages and each states the claimed behavior:
the Runtime sessions doc says a stopped session "transitions back to Active
on the next invocation and a new compute is provisioned", and the Instances
doc says to "invoke the runtime again with the same runtimeSessionId" to
resume a stopped session. Both citation URLs were already in sources, and
last_verified already read 2026-10-28. This is a redelivery of the same
event (mevt_771e216b) that commit 08790a3 handled at 17:18, and that turn's
changelog entry never got written, which left the monitor free to send it
again. One caveat: both pages describe resumption through a runtime
invocation that provisions new compute, and neither page mentions a sandbox
waking on inbound network traffic.
runwork: cold start cites Blaxel's under-1 s sandbox spin-up claim
runwork: cold start cites Blaxel's under-1 s sandbox spin-up claim
Updated cold_start in data/providers/runwork.json from the old 2-3 s
environment boot (Blaxel's Runwork case study) to "Resume: <25 ms; fresh
sandbox: <1 s (Blaxel claim)". I fetched the three cited pages and each states
the claimed figure: the pricing page says "Spin up your first sandbox in under
a second", the sandbox docs say sandboxes "resume from standby in under 25
milliseconds", and the case study says a triggered sandbox resumes in less
than 25 ms. Blaxel's pricing page and docs outrank the blog case study under
the data rules, so the under-1 s spin-up claim replaces the case study's
2-3 s figure. Added https://blaxel.ai/pricing.html to sources, set
last_verified to 2026-10-28, and left every other field alone because the
event proposed no changes to them.
fly-io-sprites: event values already on file; price and SDKs verified
fly-io-sprites: event values already on file; price and SDKs verified
The event proposed a compute price of $0.0385 per CPU-hour with memory at
$0.021875 per GB-hour, plus an SDK list that adds Elixir. I fetched the cited
pages: https://fly.io/pricing/ lists both rates under Sprites compute, and
https://fly.io/sprites/ shows JavaScript, Go, Elixir, and Python quickstarts.
The data file already carried every one of these values, so I changed no
field; I bumped last_verified to 2026-10-28, and both citation URLs were
already in sources. The Sprites page never mentions TypeScript, so the
TypeScript part of the file's JavaScript/TypeScript entry rests on the
sprites-js repository (https://github.com/superfly/sprites-js), which the
file already cites.
opencomputer: no field changes; GPU source added, cited docs 404
opencomputer: no field changes; GPU source added, cited docs 404
The event proposed three updates for OpenComputer, and only one survives verification. OpenComputer's own E2B alternatives guide states "OpenComputer has no GPUs", which confirms the gpu: false value already recorded in data/providers/opencomputer.json, so I added https://opencomputer.dev/guides/e2b-alternatives/ to sources and set last_verified to 2026-10-28. The other two proposals, a cold_start rewrite ("Create: ~300 ms; wake: typically sub-second") and wake_on_request: true, cite https://docs.opencomputer.dev/how-it-works and https://docs.opencomputer.dev/sandboxes/timeout, and both URLs now return 404. The docs restructured around Serverless Agents, the current llms.txt index lists no sandbox or timeout pages, and the new "How it works" page (docs.opencomputer.dev/agents/mental-model) states no boot or wake figures, so I left cold_start and wake_on_request alone. The wake_on_request evidence also described SDK operations waking a hibernated sandbox, not the inbound network traffic the field asks about, and the file already records true.
aws-lambda-microvms: SDK list already current, no field changes
aws-lambda-microvms: SDK list already current, no field changes
The event proposed adding .NET to the sdks list, citing the Lambda MicroVMs
API Reference PDF. I fetched that PDF and it lists AWS SDKs for .NET V4, C++,
Go v2, Java V2, JavaScript V3, Kotlin, PHP V3, Python (Boto3), and Ruby V3.
data/providers/aws-lambda-microvms.json already records that exact set, so no
field needed to change. I updated last_verified to 2026-10-27; the citation
URL was already in sources. The event's other fields appeared only in its
previous snapshot, not as proposed changes, so I left them alone.
Add JavaScript SDK to Databricks Sandbox
Databricks Sandbox now lists a JavaScript SDK alongside Python, Go, and Java in data/providers/databricks-sandbox.json. The docs usage guide states that the Databricks SDK for Python includes a sandbox client, the Go SDK's service/sandbox/api.go and the Java SDK's SandboxAPI.java define the sandbox service, and Databricks publishes the JavaScript package @databricks/sdk-sandbox on npm (latest 0.1.7, homepage github.com/databricks/sdk-js). The npm package page itself sits behind a Cloudflare challenge to curl, so I confirmed it through the npm registry JSON, which carries the same package data. I added the npm citation to sources, deduplicated against the three citations the file already had, and left last_verified at 2026-10-27.
Update Akamai Agent Sandbox notes and SDK list
Akamai launched Agent Sandbox today and both of the event's field changes
check out. The notes field now records that Akamai lists Agent Sandbox via
the Spin SDK as available in beta, per the launch press release's
Availability line, and keeps the product page's description of intermittent
execution, where each step completes in about a minute. The sdks field now
lists Rust, Go, JavaScript, and Python: the product page says agents are
built with the Spin SDK and run as Spin applications on Akamai Functions,
and the Akamai Functions welcome doc states "SDK support for Rust, Go,
JavaScript, and Python". Akamai's main site blocks direct fetches from this
environment, so I verified the press release through Akamai's investor
relations mirror of the same release and the product page through a text
extraction proxy of the cited URL. I added both new citations to sources,
deduplicated, and touched no other fields.
No change: OpenComputer cold_start claim fails verification
No change: OpenComputer cold_start claim fails verification
The event proposed replacing cold_start with "Wake averages 1-2 seconds; no specific create-time figure stated". I fetched both citations and rejected the change. The overview page (https://docs.opencomputer.dev/sandboxes/overview) returns 404 after a docs restructure, so it states nothing. The guide (https://opencomputer.dev/guides/qemu-vs-kvm/) does say waking averages 1 to 2 seconds, but the same page also gives create-time figures: sandbox boot under 1 second at p95, around 300 ms from a golden snapshot, and around 200 ms when the snapshot is warm on the worker. So the claim that no create-time figure is stated is false, and the current value, "~300 ms from a golden snapshot; under 1 s at p95 for boot; 1-2 s average wake from hibernation", matches every figure on that live guide. The restructure also removed the old how-it-works and timeout pages, but the guide carries the same figures and already sits in sources along with both event citations. I left the file untouched.
box-by-ascii: add $20 plan minimum; 14-day snapshot retention stands
box-by-ascii: add $20 plan minimum; 14-day snapshot retention stands
The Box homepage states a $20 minimum per month, which buys about 555 hours of 4 vCPU / 8 GB VM-time spread across one sandbox or many, so notes now records that plan minimum (box.ascii.dev). The event also claimed the Box FAQ retains stopped-Box snapshots for the life of the Box; the cited URL redirects to docs.boat.dev/faq, which says a stopped sandbox keeps its disk for 14 days and boat then deletes it, so I left the retention text unchanged. While verifying, I confirmed on the pricing and billing pages that saved snapshots above the plan's included count cost $0.056 a day; the file had said $1.70 a month, so notes now uses the stated figure. I changed only notes and last_verified, and both event citations were already in sources.
No change: Sprites CPU price stays $0.0385 per CPU-hour
No change: Sprites CPU price stays $0.0385 per CPU-hour
The event proposed setting the Fly.io Sprites price_headline to "$0.07 per CPU-hour", citing the Sprites product page with the excerpt "$0.07 /CPU-hour". That page states CPU at $0.0385/CPU-hour in its pricing FAQ, and its only "0.07" is a coordinate inside an SVG logo path, so the excerpt misreads the page. The second cited URL, https://fly.io/pricing.md, lists Sprites CPU time at $0.0385 / CPU-hour, and Fly's October 2026 pricing update page carries the same rate. The file already matches these pages, so I left data/providers/fly-io-sprites.json unchanged.
Add Akamai Agent Sandbox and Databricks Sandbox as new providers
Add Akamai Agent Sandbox and Databricks Sandbox as new providers
A new-products event named two sandboxes the site did not track, and I added a data file for each, filling only fields the event supports and leaving the rest null. For Akamai Agent Sandbox, I confirmed the claims in Akamai's October 27, 2026 press release and StreetInsider's report, fetching both through a reader proxy because they block direct requests: agents run on Akamai Functions, agent-written code runs in a separate WebAssembly-isolated environment delivered as an open source part of the Spin framework, and the product is in beta; neither source states pricing, so the pricing fields stay null. For Databricks Sandbox, I fetched the docs page (last updated October 26, 2026) directly and confirmed it is in beta, runs untrusted code on serverless, on-demand compute reached through the REST API, SDK, or CLI, and keeps a persistent home directory; the page states no usage charge during beta and anticipates billing for runtime compute, storage, and data transfer afterward. I left providers.json untouched, since the census is edited only during discovery turns.
blaxel: wake_on_request finding already on file, no field changes
blaxel: wake_on_request finding already on file, no field changes
The event's only proposed change sets Blaxel's wake_on_request to true, and data/providers/blaxel.json already records true, so I changed no fields. I fetched both cited pages and they support the on-file value: the lifecycle blog says a standby sandbox is "waiting for a signal to reactivate" and that "when it receives a request, it wakes up and restores the previous state", and the Sandboxes overview says a sandbox without an active connection "automatically transitions to a warm standby mode". Both URLs were already in sources, so the only edit is last_verified moving to 2026-10-27 to mark the re-verification.
No change: Daytona docs still list a Java SDK, event misread page
No change: Daytona docs still list a Java SDK, event misread page
The event asked me to drop Java from Daytona's SDK list, citing the docs overview at https://daytona.io/docs/en. I fetched that page and it still lists Java: the "Daytona SDKs" resource list links TypeScript, Python, Ruby, Go, and Java, the quick start includes a Java install tab, and the Java SDK docs page (https://www.daytona.io/docs/en/java-sdk/) returns 200. The page does not support removing Java, so I left data/providers/daytona.json unchanged and no fields were edited.
# Turn summary 2026-10-26T190629Z
perplexity-space: reword cold_start to the verified 60 ms benchmark
Updated cold_start in data/providers/perplexity-space.json to "~60 ms median create latency (published benchmark; not a guaranteed cold-start time)". The event's monitor snapshot previously showed this field as null, but the file already carried the same 60 ms figure from an earlier turn, so this turn is a rewording that also removes an em dash the style guide forbids, not a new fact. I verified the claim against the cited Perplexity engineering post, "Making SPACE: Secure and efficient runtimes for long-running agents" (https://www.perplexity.ai/hub/blog/making-space-secure-and-efficient-runtimes-for-long-running-agents). The live page sits behind a Cloudflare challenge, so I confirmed the wording in the Wayback Machine snapshot of that URL from 2026-10-16: "median create latency fell from 185 milliseconds to 60 milliseconds (3.1x improvement), and the 90th-percentile latency fell from 447 milliseconds to 89 milliseconds (5.0x improvement)." The post measures SPACE against Perplexity's previous sandbox provider on shared production traffic over launch week, so the numbers are a published benchmark, which the new field text states. I set last_verified to 2026-10-26. The event proposes no other field changes, and its one citation URL was already in sources, so the list stays as it was.
Update nvidia-openshell isolation: MicroVMs are libkrun-based
Update nvidia-openshell isolation: MicroVMs are libkrun-based
NVIDIA's current docs describe the MicroVM runtime as libkrun-based and no longer mention QEMU, so I dropped QEMU from the isolation field and set last_verified to 2026-10-26. The runtimes page (https://docs.nvidia.com/openshell/latest/how-it-works/sandboxes/runtimes.md) says the MicroVM driver runs each sandbox in its own lightweight VM, and the support matrix (https://docs.nvidia.com/openshell/latest/about/support-matrix.md) states that runtime uses the VM compute driver and libkrun. Neither page mentions QEMU, and the GitHub architecture doc that previously listed "libkrun or QEMU" now returns 404. I kept the field's Landlock and seccomp detail because the support matrix still lists both as required kernel facilities, and I left every other field unchanged. Both supporting pages were already in the file's sources list, so the deduplicated list needed no additions.
agent-substrate: not free while idle; GKE bills nodes until deleted
agent-substrate: not free while idle; GKE bills nodes until deleted
Changed free_while_idle and usage_billed to false in data/providers/agent-substrate.json, set last_verified to 2026-10-26, and added the GKE pricing page and the resume-actor flow page to sources. Google's install page says Agent Substrate on GKE runs only on GKE Standard clusters, with Autopilot unsupported, and that node-pool autoscaling is optional; the GKE pricing page bills Standard node pools for their underlying Compute Engine instances until the nodes are deleted. A suspended actor therefore leaves its cluster billing on allocated capacity, so a sleeping sandbox is not free and the bill follows reserved nodes rather than actor CPU use. The About page still says you pay for compute only when agents are actively processing tasks; that sentence describes agent compute rather than the cluster bill, so the pricing page governs. I verified both field changes against the live pages: https://docs.cloud.google.com/kubernetes-engine/ai-ml/install-overview-substrate and https://cloud.google.com/kubernetes-engine/pricing.
vast stack: note the public vast-sandboxes repository
vast stack: note the public vast-sandboxes repository
Updated only the notes field for the VAST Agent Sandbox Foundation Stack. The event's changed field said the GitHub repository moved from planned to available, and both cited pages check out: github.com/vast-data/vast-sandboxes is publicly accessible and ships a deployable implementation (deploy runbooks, deploy scripts, docs/ARCHITECTURE.md), while the press release (vastdata.com/press-releases/...) still describes the repository as planned and states no compute prices or hosted sandbox rate, so the notes now record the repository as public with no stated prices. I kept the existing SDK and RAM caveats because the event does not contradict them, added the repository URL to sources, and set last_verified to 2026-10-26. One wrinkle from verification: the press release's "Agent Sandbox Foundation Stack" link points at the separate vast-research-assistant-agent blueprint, but the vast-sandboxes repository itself matches the stack (NemoClaw and OpenShell on VAST AI OS).
novita: duplicate long-running event, no new change
novita: duplicate long-running event, no new change
Turn 20261026T171637Z already processed this event, byte for byte, as commit a0dc61f, so I edited nothing. I re-verified the cited pages: https://novita.ai/sandbox lists a 1-hour free-tier and 24-hour paid-tier max session length, and the long-running guide at https://docs.novita.ai/guides/sandbox-long-running shows a sandbox staying alive for up to 7 days as an example and states no hard maximum. data/providers/novita.json already carries these facts in max_runtime and notes. The quota-limit doc (https://docs.novita.ai/guides/sandbox-quota-limit) still caps paid sessions at 3 hours, so the product page's 24-hour figure stays a flagged conflict in notes rather than the recorded value. Both event citations were already in sources and last_verified already reads 2026-10-26.
aws-agentcore-runtime: event confirms docker and idle billing, no change
aws-agentcore-runtime: event confirms docker and idle billing, no change
The event's changed output sets docker to true and free_while_idle to false, and data/providers/aws-agentcore-runtime.json already records both values, so no field changed; the event's previous output is an older monitor snapshot, not the site's data. I fetched the three cited pages. The Instances page states that AgentCore provisions GPU drivers so standard container images, including CUDA images, work without bundling drivers, and the pricing page states that a consumption session spans from microVM ready through idle periods to termination, with system overhead and a 128 MB memory floor, while Instances bill the underlying EC2 instance for the time it runs, which supports free_while_idle false (https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-instances-how-it-works.html, https://aws.amazon.com/bedrock/agentcore/pricing/). The third citation, https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-security.html, now redirects to the AgentCore overview page, which still says "Bring your own container image for custom environments with additional dependencies". No cited page mentions a Docker daemon inside a session, a gap the event's own reasoning flags, so I left docker at the value the site already held, which the event affirms. I set last_verified to 2026-10-26 and added that URL to sources; the other two citations were already listed, and every other field stands.
brig: update isolation to urunc on Cloud Hypervisor, add qemu backend
brig: update isolation to urunc on Cloud Hypervisor, add qemu backend
Brig's isolation field now says each sandbox is a microVM with its own kernel, macOS runs hull with hvi, vz, or qemu backends, and Linux runs urunc on Cloud Hypervisor. I confirmed both changes on the cited pages: the architecture page states "On Linux, urunc boots the sandbox on Cloud Hypervisor", and the runtimes page lists hvi, vz, and qemu as the three backends hull accepts for its --hypervisor flag. The event's changed output covers only isolation, so I left every other field in data/providers/brig.json alone. I added https://www.brig.sh/docs/architecture/ to sources, skipped https://www.brig.sh/docs/runtimes/ as a duplicate, and set last_verified to 2026-10-26.
novita: long-running docs show 7-day example, no stated maximum
novita: long-running docs show 7-day example, no stated maximum
Updated data/providers/novita.json after verifying both cited pages. The long-running guide (https://docs.novita.ai/guides/sandbox-long-running) presents "stays alive for up to 7 days" as an example configuration and states no hard maximum for long-running mode, so max_runtime and notes now describe 7 days as a documented example rather than a cap; the guide also confirms the default 1-hour timeout that long-running mode lifts. The product page (https://novita.ai/sandbox) still lists a 1-hour free tier and a 24-hour paid-tier max session length. The event's proposed values dropped the quota-doc session figures, but the quota page (https://docs.novita.ai/guides/sandbox-quota-limit) still caps paid sessions at 3 hours and enterprise at 4 hours by default, adjustable, so I kept those figures and left the product-page disagreement in notes. Both citation URLs were already in sources, and last_verified is now 2026-10-26.
Add OCI Enterprise AI Agent Sandbox as a new provider
Add OCI Enterprise AI Agent Sandbox as a new provider
Created data/providers/oci-enterprise-ai-agent-sandbox.json, sourced to Oracle's announcement post (https://blogs.oracle.com/ai-and-datascience/oci-enterprise-ai-smr-sandbox). The post states that OCI Enterprise AI Agent Sandbox is generally available as a managed execution layer where agents create temporary Linux workspaces to test generated code, run shell commands, and analyze business data. Organizations configure compute resources, execution duration, and network access while OCI operates the underlying infrastructure, and OCI Enterprise AI is expanding to 30 additional commercial regions with sandboxes among the selected features. The post states no pricing, so the pricing fields read "Not publicly stated" and the other specs stay null. The event's other citation, a Tech in Asia story on the VAST Data and NVIDIA stack announced October 22, matches what data/providers/vast-agent-sandbox-foundation-stack.json already records, so that file is unchanged.
No data change: opencomputer 8-hour claim fails verification
No data change: opencomputer 8-hour claim fails verification
The event proposes changing opencomputer's max_runtime to an 8-hour ceiling for v2 sandboxes, citing https://docs.opencomputer.dev/sandboxes/lifetime. That page returns 404, it appears in neither the docs sitemap nor the llms.txt index, and the Wayback Machine has never archived it. I also fetched the full docs dump (llms-full.txt), the pricing page, and the homepage: none mentions a v2 sandbox runtime or any 8-hour cap. OpenComputer has reorganized its docs under /agents/ and the old /sandboxes/ pages now 404, but the current docs state no runtime ceiling, so the existing "no fixed limit" value stands. The event's only changed field was max_runtime, so data/providers/opencomputer.json is untouched and no other provider files were affected.
google-cloud-agent-sandbox: event confirms docker, no value changes
google-cloud-agent-sandbox: event confirms docker, no value changes
The event's only delta was docker, null to true, citing the gVisor tutorial for running Docker in a GKE sandbox. The file already had docker: true, sourced to the gvisor.dev copy of that same tutorial, so no spec field changed. I fetched the cited page and confirmed it states that all basic docker commands work in gVisor and shows a Docker daemon running inside a gVisor-sandboxed Pod, with NET_ADMIN and SYS_ADMIN capabilities required and an Autopilot NET_ADMIN workload policy. I set last_verified to 2026-10-26 and added the GitHub URL to sources, which had no duplicate of it. The event carries no other changes, so the file's other values stand.
codesandbox: event confirms existing docker support, no field changes
codesandbox: event confirms existing docker support, no field changes
The event's only delta was docker, null to true, citing the SDK launch post and the SDK repository, and data/providers/codesandbox.json already had docker: true, so no field changed. I verified both citations: the launch post lists "Environment customization using Docker & Docker Compose (Dev Containers)" among what CodeSandbox SDK sandboxes provide, and the repository README lists "Running any Dockerfile" (the live blog blocks automated fetches, so I confirmed the excerpt against the Internet Archive copy). I set last_verified to 2026-10-26 and added https://github.com/codesandbox/codesandbox-sdk to sources; the blog URL was already listed. The event carried no other changes, so the file's other values stand.
No data change: Runloop isolation event cites a dead page
No data change: Runloop isolation event cites a dead page
The event proposes updating Runloop's isolation field to "Dedicated MicroVM on bare-metal infrastructure, with a hypervisor boundary and a container boundary within the VM", citing https://runloop.ai/security-compliance. That URL returns HTTP 404 and runloop.ai's sitemap does not list it. The only archived copy, from March 16, 2026 (web.archive.org/web/20260316170603/https://runloop.ai/security-compliance), says every agent runs in a hardware-isolated MicroVM on bare-metal infrastructure and states "No shared kernels. No hypervisor attack surface", which does not confirm the event's hypervisor-boundary and container-boundary wording. Runloop's current docs state that wording nowhere either. I left data/providers/runloop.json unchanged, so the isolation field, last_verified date, and sources stay as they were.
runloop: no data change; cited security page returns 404
runloop: no data change; cited security page returns 404
The event proposes one change: rewrite isolation to "Dedicated MicroVM on bare-metal infrastructure, with a hypervisor boundary and a container boundary within the VM", citing https://runloop.ai/security-compliance. That URL returns 404, and the Security & Compliance link in Runloop's own footer now points at /product/security-compliance, which also returns 404, so the cited page can't confirm the new value. The only archived copy (web.archive.org, 2026-03-16) says every agent runs in its own hardware-isolated MicroVM on bare-metal infrastructure and claims there is no hypervisor attack surface, so even that copy does not state the proposed two-boundary wording. No live Runloop page carries it either. The existing value, "Linux microVM with hardware isolation (two-layer VM + container)", already covers the same substance, and the live pricing page still states microVM-level hardware isolation between tenants (https://runloop.ai/pricing), so I left data/providers/runloop.json untouched: no field edits, no new sources, and no last_verified bump.
agent-substrate: re-verified citations, no field changes
agent-substrate: re-verified citations, no field changes
The event's snapshot re-proposes a <400 ms resume figure that commit
40140ca already recorded on 2026-10-18, so cold_start keeps its current
wording. I fetched the README and confirmed it states resume operations
take less than 400 ms, which supports the value as written; the GKE docs
agree that restores finish in under a second. The event also flips docker
to true, but neither cited page says Docker containers run inside a
sandbox. The README's OCI-image sentence describes how actor workloads are
packaged, its only Docker mention is a build prerequisite for the dev
machine, and the event's own reasoning concedes it does not establish
nested Docker support, so docker stays null. Both citation URLs were
already in sources, and I bumped last_verified to 2026-10-25 after
verifying the file.
No change: Islo 300 ms cold-start claim not verified
No change: Islo 300 ms cold-start claim not verified
The event proposed setting Islo's cold_start to "~300 ms", citing the blog post "Coding Agents Need a New Primitive, and It's Not a Sandbox" (https://islo.dev/blog/coding-agents-need-new-primitive/). I fetched the page and confirmed it contains the quoted sentence, "A sandbox boots in 300ms. A shell appears." The post uses that figure to describe sandbox demos in general while arguing that boot time matters less than persistence for coding agents, and it never states Islo's own boot time. The research summary itself flags medium confidence and calls the figure unmeasured. I therefore left data/providers/islo.json unchanged: the cited page does not state this value for Islo, and a generic figure from a blog post is not better sourced than the file's current entry. The event's diff touched no other field.
openshell: MicroVMs run on libkrun or QEMU
I updated the isolation field in data/providers/nvidia-openshell.json to say MicroVMs run on libkrun or QEMU instead of libkrun only. NVIDIA's gateway configuration reference states the host supervisor normalizes the proxy host name for both libkrun and QEMU sandboxes (https://docs.nvidia.com/openshell/latest/how-it-works/gateways/configuration.md), and the runtimes page says VM mounts work only with the libkrun backend, which confirms libkrun is one backend among several (https://docs.nvidia.com/openshell/latest/how-it-works/sandboxes/runtimes.md, already cited). I added the configuration URL to sources and set last_verified to 2026-10-25. I kept the existing Landlock and seccomp wording because the architecture page still states it (https://docs.nvidia.com/openshell/latest/about/architecture.md), so the event's rewording to "runtime-specific kernel and network controls" would only drop sourced detail. The event's GitHub citation for the QEMU claim, architecture/compute-runtimes.md, returns 404 and no such file exists in the NVIDIA/OpenShell repo, so I left it out of sources.
runwork: memory snapshots persist across suspend (Blaxel case study)
runwork: memory snapshots persist across suspend (Blaxel case study)
Blaxel's Runwork case study says Runwork agent sandboxes suspend when a task ends and resume from the exact state in under 25 ms, and credits persistent memory snapshots for the speedup (https://blaxel.ai/blog/runwork-accelerates-collaborative-enterprise-ai-workflows-by-10x-using-blaxel). Blaxel's sandbox docs describe the same mechanism: a standby snapshot captures the entire state, including the in-memory filesystem and running processes, and restores it on reconnect, though external network connections are not preserved (https://docs.blaxel.ai/Sandboxes/Overview). I set memory_snapshots to true in data/providers/runwork.json, added the docs URL to sources, updated notes with the provenance and the network caveat, and bumped last_verified to 2026-10-25. The event's other two fields changed nothing: cold_start and sdks already hold the proposed values from earlier turns, the monitor's previous snapshot was stale, and the cited pages still support what the file says.
novita: event reconfirms Firecracker isolation, bump last_verified
The event proposes setting isolation to "Firecracker microVM", and the data
file already records that value, so no field content changed. I fetched the
cited page, Novita's blog post "What Is an AI Agent Sandbox?", and it states
directly that Novita Agent Sandbox uses "Firecracker microVM isolation"
(https://blogs.novita.ai/what-is-an-ai-agent-sandbox/). The URL already
appears in the file's sources, so nothing was added there. I bumped
last_verified to 2026-10-25 to record the verification.
agent37-cloud: no data change; cited page lacks the event's new medians
agent37-cloud: no data change; cited page lacks the event's new medians
The event's only changed field is cold_start, proposing "Create: 2.88 s median API duration; resume: 549 ms median same-host checkpoint restore" and citing https://www.agent37.com/compare/namespace. That page's Agent37 column reports Create at 1.29 s median (n = 37) and Resume / wake at 176 ms median (n = 38), from Performance dashboard telemetry covering October 22, 2026, 00:50 to 01:15 UTC. The event's excerpts quote the page's row descriptions accurately, but its numbers appear nowhere on the page: neither 2.88 nor 549 occurs in the HTML, and a second fetch returns the same table. The comparison page at https://www.agent37.com/compare/codesandbox shows the same 1.29 s and 176 ms. The citation therefore confirms the values data/providers/agent37-cloud.json already records, so I left the file untouched, with last_verified and sources unchanged.
opencomputer: no data change; event cites deleted docs pages
opencomputer: no data change; event cites deleted docs pages
The event's only changed field is cold_start, proposing "About 300 ms to boot from a golden snapshot; wake is typically sub-second" with two citations. Both cited URLs (https://docs.opencomputer.dev/how-it-works and https://docs.opencomputer.dev/sandboxes/timeout) return 404: OpenComputer restructured its docs around Serverless Agents, and the current index (https://docs.opencomputer.dev/llms.txt) lists no sandbox, timeout, or hibernation pages. A Wayback copy of the timeout page from 2026-08-29 does say wake is typically sub-second, so the event's excerpt is real, but OpenComputer's live pages disagree on wake: https://opencomputer.dev/guides/qemu-vs-kvm/ says waking averages 1 to 2 seconds depending on snapshot warmth, and https://opencomputer.dev/blog/scaling-one-vm-to-million-sandboxes says wake is 1-2 seconds and boot is under 1 second at p95. The field already carries those live-sourced figures (~300 ms golden-snapshot boot, under 1 s at p95, 1-2 s wake), and rewriting it to a claim citable only to a deleted page would make it worse-supported, so I left data/providers/opencomputer.json untouched and added no dead URLs to sources.
codesandbox: no data change; cold_start keeps the more specific figures
codesandbox: no data change; cold_start keeps the more specific figures
The event's only changed field is cold_start. I verified both citations against Wayback copies (2026-03-14 for the Resume page, 2026-04-18 for Core Concepts) because Cloudflare's challenge blocks direct fetches, and both match the event's excerpts. The Resume page does say resumes take 1-3 seconds regular and 10-60 seconds archived, but Core Concepts gives the finer breakdown the file already carries: 1-3 s to create, 0.5-2 s from a memory/disk snapshot, 5-20 s from disk, 20-60 s from archive. Both pages are CodeSandbox's own docs, and the event's previous and current readings cite identical excerpts from the same URLs, so the proposal restates unchanged docs with less specificity. The site's rules say to keep the more specific figure and not to rewrite a field to an equally-supported alternative, so I left data/providers/codesandbox.json untouched. Sources: https://codesandbox.io/docs/sdk/core-concepts, https://codesandbox.io/docs/sdk/resume.
cloudflare: no data change; wake evidence is from legacy SDK 0.x
cloudflare: no data change; wake evidence is from legacy SDK 0.x
The event proposed two edits and I rejected both after fetching the pages. The 648 ms median time-to-interactive it proposes for cold_start is already in the field: https://blog.cloudflare.com/faster-agent-sandboxes/ reports a 648 ms median in ComputeSDK's 100-sandbox Burst TTI Benchmark on the new scheduling policy, and https://developers.cloudflare.com/containers/concepts/architecture/ still states the general 1-3 second range, so the rewrite would only drop sourced context. The proposed wake_on_request: true rests on https://developers.cloudflare.com/sandbox/concepts/sandboxes, which says that after idle "the container stops" and "when the next request arrives, a fresh container starts", but that page documents Sandbox SDK 0.x for existing applications. For the current product, the 1.0 docs say you write the Durable Object class yourself and your code decides when the container starts (https://developers.cloudflare.com/sandbox/sdk/migrate/changes-in-1-0/), and that Cloudflare does not wake the Durable Object when its instance stops (https://developers.cloudflare.com/sandbox/concepts/lifetime/), so wake_on_request stays false as set on 2026-10-16 rather than flip on legacy-version docs. I bumped last_verified to 2026-10-25, added the changes-in-1-0 page to sources, and left the event's citations alone because both were already listed (the lifecycle page is the same URL with a trailing slash).
modal: no change; cold-start guide figure is not Sandbox-specific
modal: no change; cold-start guide figure is not Sandbox-specific
The event proposed changing Modal's cold_start to "About 1 second (published container timing; not Sandbox-specific)", citing https://modal.com/docs/guide/cold-start. I fetched the page: it states "Containers boot in about one second" inside the Functions cold-start guide, about Modal's container stack generally, and its body never mentions Sandboxes. The event's own reasoning concedes the figure is not a measured Sandbox create or resume time. The current value still holds: Modal's VM Sandboxes post says VM Sandboxes bring "sub-second cold-starts" (https://modal.com/blog/vm-sandboxes-agent-computers, verified live today), and the cited cold-start guide URL is already in modal.json's sources. I edited nothing, because the page does not state this timing for Sandboxes and the current claim is the one Modal makes about Sandboxes directly.
tencent-cubesandbox: cold_start now ~60 ms per README benchmark
tencent-cubesandbox: cold_start now ~60 ms per README benchmark
Updated cold_start for Tencent Cloud CubeSandbox. The project README states "Cold start benchmarked on bare-metal. 60ms at single concurrency; under 50 concurrent creations, avg 67ms, P95 90ms, P99 137ms", so the create figure now reads ~60 ms at single concurrency with a 67 ms average at 50 concurrent creations, replacing the ~48 ms serial figure the June benchmark post reported. The event rendered the README's "under 50 concurrent creations" as "fewer than 50 concurrent creations"; the README's paired chart and caption ("single and high-concurrency workloads") show the 67 ms average belongs to 50-concurrency runs, so I wrote "at 50 concurrent creations" instead. I kept the ~42 ms resume figure and the auto-resume caveat, which the 2026-06-01 benchmark post and the lifecycle guide still state. The README's 50-concurrency numbers disagree with that post's own table (276.1 ms average at 50-concurrent on BMI5), but the README is the provider's current docs and takes precedence over the blog post. Both event citations were already in sources, so I only set last_verified to 2026-10-25.
microsoft-azure: wake_on_request stays true; GA post verifies it
microsoft-azure: wake_on_request stays true; GA post verifies it
The event proposed setting wake_on_request to true, citing Microsoft's GA
announcement for Azure Container Apps Sandboxes. I fetched that page and it
states a stopped sandbox "can resume on a start command or automatically on
arriving network traffic", so the value is confirmed. The data file already
carried true from earlier turns, so no field value changed; I bumped
last_verified to 2026-10-24 and left everything else alone. The citation
(https://techcommunity.microsoft.com/blog/appsonazureblog/azure-container-apps-sandboxes-now-generally-available/4559125)
was already in sources.
langsmith-sandboxes: docker stays true; page verifies it
langsmith-sandboxes: docker stays true; page verifies it
The event proposed setting docker to true for LangSmith Sandboxes, citing the product page. I fetched https://www.langchain.com/langsmith/sandboxes and confirmed it states agents get full root inside the sandbox and can install packages and run Docker. The data file already held docker: true, so no value changed. I refreshed last_verified to 2026-10-24; the citation URL was already in sources.
No change: Gemini platform rates don't apply to Agent Compute Engine
No change: Gemini platform rates don't apply to Agent Compute Engine
The event proposed values for price_headline and pricing_model on agent-compute-engine.json, citing Google's Gemini Enterprise Agent Platform pricing page (https://cloud.google.com/products/gemini-enterprise-agent-platform/pricing). I fetched the page and the figures are real: it bills Runtime and Sandbox environments at $0.085 per vCPU-hour for Agent Compute and $0.009 per GiB-hour for Agent Memory, with the first 50 compute hours and 100 GiB-hours free per month per account, and usage rounded to the nearest second. The page never names Agent Compute Engine, though. It prices the Gemini platform's own environments, where "Agent Compute" is the platform's billing resource, and neither Agent Compute Engine blog post (https://cloud.google.com/blog/topics/ai-infrastructure/introducing-agent-compute-engine-and-expanded-agent-governance, https://cloud.google.com/blog/topics/ai-infrastructure/agent-compute-engine-deep-dive) mentions pricing or the platform. I left both fields at "Not publicly documented" and edited nothing else, so last_verified stays 2026-10-22 and no sources were added. If the site adds a record for the Gemini platform's sandbox environments, these rates belong there.
agent37-cloud: cold_start now 1.29 s create, 176 ms resume medians
agent37-cloud: cold_start now 1.29 s create, 176 ms resume medians
Agent37 re-measured its startup telemetry, so data/providers/agent37-cloud.json now reads "Create: 1.29 s median API duration; same-host checkpoint resume: 176 ms median host-timed restore." instead of the older "a few seconds to restore from sleep" wording. I fetched the cited page, https://www.agent37.com/compare/codesandbox, and confirmed both figures sit in the Agent37 column of the performance table (n = 37 and n = 38); https://www.agent37.com/compare/machine0, which the event's previous snapshot drew on, now shows the same numbers, so the old 2.88 s and 549 ms medians were superseded rather than contradicted. I set last_verified to 2026-10-24 and added the comparison URL to sources. The event's snapshot changed only cold_start, so every other field is untouched.
digitalocean-managed-agents: keep cold_start; 200 ms claim conflicts
digitalocean-managed-agents: keep cold_start; 200 ms claim conflicts
The event proposed setting cold_start to "~200 ms to resume; create time not stated". I fetched the cited page (https://www.digitalocean.com/products/managed-agents) and it does not support that value. Its headline states sessions "go from creation to a first response in under a couple of seconds, and resume paused work in about 300 milliseconds", which undercuts the proposal twice: the page does state a create-to-first-response time, and its resume figure is 300 ms, while the 200 ms figure appears only in one FAQ answer about reattaching after a closed laptop. Two figures on the same page carry equal weight, so cold_start keeps its current value rather than flip to the competing one. I reverified that value today: the product page still carries the headline figures, and the LangGraph quickstart (https://docs.digitalocean.com/products/managed-agents/agent-harness-runtime/how-to/run-langgraph-agent/) still states "Cold start typically takes about 20 seconds". The only file change is last_verified, now 2026-10-24; the event's citation URL was already in sources, so nothing was added there.
daytona: wake_on_request already true; reverified, no field changes
daytona: wake_on_request already true; reverified, no field changes
The event proposed setting Daytona's wake_on_request to true, but data/providers/daytona.json already records true, applied on 2026-10-17 from the same docs, so I changed no fact field. I reverified the value today: Daytona's docs say a stopped or paused persistent sandbox starts when an authenticated request arrives, and Daytona holds the request for up to 60 seconds while the sandbox comes up (https://daytona-website-website-prod.daytona.workers.dev/docs/en/preview), and the persistence docs say a Linux sandbox with wake_on_request set also starts on the next request (https://daytona-website-website-prod.daytona.workers.dev/docs/en/persistence). The cited sandboxes page no longer carries the wake-on-request sentence because Daytona reorganized its docs, but the pages above confirm the behavior. I refreshed last_verified to 2026-10-24 and added the preview URLs page to sources.
modal: cold_start now sub-second (Modal's published claim)
modal: cold_start now sub-second (Modal's published claim)
Modal's engineering posts claim sub-second cold starts for Sandboxes. The VM Sandboxes post says the VM runtime brings "the same APIs, modal.Images, sub-second cold-starts... as previously" (https://modal.com/blog/vm-sandboxes-agent-computers), and the filesystem post says "we were back to our sub-second cold starts" and that "Modal containers cold-start in under a second" (https://modal.com/blog/vm-sandbox-filesystem). I fetched both pages and confirmed the quotes, so cold_start in data/providers/modal.json now reads "Sub-second (Modal's published claim)", replacing "Boots in seconds; no exact create or resume time published". I dropped the event's "no typical measured time specified" hedge because the file already cites Modal's 1M-sandbox post, which reports sandbox start times under half a second at the median, so a blanket "no measured time" would be wrong. The cold-start guide's "Containers boot in about one second" line covers Modal Functions containers, not Sandboxes, so it does not compete with the new value. Both citation URLs were absent from sources, so they are appended, deduplicated, and last_verified moves to 2026-10-24.
runloop: gpu already true; refreshed last_verified only
runloop: gpu already true; refreshed last_verified only
The event proposes setting gpu to true for Runloop Devboxes, and data/providers/runloop.json already records that value. I verified the claim against both cited pages before touching anything: https://docs.runloop.ai/llms.txt describes a Devbox as an isolated Linux sandbox with shell, filesystem, networking, and optional GPU, which supports keeping gpu true. The sizes page (https://docs.runloop.ai/docs/devboxes/configuration/sizes) lists X_SMALL through XX_LARGE with CPU, memory, and storage columns but never mentions GPU, so it adds no support of its own. Both citation URLs already sit in the file's sources list, so nothing was added there. The only edit is last_verified, now 2026-10-24.
ellipsis: set docker true; docs use compose in setup scripts
ellipsis: set docker true; docs use compose in setup scripts
Ellipsis's environments page tells setup scripts to start services in the background, gives `docker compose up -d --wait` as the example, and says saved results keep those services running (https://www.ellipsis.dev/docs/environments). That is the provider's own instruction to run Docker Compose inside the sandbox, so data/providers/ellipsis.json now records docker as true and carries last_verified 2026-10-24. I fetched the cited page and confirmed the paragraph; it is the only Docker mention there, and the URL was already in the file's sources, so the deduplicated list is unchanged. The event's changed output covers only this field, so nothing else moved.
computer-agents: no change; event restates already-recorded facts
computer-agents: no change; event restates already-recorded facts
The event proposes new wording for two fields on Computer Agents, pricing_model and summary, and I verified every claim behind it: https://computer-agents.com/pricing lists subscription plans with included credits and computer rates from $0.0026/min (Lite) to $0.013/min (Desktop), https://computer-agents.com/developers/core-concepts/computers states that computers are billed by active runtime minute, and https://computer-agents.com/ describes persistent cloud computers, projects and tasks, and the official TypeScript and Python SDKs. The current data/providers/computer-agents.json already records these facts from the same pages: its pricing_model covers per-minute billing by computer tier with subscription credits, and its summary already names the per-agent persistent cloud computer, the isolated container, and both SDKs. The proposed values restate what the file says rather than adding better-sourced ones, and the guide says to change a field only when the new value is better sourced, so I edited nothing. All three citation URLs already appear in the file's sources.
railway: no data change; duplicate event, facts already recorded
railway: no data change; duplicate event, facts already recorded
This turn re-delivers the same event the site already processed earlier today
(commit e7e0b17), so I changed no fields in data/providers/railway.json. I
re-verified all four cited pages anyway: docs.railway.com/sandboxes and
docs.railway.com/pricing/plans state that memory, background CPU use, and
outbound traffic remain billable while a sandbox waits for work,
railway.com/pricing states a sandbox is billed "never for the time it spends
waiting", and railway.com/changelog/2026-09-18-railway-sandboxes states
Railway Sandboxes graduated from Priority Boarding and are available on every
plan. The file's notes already record the idle-billing conflict and the
every-plan availability, all four citation URLs already sit in sources, and
last_verified already reads 2026-10-23.
microsoft-azure: no change; storage billing still marked coming soon
microsoft-azure: no change; storage billing still marked coming soon
The event proposed rewriting the notes field to say "storage is charged per GB for as long as it is retained". I fetched the cited cost page (https://sandboxes.azure.com/docs/sandboxes/cost) and it still says "Storage is charged (coming soon) at Premium Azure Blob ZRS rates", so the page contradicts the proposal and I left the field alone. The proposal's other claims do check out: the lifecycle page confirms stopped sandboxes keep disk state and stop compute billing (https://sandboxes.azure.com/docs/sandboxes/sandbox/lifecycle), and the Microsoft Learn snapshots page confirms sandboxes with attached data disk volumes support Disk suspend mode only (https://learn.microsoft.com/en-us/azure/container-apps/sandboxes-snapshots-state-management). Nothing in the current file conflicts with those claims, so data/providers/microsoft-azure.json is unchanged. Its last_verified already reads 2026-10-23 and all three citation URLs are already in its sources list.
railway: note idle-billing conflict between docs and pricing page
railway: note idle-billing conflict between docs and pricing page
The event proposed one change for Railway Sandboxes, to the notes field, and
I verified all four cited pages before editing. docs.railway.com/sandboxes and
docs.railway.com/pricing/plans both state that memory, background CPU use, and
outbound traffic remain billable while a sandbox waits for work, while
railway.com/pricing states a sandbox is billed "never for the time it spends
waiting", so data/providers/railway.json now records that conflict alongside
the existing billing sentence. The same changelog and the sandbox docs say
sandboxes are available on every plan, which is now noted as well. All four
citation URLs were already in the file's sources list, so no entries were
added; last_verified moved to 2026-10-23. No other fields changed: the event's
previous and current snapshots differ only in notes.
microsoft-azure: notes edit rejected; storage billing still coming soon
microsoft-azure: notes edit rejected; storage billing still coming soon
The monitor proposed rewriting the notes field to say storage is charged per GB for as long as it is retained. I fetched all three cited pages: the lifecycle page (https://sandboxes.azure.com/docs/sandboxes/sandbox/lifecycle) confirms that stopped sandboxes keep disk state and stop compute billing, and the Microsoft Learn snapshots page (https://learn.microsoft.com/en-us/azure/container-apps/sandboxes-snapshots-state-management) confirms that sandboxes with data disk volumes suspend in Disk mode only. But the cost page (https://sandboxes.azure.com/docs/sandboxes/cost) still says "Storage is charged (coming soon) at Premium Azure Blob ZRS rates", so the proposed sentence presents a charge the page itself says is not in effect yet. The researcher appears to have lifted "Storage, per GB stored, for as long as you keep it" from the charges summary and missed the coming-soon qualifier below it. I left every field value unchanged. The only edits are last_verified, now 2026-10-23, and two new sources, the cost and lifecycle pages, which back the file's existing price_headline, pricing_model, free_while_idle, and cold_start values; the Learn page was already listed.
langsmith-sandboxes: cold_start already records p50; no fact changed
langsmith-sandboxes: cold_start already records p50; no fact changed
The event adds a cold_start figure to the monitor's record for LangSmith Sandboxes, and the site already carries it. I fetched both cited pages and confirmed them: the product page (https://www.langchain.com/langsmith/sandboxes) states "Prewarming keeps p50 latency under 0.98s", and the snapshots docs (https://docs.langchain.com/langsmith/sandbox-snapshots) say the first request after a stop pays the boot cost, with no duration stated. data/providers/langsmith-sandboxes.json already read "p50 under 0.98 s with prewarming; cold-resume duration not publicly stated", an equally-supported phrasing of the same facts, so I changed no field values and refreshed last_verified to 2026-10-23. Both citation URLs were already in the file's sources list.
gke-agent-sandbox: isolation restatement verified, field unchanged
gke-agent-sandbox: isolation restatement verified, field unchanged
The monitor proposed restating the isolation field as a configurable GKE Sandbox runtime, gVisor or Kata Containers microVMs, with the documented example using gVisor. I fetched the three cited pages and each supports that description: the Agent Sandbox how-to sets runtimeClassName: gvisor in its SandboxTemplate example, the GKE Sandbox page implements microVMs with Kata Containers and Cloud Hypervisor alongside gVisor, and the Agent Sandbox overview says it supports multiple runtimes while primarily intending gVisor. The file already records these same facts, gVisor through GKE Sandbox with the Kata Containers option, from the same pages, which are already in its sources, so I left the field unchanged rather than rewrite an equally supported value. The only edit is last_verified, now 2026-10-23; all three citation URLs were already present, so the sources list stays as is.
fly: no data change; GPU blog predates July 2026 deprecation
fly: no data change; GPU blog predates July 2026 deprecation
The event proposed flipping gpu to true and rewriting notes. The blog post it cites (https://fly.io/blog/wrong-about-gpu/) does say "we're not getting rid of them", but Fly published it in February 2025, and Fly's deprecation email, quoted in the community thread already in sources (https://community.fly.io/t/gpu-migration-fly-io-gpus-will-be-deprecated-as-of-july-31-2026/27110), says GPUs will be fully deprecated as of July 31, 2026, a date that has passed. The event's other basis, that the GPU docs say GPUs become unavailable after August 1 without naming a year, fails verification: https://fly.io/docs/gpus/ now redirects to that same blog post, and the event carries no excerpt for the docs claim. The suspend facts in the proposed notes (2 GB memory limit, no swap, no schedule, an update since June 20, 2024, snapshots not guaranteed to persist) are already on file from the previous turn, and I reconfirmed them on the live page (https://fly.io/docs/reference/suspend-resume/). The rewrite would also drop the rootfs and volume billing sentences, which the billing page supports, so notes stay unchanged. All three event citations are already in sources and last_verified already reads 2026-10-23, so fly.json is untouched.
sailboxes: cold_start stays; event misreads wake time
sailboxes: cold_start stays; event misreads wake time
The event proposed one change, rewriting cold_start to "A couple of seconds to wake; initial create time not stated", cited to the Lifecycle page (https://docs.sailresearch.com/sailboxes-lifecycle). That page says "Waking takes a few seconds" and never uses "couple", so the proposed value misquotes it. The value on file, "<2s start/resume; waking from sleep takes a few seconds", is confirmed today: the docs comparison table (https://docs.sailresearch.com/sailboxes) still lists <2s for Sailboxes under Start/resume time, and the lifecycle page still says waking takes a few seconds. I changed no fields, since the provider's own docs give the more specific figure and the rewrite would also drop Sailboxes from the start-time ranking, which only ranks a field with a parseable figure. The only edit is last_verified moving to 2026-10-23 to mark the re-verification; the event's citation was already in sources.
fly: add suspend update cutoff to notes; gpu stays false
fly: add suspend update cutoff to notes; gpu stays false
Edited data/providers/fly.json only. The suspend-resume page (https://fly.io/docs/reference/suspend-resume/) lists a fourth suspend requirement, a Machine updated since June 20, 2024, so notes now includes that cutoff alongside the 2 GB, swap, and schedule limits. I left gpu false. The event's evidence for true is the "we're not getting rid of them" line in the blog post We Were Wrong About GPUs (https://fly.io/blog/wrong-about-gpu/), but that post is dated February 14, 2025 and predates Fly's deprecation emails: the community thread already in our sources (https://community.fly.io/t/gpu-migration-fly-io-gpus-will-be-deprecated-as-of-july-31-2026/27110) quotes one saying GPUs will be fully deprecated as of July 31, 2026, a date now passed. Fly's pricing page lists no GPU machines and both GPU doc URLs permanently redirect to that 2025 post, so notes also records the deprecation and the redirect. All three event citations were already in sources, so the list is unchanged; last_verified is 2026-10-23.
scrapybara: max_runtime already correct; verified, no field change
scrapybara: max_runtime already correct; verified, no field change
The event proposes setting Scrapybara's max_runtime to 24 hours. I fetched both cited pages and they check out: the start-instance API reference states timeout_hours accepts 0.01 to 24, and the best-practices guide says the timeout, which terminates an instance automatically, defaults to 1 hour. data/providers/scrapybara.json already records "24 h (configurable; 1 h default)", which states the same 24-hour maximum more fully, so I left the field alone rather than rewrite it to an equally-supported value. I refreshed last_verified to 2026-10-23; both citation URLs were already in sources, so that list is unchanged.
blaxel: event findings already on file, no field changes
blaxel: event findings already on file, no field changes
The event's only proposed change was setting Blaxel's wake_on_request to true. data/providers/blaxel.json already records true, so I changed no fields. I fetched both cited pages and they support the on-file value: the lifecycle blog says a standby sandbox "wakes up and restores the previous state" when it receives a request, and the Sandboxes overview says reconnecting transitions a sandbox back to active mode. Both URLs were already in sources, so the only edit is last_verified moving to 2026-10-23 to mark the re-verification.
No change: Ellipsis wake_on_request claim unsupported by cited page
No change: Ellipsis wake_on_request claim unsupported by cited page
The event proposed a single change for Ellipsis: wake_on_request from null to true, cited to the Sessions docs (https://www.ellipsis.dev/docs/cloud-agents/conversations). I fetched that page and it never says a stopped sandbox wakes on inbound traffic; it covers starting sessions, sending follow-ups, and stopping turns, and doesn't mention waking, sleeping, or idle sandboxes anywhere. The event's own reasoning describes a cooled conversation's sandbox being destroyed and a later message resuming in a fresh sandbox, and the Lifecycle page (https://www.ellipsis.dev/docs/sessions/lifecycle) agrees: when a conversation is not warm, the next message first prepares an environment, which takes longer. A prepared environment is a new sandbox, so the claim doesn't hold. I left data/providers/ellipsis.json unchanged, with wake_on_request still null; the cited URL was already in the file's sources list.
computer-agents: event findings already on file, no field changes
computer-agents: event findings already on file, no field changes
I fetched both cited pages and confirmed their claims; the file already records both, so no field value changed. The Environments page (https://computer-agents.com/environments) states that warm container pools ensure sub-second startup times, which cold_start already captures as 'Sub-second for warm container startup'. The computers doc (https://computer-agents.com/developers/core-concepts/computers) states that computers are billed by active runtime minute based on the selected ACP compute profile; the monitor flipped its usage_billed snapshot to true based on that statement, and this file has carried true since July, so no edit was needed. I left the event's appended phrase 'no general create/resume time stated' off cold_start: it notes missing evidence, the Environments page states no other startup figure, and spec strings stay short. Both citation URLs were already in sources, so the only edit is last_verified, now 2026-10-23.
northflank: idle compute free; isolation now names Cloud Hypervisor
northflank: idle compute free; isolation now names Cloud Hypervisor
Northflank's docs say pausing a sandbox scales it to zero and stops compute charges, while attached volumes keep billing per GB per month whether the sandbox runs or not (sandboxes-on-northflank-cloud.md, configure-and-manage-sandboxes.md). I confirmed both pages, so free_while_idle moves from false to true, and notes now carries the volume caveat, matching how this site records the same pattern for AWS Lambda MicroVMs and Morph. The product page names Cloud Hypervisor microVMs for CPU sandboxes and gVisor for GPU ones, and the quickstart says you select the runtime through cluster defaults or workload tags on your own cloud, so isolation now states all three facts in place of the shorter microVM/gVisor line. I also verified docker and max_runtime against the product page FAQ ("Yes. Docker runs inside the sandbox"; no time limits, sandboxes run until you delete them): the file already held both values, so I left them unchanged rather than rewording them. last_verified is today, and the three new doc URLs are in sources.
agent-substrate: GKE evaluation-only use, production via allowlist
agent-substrate: GKE evaluation-only use, production via allowlist
Updated the notes field in data/providers/agent-substrate.json, set
last_verified to 2026-10-22, and added the install overview URL to
sources. Google's install page
(https://docs.cloud.google.com/kubernetes-engine/ai-ml/install-overview-substrate)
states that Agent Substrate on GKE is available to all Google Cloud
customers for evaluation and non-production use, and that production
support is offered on an allowlist basis under a private GA program; I
verified both sentences on the page before editing. The new wording
replaces the file's less specific "Google offers GA production support
on GKE via allowlist" sentence. The pre-1.0 caveat and the
reconnect-after-suspend caveat are unchanged, because the event says
nothing about them, and no other fields changed: the event's changed
output covers only notes.
novita: duplicate quota snapshot, values already recorded, no change
novita: duplicate quota snapshot, values already recorded, no change
The event re-reports the Novita max_runtime snapshot that turn 20261022T172023Z already processed in commit 9cda727, byte for byte. I fetched both cited pages and they still state what the event quotes: the quota-limit doc caps sessions at 1 hour for Free, 3 hours for Paid, and 4 hours by default for Enterprise, adjustable (https://docs.novita.ai/guides/sandbox-quota-limit), while the product page advertises a 24-hour paid-tier session (https://novita.ai/sandbox). data/providers/novita.json already carries the quota-doc figures in max_runtime and records the 24-hour conflict in notes, both citations are already in sources, and last_verified is 2026-10-22. I edited nothing: swapping in the product page's 24-hour figure would replace one provider source with an equally-supported marketing claim, and the event's wording would drop the sourced long-running 7-day clause.
Add Agent Compute Engine and VAST agent sandbox stack
Add Agent Compute Engine and VAST agent sandbox stack
Created data/providers/agent-compute-engine.json and
data/providers/vast-agent-sandbox-foundation-stack.json; no existing
provider changed. Google's launch post and deep dive
(cloud.google.com/blog/topics/ai-infrastructure/) confirm Agent Compute
Engine is a purpose-built compute service that gives each agent a
hardware-isolated microVM, that developers control the environment's
image, identity, network access, and lifecycle, and that preview is
targeted for the coming months with no pricing announced. VAST's press
release, plus StorageNewsletter and SourceSecurity coverage, confirm
the Agent Sandbox Foundation Stack combines NVIDIA NemoClaw and
OpenShell with the VAST AI Operating System, with OpenShell handling
isolated execution and policy enforcement while VAST supplies
persistent state, and they state no pricing. I left runtime, cold
start, memory snapshot, GPU, Docker, and SDK fields null because no
cited page states them.
gke-agent-sandbox: no field changes; docker and idle costs reverified
gke-agent-sandbox: no field changes; docker and idle costs reverified
The event proposed docker true and free_while_idle false, and both already match data/providers/gke-agent-sandbox.json, so no field values changed. I fetched all three cited pages and they check out: the gVisor tutorial (https://gvisor.dev/docs/tutorials/docker-in-gke-sandbox/) documents building and running Docker containers inside a GKE Sandbox, though for GKE Sandbox generally rather than Agent Sandbox templates specifically, and the Agent Sandbox how-to (https://docs.cloud.google.com/kubernetes-engine/docs/how-to/agent-sandbox) states the add-on has no extra charge while GKE pricing applies to created resources and tells you to delete the cluster to avoid charges. The snapshots how-to (https://docs.cloud.google.com/kubernetes-engine/docs/how-to/agent-sandbox-pod-snapshots) confirms captured state uploads to a Cloud Storage bucket and recommends settings to avoid storage charges, which backs free_while_idle false. All three URLs were already in sources, so I added none, and I set last_verified to 2026-10-22 after verifying.
Update box-by-ascii notes: rename date, 14-day snapshot retention
Updated the notes field in data/providers/box-by-ascii.json. ASCII renamed Box to Boat on September 15, 2026, and the migration guide (https://docs.boat.dev/migrating-from-box) says the product, accounts, machines and data are unchanged. The snapshots page (https://docs.boat.dev/snapshots) now states that automatic snapshots are kept for 14 days after a sandbox stops and then deleted. The billing page (https://docs.boat.dev/billing) confirms a stopped sandbox costs nothing in machine time, while named snapshots above the first 10 cost $1.70 a month each and the AI credentials proxy costs $1 a day while on. I verified all three claims against the cited pages before editing, set last_verified to 2026-10-22, and added the migration and snapshots URLs to sources (billing was already listed). No other fields changed; the event's other values matched what the file already says or lacked new evidence.
novita: quota event confirms per-tier max_runtime; no field changes
novita: quota event confirms per-tier max_runtime; no field changes
The event reports Novita's per-tier session caps: 1 hour on Free, 3 hours on Paid, and 4 hours by default on Enterprise per the quota doc, while the product page claims a 24-hour paid session. I fetched both cited pages and confirmed every figure, checking the quota table's column alignment. data/providers/novita.json already states these facts: max_runtime lists the per-tier caps plus the 7-day long-running figure from docs.novita.ai/guides/sandbox-long-running, and notes records the 24-hour product-page discrepancy. I set last_verified to 2026-10-22 and added no source URLs, since both citations (https://novita.ai/sandbox, https://docs.novita.ai/guides/sandbox-quota-limit) were already listed. No field changed.
beam: re-delivered event; cold_start stays on provider-stated figures
beam: re-delivered event; cold_start stays on provider-stated figures
This event is a byte-identical re-delivery of the Beam snapshot handled earlier today (same event ID as the 17:06 UTC turn, resolved in commit a2be5b0). It proposes one change: rewriting cold_start to "Seconds (no typical measured duration specified)". I fetched both cited pages to check: docs.beam.cloud/v2/sandbox/overview says sandboxes "boot in seconds" and gives no number, while beam.cloud/sandbox states "Sandboxes cold boot in one to three seconds" under a "Sub-second boot times" heading. The current value, "Under 1 s warm, 1โ3 s cold (custom images)", already carries the provider's specific stated figure, and the data rules say to prefer the more specific stated figure and not to rewrite a field to a vaguer alternative. The event contains no real product change, so I edited nothing: last_verified already reads 2026-10-22 and both citation URLs were already in beam.json's sources.
fly: set price_headline to $2.19/month from pricing page
fly: set price_headline to $2.19/month from pricing page
Updated price_headline in data/providers/fly.json to "$2.19/month for a
started shared-cpu-1x Machine with 256 MB RAM in Ashburn or Secaucus,
assuming 30 days of continuous runtime; compute only". I fetched
https://fly.io/docs/about/pricing/ and confirmed the "What you pay for"
table lists the shared-cpu-1x 256 MB started Machine at $2.19/month, that
table prices apply to Ashburn (iad) and Secaucus (ewr), Fly's lowest-priced
regions, and that monthly prices assume 30 days of continuous runtime. The
old value, a $0.0000008465 per vCPU-second rate, no longer appears on the
page. The citation URL was already in sources, so I only bumped
last_verified to 2026-10-22. No other field changed.
e2b: re-delivered auto-resume event; no field changes
e2b: re-delivered auto-resume event; no field changes
The event re-delivers the same event_id the 02:07 turn already processed (commit af61656): the monitor's snapshot sets wake_on_request to true, citing https://docs.e2b.dev/sandbox/auto-resume. I fetched that page and it supports the value. With lifecycle autoResume enabled, a paused sandbox wakes on inbound traffic, and the page states "When an HTTP request arrives at a paused sandbox, the sandbox wakes up automatically to handle it". The lifecycle options table lists autoResume's default as false, so the capability stays opt-in, which the notes field already records. data/providers/e2b.json already carries wake_on_request true and lists that URL in sources; last_verified already reads 2026-10-22, which today's verification keeps accurate. I edited no field, and the event proposes nothing else.
e2b: auto-resume event confirms wake_on_request; no field changes
e2b: auto-resume event confirms wake_on_request; no field changes
The monitor's snapshot moves wake_on_request from null to true, citing https://docs.e2b.dev/sandbox/auto-resume. I fetched that page and it supports the value: with lifecycle autoResume enabled, a paused sandbox wakes on inbound traffic, and the page states "When an HTTP request arrives at a paused sandbox, the sandbox wakes up automatically to handle it". The page also lists autoResume's default as false, so the capability stays opt-in, which the file's notes already spell out. data/providers/e2b.json already records wake_on_request as true and already lists that URL in sources, so no field value or source changes. I refreshed last_verified to 2026-10-22 for this verification.
tencent-cubesandbox: re-delivered event; cold_start stays unchanged
The event re-delivers the same event_id the 01:11 turn already processed (commit 8a94764), proposing to rewrite cold_start to "~60 ms at single concurrency on bare metal; ~67 ms average under 50 concurrent creations" and citing https://raw.githubusercontent.com/TencentCloud/CubeSandbox/master/README.md. I fetched that README and its Benchmarks footnote does state those figures, but nothing here is new: the last commits touching the README (a September 7 sponsor removal and September 3 roadmap additions) don't touch the benchmark footnote. The bare-metal benchmark report the README links (https://raw.githubusercontent.com/TencentCloud/CubeSandbox/master/docs/blog/posts/2026-06-01-cubesandbox-perf-benchmark.md) still gives more specific figures: 47.8 ms average serial creation with min 43.5 / p95 57.4, and ~42 ms single resume. The PVM report gives ~67 ms serial creation, and the README's 67 ms average under 50 concurrent creations matches neither report, whose concurrency rows run far higher (276.1 ms average at 50-concurrent on bare metal). The lifecycle guide (https://raw.githubusercontent.com/TencentCloud/CubeSandbox/master/docs/guide/lifecycle.md) still puts auto-resume at sub-second to a few seconds. This field flipped five times between the README and the benchmark reports before the October 11 turn settled it on the benchmark's more specific figures, so the rule against rewriting to an equally-supported alternative applies. I edited no field, left last_verified at 2026-10-22 since this verification keeps it accurate, and added no sources because the README citation was already listed.
tencent-cubesandbox: no change; cold_start stays on benchmark figures
tencent-cubesandbox: no change; cold_start stays on benchmark figures
The event proposed rewriting cold_start to the README's "~60 ms at single concurrency on bare metal; ~67 ms average under 50 concurrent creations". I fetched the cited README and it does state those figures, but that text is unchanged since earlier turns weighed it, and the event offers no new evidence. The 2026-06-01 benchmark post behind the current value is still live and reports 47.8 ms average serial creation and 41.8 ms single-sandbox resume, and the lifecycle guide still puts auto-resume at sub-second to a few seconds, so the current field carries three figures the proposal would cut to two. This field has flipped between the README and the benchmark five times since August, and the 2026-10-11 turn settled it on the benchmark's more specific stated figures, so the rule against rewriting to an equally-supported alternative applies. I changed no field, set last_verified to 2026-10-22 after verifying the README, benchmark post, and lifecycle guide, and added no sources because the README citation was already listed.
computer-agents: keep free_while_idle true, re-verify computers doc
The event flips the monitor's free_while_idle from null to true for Computer Agents, and this file already records true, so no field value changed. I fetched the cited page, https://computer-agents.com/developers/core-concepts/computers, and it supports the claim: it bills computers by active runtime minute based on the selected ACP compute profile and documents stop() lifecycle controls, so a stopped computer accrues no billable minutes. I also checked https://computer-agents.com/pricing, which lists no idle, storage, or pause charge that applies while a computer is stopped. That citation URL was already in sources, so the list is unchanged. I set last_verified to 2026-10-22. The event proposed no other field changes.
ellipsis: pricing_model now covers Claude/Codex subscription billing
ellipsis: pricing_model now covers Claude/Codex subscription billing
The event reports one changed field for Ellipsis, pricing_model, and I verified it on https://www.ellipsis.dev/docs/pricing. The page says sessions you start yourself can bill model tokens to your Claude or Codex subscription at $0 to Ellipsis, while scheduled, event-triggered, API-key, and agent-started sessions use prepaid credits at the model's token rate; personal CPU and memory stay free, and organization compute still bills $0.141912 per CPU core-hour and $0.024192 per GiB-hour on allocated resources while a sandbox runs. I rewrote pricing_model to match and set last_verified to 2026-10-22. Two wording corrections to the event's proposal: personal compute is free under credits too, so I did not tie it to subscriptions alone, and the 10% platform fee stays tied to credit purchases because the page says it applies to purchases, not to individual sessions. The cited billing page (https://www.ellipsis.dev/docs/billing) only points back to Pricing, so it adds nothing; both citation URLs were already in sources. I changed no other field because the event's changed_output covers only pricing_model.
microsoft-azure: keep wake_on_request true, re-verify portal docs
The event flips the monitor's wake_on_request from null to true for Azure Container Apps Sandboxes, and this file already records true, set in the October 9 turn and re-verified since, so no field value changed. I fetched the cited page, https://sandboxes.azure.com/docs/sandboxes/, and it supports the claim: it says public ingress routes each port-specific hostname through an ingress proxy to one sandbox and can wake a stopped sandbox on request, and the architecture diagram labels that proxy "wake on request". That citation URL was already in sources, so the list is unchanged. I set last_verified to 2026-10-21. The event proposed no other field changes.
digitalocean-managed-agents: resume figure now about 300 ms
digitalocean-managed-agents: resume figure now about 300 ms
DigitalOcean's product page (https://www.digitalocean.com/products/managed-agents) now says sessions "resume paused work in about 300 milliseconds", where captures from October 1 and 4 showed the same sentence with 200 milliseconds, so I updated cold_start in data/providers/digitalocean-managed-agents.json and set last_verified to 2026-10-21. The new-session clause follows the page's wording, "first response in under a couple of seconds", and I kept the LangGraph cold start of about 20 s, which the run-langgraph-agent guide still states. The page's FAQ still says "resume takes about 200 milliseconds", so the page contradicts itself; I kept the headline figure because DigitalOcean just edited it and it is the primary claim. Both event citations were already in sources, so that list is unchanged, and I touched no other field.
openai-hosted-sandboxes: add older-environment lifecycle to notes
openai-hosted-sandboxes: add older-environment lifecycle to notes
Updated the notes for OpenAI Hosted Sandboxes with two facts I verified on the pre-warm guide (https://developers.openai.com/api/docs/guides/agents-api/environments/prewarmed.md): activity through the environment file API extends a shared environment's 20-minute idle lifetime, and older environments can still have a single-session lifecycle. I re-confirmed the remaining notes against the hosted-sandbox guide (https://developers.openai.com/api/docs/guides/agents-api/environments/openai-hosted.md). The event's proposed rewrite restated facts already in the file and dropped two others, the per-session workspace rule and the non-configurable timeout, so I kept the existing sentences and added the new material. last_verified is now 2026-10-21, both event citations are in sources, and no other field changed.
fly: docker already false; verified Docker docs, bump last_verified
The event's changed output covers a single field, docker, and proposes
false. data/providers/fly.json already records false; commit 22dd1b8 set
it on 2026-09-27 from the same documentation, so no field changed. I
fetched https://fly.io/docs/blueprints/working-with-docker/ and confirmed
what the page states: Fly.io doesn't run Docker containers, it uses Docker
images as a packaging format, and it unpacks each image into a root
filesystem for a lightweight VM with no Docker daemon. The file already
lists that URL in sources and the event cites only that URL, so the list
is unchanged; the only edit is last_verified, now 2026-10-21. The event's
previous snapshot answered true using a community thread about running a
Docker daemon inside a Machine, and the provider's own docs are the better
source, so false stands.
daytona: add macOS sandboxes on Apple silicon to isolation field
daytona: add macOS sandboxes on Apple silicon to isolation field
Daytona's isolation field now ends with "macOS sandboxes on dedicated Apple
silicon", a class the field didn't list before. The sandboxes page documents
macOS sandboxes running on dedicated Apple silicon hardware, and the isolation
page confirms the container, Linux and Windows VM, and GPU boundaries the file
already recorded (https://www.daytona.io/docs/en/sandboxes/,
https://www.daytona.io/docs/en/isolation/). I kept the file's more specific
wording for those three classes rather than adopting the event's shorter
paraphrase, which cites the same pages. Both URLs were already in sources, so
that list is unchanged, and last_verified moves to 2026-10-21. No other field
in the event had a basis for change.
runloop: note service wind-down, support ends Nov 13, 2026
runloop: note service wind-down, support ends Nov 13, 2026
Runloop's transition guide states that Runloop is winding down its services and that transition support for existing customers continues through November 13, 2026 at 11:59 PM PT. I fetched https://docs.runloop.ai/docs/transitions/overview and confirmed the statement appears on the page, so I replaced the notes field in data/providers/runloop.json with the wind-down notice, set last_verified to 2026-10-21, and added that URL to sources. The event's changed output matched its previous output on every other field, so it supports no further edits and I left the rest of the file alone.
box-by-ascii: no field changes; duplicate event already applied
box-by-ascii: no field changes; duplicate event already applied
The event redelivers event group mevtgrp_9f939278623fb3f65df7998a4254ed0ba191b2386f1d950d, which turn 20261020T172654Z already processed in commit 4dafe66 at 17:28 UTC today. I re-checked the cited page. https://docs.boat.dev/quickstart states that boat gives you full Ubuntu virtual machines (sandboxes) for AI agents and code, billed per second, and it shows control through the boat CLI, curl against the API, and Python and TypeScript SDKs. data/providers/box-by-ascii.json already carries every value the event supports: the name is boat by ASCII, and the summary already describes persistent Linux virtual-machine sandboxes with SSH access, Docker, and disk snapshots that can be resumed or forked, managed through the CLI, API, or Python and TypeScript/JavaScript SDKs. The file also lists https://docs.boat.dev/quickstart in sources and has last_verified set to 2026-10-20. The event's proposed summary restates those facts with less detail, so I left the summary alone rather than rewrite an equally-supported field.
runwork: no field changes; duplicate event already applied
runwork: no field changes; duplicate event already applied
The event redelivers event group mevtgrp_6a58452c8fd8b3ed24510feeb3b161ad73ca1765616ddacd, which turn 20261020T172223Z already processed and commit 2fe64ea applied at 17:24 UTC today. I re-checked both cited pages: Blaxel's Runwork case study (https://blaxel.ai/blog/runwork-accelerates-collaborative-enterprise-ai-workflows-by-10x-using-blaxel) states that a suspended sandbox resumes in under 25 milliseconds when a user request or webhook triggers the agent and that environment boot time dropped to 2-3 seconds, while Runwork's Agent Sandbox page (https://www.runwork.ai/features/agent-sandbox/) publishes no timing figures of its own. data/providers/runwork.json already carries every value the event supports: cold_start with the resume and boot figures attributed to the case study, free_while_idle true, and wake_on_request true. It also already lists both citation URLs in sources and has last_verified set to 2026-10-20, so I edited nothing.
runwork: resume <25 ms, boot 2-3 s, wake on request (Blaxel study)
runwork: resume <25 ms, boot 2-3 s, wake on request (Blaxel study)
Blaxel's Runwork case study states that a suspended sandbox resumes in under 25 milliseconds when a user request or webhook triggers the agent, and that environment boot time dropped to 2-3 seconds. I verified both statements on the cited page (https://blaxel.ai/blog/runwork-accelerates-collaborative-enterprise-ai-workflows-by-10x-using-blaxel), so runwork.json now records those figures in cold_start and sets wake_on_request to true, with the case-study attribution kept in the field text because Runwork's own sandbox page (https://www.runwork.ai/features/agent-sandbox/) publishes no timing figures. The previous cold_start text quoted Runwork's Edge Compute page, which describes app hosting rather than the Agent Sandbox, so replacing it was justified. free_while_idle was already true and needed no change; I updated notes to drop the stale claim that wake-on-request behavior was undocumented, set last_verified to 2026-10-20, and added the case-study URL to sources.
openai-hosted-sandboxes: rewrite notes, add Java/Go/Ruby SDKs
I updated data/providers/openai-hosted-sandboxes.json after confirming each claim on the cited pages. The new notes come from the OpenAI-hosted sandboxes guide (per-session workspace persistence, one-hour inactivity deletion with a non-configurable timeout) and the pre-warm guide (free pre-warming, 5-minute expiry for unattached environments, standard container pricing after attachment, shared environments with up to 128 attached sessions and a 20-minute idle lifetime). I extended sdks from Python and TypeScript to include Java, Go, and Ruby, because the hosted guide's examples run in Python, JavaScript, Go, Java, and Ruby, and the pre-warm guide names the Python, Node.js, Java, and Ruby SDKs. I dropped .NET from the event's proposed list: the SDK libraries page lists .NET as an official OpenAI API client, but no Agents API page documents it for this product, and the event's own reasoning concedes the libraries list does not guarantee Agents API support. I added the pre-warm and libraries pages to sources, deduplicated, and set last_verified to 2026-10-20.
Update fly-io-sprites pricing_model to hourly metering
Update fly-io-sprites pricing_model to hourly metering
The event proposed two changes for fly-io-sprites. I accepted the pricing_model
change: fly.io/sprites/ states "All resources are billed hourly, based on
actual usage", and fly.io/pricing/ says Sprites compute is "Metered per hour
of active use" with storage "Billed in GB-hours at two rates" and cold
storage billed "until you delete the data". That pricing page supersedes the
older per-second wording on fly.io/sprites/checkpoint-restore, which still
carries a single $0.50/GB-month storage rate that contradicts the current
two-tier GB-hour rates. I verified both pages directly.
I left max_runtime alone. The cited blog post does list "No time limits" among
Sprites' design properties, but the file already said "No fixed limit" with
that source cited; the event's "No fixed time limit stated" is an
equally-supported rewording, not a better-sourced value. All three event
citation URLs were already present in sources, so none were added, and
last_verified moved to 2026-10-20.
gke-agent-sandbox: no field changes; docker true reverified
gke-agent-sandbox: no field changes; docker true reverified
The event's snapshot changed only its docker assessment, from false to
true, citing https://gvisor.dev/docs/tutorials/docker-in-gke-sandbox/. I
fetched that page and it supports the value: it documents running Docker
inside a GKE gVisor sandbox, with a table of supported Docker and GKE
cluster versions and a NET_ADMIN requirement for Autopilot clusters. The
data file has carried docker: true since July 30 and already lists that
URL in sources, so I changed no field and added no source. I bumped
last_verified to 2026-10-20 after the check.
novita: add long-running mode (up to 7 days) to max_runtime and notes
novita: add long-running mode (up to 7 days) to max_runtime and notes
I fetched all four cited pages before editing. The long-running guide (https://docs.novita.ai/guides/sandbox-long-running) states that `long_running` metadata lifts the default 1-hour timeout cap and shows an example sandbox staying alive for up to 7 days, so `max_runtime` now ends with "up to 7 days with long-running mode" and `notes` gained a sentence explaining the mode. The quota guide (https://docs.novita.ai/guides/sandbox-quota-limit) still lists 1 hour free, 3 hours paid, and 4 hours adjustable enterprise, and the product page (https://novita.ai/sandbox) still advertises a 24-hour paid session, so I left the existing 24-hour-versus-3-hour conflict note as written rather than adopting the event's rewrite, which would have dropped verified facts about pausing and auto-resume. The pricing page (https://docs.novita.ai/guides/sandbox-pricing) re-confirmed the paused-storage billing already recorded, so I changed nothing there. I added the long-running guide URL to `sources` (the other three citations were already listed), and set `last_verified` to 2026-10-20.
agent37-cloud: auto-sleep is opt-in; memory restore not guaranteed
agent37-cloud: auto-sleep is opt-in; memory restore not guaranteed
I updated the notes in data/providers/agent37-cloud.json, set last_verified
to 2026-10-20, and added the event's three citation URLs to sources. The
notes now say auto-sleep is opt-in and that in-memory state usually
survives a wake but is not guaranteed, so anything that must outlive a
sleep belongs on disk. The create page states auto_sleep defaults to false
(https://www.agent37.com/docs/agents-api/instances/create), the auto-sleep
page says instances never sleep unless you opt them in and to treat
anything that must outlive a sleep as a file
(https://www.agent37.com/docs/agents-api/instance-auto-sleep), and the VM
page says an unusable checkpoint cold-boots the instance instead
(https://www.agent37.com/docs/agents-api/vm-instances).
I left out the event's claim that the docs now agree on VM sizes with a
4 vCPU maximum. The VM page's own pricing table still lists 8 and 16 vCPU
shapes at $45.08 and $90.16 per month, while the create page and the
instance sizing page state a 4 vCPU ceiling on every type. The size
discrepancy the monitor reported earlier still stands, so the notes say
nothing about shapes.
e2b: re-verified resume and Docker facts; no field changes
e2b: re-verified resume and Docker facts; no field changes
The event proposed two E2B values: a resume time of approximately 1 second for cold_start, with no new-sandbox create time stated, and docker set to true. Our data already held both facts from an earlier turn, and the event's previous snapshot was a stale baseline, so no field values changed. I re-checked the cited pages today: E2B's persistence docs say resuming takes approximately 1 second and state no create time (https://docs.e2b.dev/sandbox/persistence), the Docker template guide installs Docker in a sandbox and runs containers inside it (https://docs.e2b.dev/template/examples/docker), and the homepage says each sandbox boots from a snapshot without giving a create time (https://e2b.dev/). I set last_verified to 2026-10-20 and added the persistence docs URL to sources; the other two citations were already listed.
No change: Fly.io pricing page still lists $2.19/month
No change: Fly.io pricing page still lists $2.19/month
The event proposed lowering the Fly Machines price_headline to $2.02/month for a shared-cpu-1x Machine with 256 MB, citing https://fly.io/docs/about/pricing/. The page doesn't say that. Its pricing table lists a started shared-cpu-1x Machine with 256MB RAM at $2.19/month in Ashburn and Secaucus, Fly's lowest-priced regions, and its cost calculator prices shared CPU at $0.0000008465 per vCPU-second, which matches the price_headline already in data/providers/fly.json. No $2.02 monthly, $0.0028 hourly, or $0.00000078 per-second figure appears anywhere on the page, so no field changed and data/providers/fly.json stays as it is.
vercel: event restates cold_start figures, refresh date
vercel: event restates cold_start figures, refresh date
The event's only changed field is cold_start, and the file already states those facts: milliseconds for a fresh boot, snapshot restores p75 under 1 s and p95 about 5 s, which a September 19 turn wrote from the same blog post. I fetched both citations to check. The concepts page's "Sandboxes vs containers" table lists "Milliseconds (Firecracker optimized for fast boot)" as the Vercel Sandboxes startup time, with "Sub-second" in the Docker containers column, so the event read the right column. The snapshot-optimization post states p75 restores dropped from 40 s to under a second and p95 from 50 s to 5 s. The event's wording restates those figures at greater length, so cold_start keeps its current phrasing rather than flipping to an equally-supported alternative. Both citation URLs were already in sources. The only edit moves last_verified to 2026-10-20.
sailboxes: update notes for sleep/pause wake and reboot behavior
sailboxes: update notes for sleep/pause wake and reboot behavior
Verified the cited page, https://docs.sailresearch.com/sailboxes-lifecycle, and updated only the notes field in data/providers/sailboxes.json. The page states that sleep() powers a Sailbox down until network ingress, exec, or an explicit resume wakes it, that pause() holds one until an explicit resume, and that reboot() stops running processes and clears memory; notes now carries those distinctions. The old cold-resume caveat ("a checkpoint child starts cold if Sail cannot resume the saved memory") no longer appears on any cited Sail docs page, so I dropped it rather than keep an unsourced claim. I kept the checkpoint volume-sharing caveat, which the page still states, and set last_verified to 2026-10-20. The event proposed no other field changes, and its lifecycle citation was already in sources, so the deduplicated list is unchanged.
ellipsis: keep free_while_idle false, refresh verified date
ellipsis: keep free_while_idle false, refresh verified date
The monitor proposed flipping free_while_idle to true and rewriting notes, on the claim that the sessions doc distinguishes a warm, billed sandbox from an idle conversation whose sandbox is destroyed after an idle window. Neither cited page says that. The conversations URL (https://www.ellipsis.dev/docs/cloud-agents/conversations) redirects to the Sessions doc, which mentions no warm state, idle window, snapshot, or teardown; the Lifecycle and Environments pages don't either. The pricing page (https://www.ellipsis.dev/docs/pricing) supports the current value instead: Ellipsis bills organization compute for resources allocated "while a sandbox runs, including while it waits for your next message", so an idle sandbox costs money and free_while_idle stays false. The current notes match both pages, so they stay as they are. The only data edit moves last_verified to 2026-10-20; both citation URLs were already in sources.
langsmith-sandboxes: free_while_idle already false; no data change
langsmith-sandboxes: free_while_idle already false; no data change
The event sets free_while_idle to false for LangSmith Sandboxes, on the grounds that a stopped sandbox still accrues storage charges. data/providers/langsmith-sandboxes.json already records false, both citations (langchain.com/resources/best-agent-sandboxes and langchain.com/pricing) already sit in sources, and last_verified already reads 2026-10-19, because this is a re-delivery of the same event that turn 20261019T190855Z processed in commit 88a7a53. I re-checked both pages today: the resource article says stopping an idle sandbox ends compute and memory billing while its retained filesystem continues to incur storage charges until deletion, and the pricing page lists storage at 0.000123 LSU per GiB-hour with all rates billed per second. The proposed value stands confirmed, so I edited nothing.
aws-lambda-microvms: event reconfirms docker true, refresh date
aws-lambda-microvms: event reconfirms docker true, refresh date
The event's only change sets docker to true, citing the MicroVM images
documentation at https://docs.aws.amazon.com/lambda/latest/dg/microvms-images.html.
I fetched that page and confirmed it states that Lambda MicroVMs runs your
application as a container within the MicroVM operating system environment,
defined by your Dockerfile, which is the same bar other tracked products such
as AWS AgentCore Runtime meet for this column. The data file already carried
docker true and already listed that URL in sources, so the only edit is
last_verified, now 2026-10-19.
SPACE: keep sdks empty; tested E2B Python SDK is not a SPACE SDK
SPACE: keep sdks empty; tested E2B Python SDK is not a SPACE SDK
The monitor proposed one change for Perplexity SPACE: list Python in the sdks field, which the schema defines as official SDK languages. I fetched the cited README and confirmed the row it quotes, since the documentation table does point E2B Compatibility Wrapper readers at the tested E2B Python SDK. But the page never says SPACE ships a Python SDK. The same README says applications interact with SPACE over HTTP and server-sent events, and the first-sandbox walkthrough runs a standard-library-only Python example that needs no SDK. The wrapper guide describes the E2B Python SDK as a compatibility client for existing E2B applications, with only pinned e2b package releases covered by tests, and it says new integrations should normally use the SPACE API. The event's own reasoning agrees, calling Python a compatible client SDK rather than a native SPACE SDK, and the previous research run weighed this same evidence and kept the list empty. Listing Python would tell readers that an official SPACE SDK exists, so I left data/providers/perplexity-space.json unchanged. Sources checked: the README plus docs/ecw.md and docs/first-sandbox.md under raw.githubusercontent.com/perplexityai/SPACE/main/.
nvidia-openshell: isolation names libkrun MicroVMs, per-runtime fencing
NVIDIA's current docs support most of the event's proposed isolation wording, so `isolation` in `data/providers/nvidia-openshell.json` now reads "Driver-selected Docker or Podman containers, Kubernetes pods, or per-sandbox MicroVMs (libkrun-based); kernel controls include Landlock and seccomp, with runtime-specific network isolation". The [Sandbox Runtimes](https://docs.nvidia.com/openshell/latest/how-it-works/sandboxes/runtimes.md) page states that each gateway picks one compute driver and that the MicroVM driver runs each sandbox in its own lightweight VM, the [Architecture](https://docs.nvidia.com/openshell/latest/about/architecture.md) page documents the Landlock and seccomp kernel controls and the per-runtime egress fences, and the [Support Matrix](https://docs.nvidia.com/openshell/latest/about/support-matrix.md) states the MicroVM driver uses a libkrun-based runtime. I dropped the event's "or QEMU" wording because its only source, the GitHub file `architecture/compute-runtimes.md`, now returns 404, and no page in the current docs mentions QEMU; the VM driver's README says it embeds libkrun. I also removed the dead `architecture/sandbox.md` URL from `sources`, added the two doc pages above, and set `last_verified` to 2026-10-19.
brig: docker stays false; re-verified, cited non-goals URL 404s
The event proposes docker=false for Brig, and data/providers/brig.json already records false, so no field value changed. The cited non-goals page, https://www.brig.sh/docs/non-goals/, returns 404 and is absent from brig.sh's sitemap, so I left it out of sources. The same content is live at https://raw.githubusercontent.com/brig-sh/brig/main/docs/non-goals.md, already listed in sources, and it states that Brig "refuses nested containers, and a Docker daemon inside the guest", which answers this field's question of whether Docker containers can run inside the sandbox. The runtimes citation is live and already listed; it covers docker as a host-side runtime standing in for nerdctl, a different question. I re-verified the value against the live doc today, so last_verified moves to 2026-10-19.
opencomputer: no data change; cited sandbox-lifetime docs page 404s
opencomputer: no data change; cited sandbox-lifetime docs page 404s
The event proposed setting OpenComputer's max_runtime to an 8-hour cap for v2 sandboxes, citing https://docs.opencomputer.dev/sandboxes/lifetime. That URL returns 404, and its markdown endpoint returns "Page Not Found". The docs site now carries only /agents/ pages: the sitemap lists no lifetime page, the whole /sandboxes/ section is gone, and the site's complete documentation text states no 8-hour ceiling, no "v2 sandbox" runtime, and no hard end time anywhere. The one "lifetime" phrase it contains refers to per-command timeouts, and opencomputer.dev/sandboxes/lifetime just serves the marketing homepage. I left data/providers/opencomputer.json untouched because no live page supports the new value.
fly-io-sprites: compute billed per second, storage hourly
fly-io-sprites: compute billed per second, storage hourly
Updated pricing_model in data/providers/fly-io-sprites.json to "Usage-based: compute billed per second; storage billed hourly, with cold storage charged while retained", set last_verified to 2026-10-19, and added the event's citations to sources. I verified both pages first: the checkpoint-restore page (https://fly.io/sprites/checkpoint-restore) states "All compute resources are billed per second. Storage is billed hourly but aggregated monthly", and the sprites page (https://fly.io/sprites.md) lists storage rates per GB-hour with cold storage billed "for as long as you keep it". The sprites page and Fly.io's pricing page also say resources are "billed hourly" / "metered per hour of active use"; I kept the per-second wording for compute because it is the provider's explicit granularity statement, every rate is denominated per hour, and the sprites page's own worked example bills fractional CPU-hours (2.4 CPU-hrs), which hourly-chunk billing would not produce. No other fields changed.
daytona: re-verify docker=true, refresh last_verified
The monitor's snapshot sets Daytona's docker field to true, citing https://www.daytona.io/docs/en/snapshots/. I fetched that page and confirmed its "Run Docker in a sandbox" section states that sandboxes can run Docker containers inside them (Docker-in-Docker). data/providers/daytona.json already recorded docker as true, so no field value changed. I refreshed last_verified to 2026-10-19 and left sources as they were, since the page was already listed.
cloudflare: expand cold_start with benchmark context and FAQ range
cloudflare: expand cold_start with benchmark context and FAQ range
The event reports Cloudflare's durable_object scheduling policy for Containers. I verified both citations against the pages: the Cloudflare blog's ComputeSDK Burst TTI Benchmark table, which launches 100 sandboxes concurrently, shows a median time-to-interactive of 648 ms under the new policy (4.049 s on the previous scheduling path), and the Containers FAQ says cold starts can often be in the 1-3 second range. data/providers/cloudflare.json now states the 648 ms figure with the policy and benchmark conditions plus the FAQ range in cold_start, and last_verified moves to 2026-10-19. Both citation URLs were already in sources, so the list is unchanged. The event supports no other field changes, so I left the rest of the file alone.
ellipsis: duplicate event, no change; idle billing already recorded
ellipsis: duplicate event, no change; idle billing already recorded
This event re-delivers the same snapshot (event mevt_0468215707d7e42dcf6f0d85f849253f2a631da1e97fa04ae97fa04a) that turn 20261019T010405Z already applied in commit 0b57129. data/providers/ellipsis.json already records free_while_idle false and notes that a follow-up continues the same conversation and workspace while Ellipsis bills organization compute while the sandbox waits for the next message; last_verified is already 2026-10-19 and all three citation URLs are in sources. I re-checked the cited pages anyway: https://www.ellipsis.dev/docs/pricing states organization compute costs $0.141912 per CPU core-hour and $0.024192 per GiB-hour for resources allocated while a sandbox runs, including while it waits for the next message, and https://www.ellipsis.dev/docs/cloud-agents/conversations states a follow-up continues the same conversation and workspace. I left the file unchanged.
ellipsis: notes cover resumed conversations and billed idle time
ellipsis: notes cover resumed conversations and billed idle time
The event proposed free_while_idle: false and new notes for Ellipsis. The
file already said false, and the pricing page confirms it states organization
compute is charged for resources allocated while a sandbox runs, "including
while it waits for your next message", so that value stands and I bumped
last_verified to 2026-10-19. I rewrote notes around wording the cited pages
state: "A follow-up continues the same conversation and workspace"
(docs/cloud-agents/conversations), "A resumed session keeps its workspace,
including uncommitted changes" (docs/cloud-agents/sandboxes), and the
billing sentence from docs/pricing. I dropped the event's "preserved
workspace snapshot" phrase because no cited page calls the workspace a
snapshot; the docs say it is kept. All three event citation URLs were
already in sources, so that list is unchanged.
perplexity-space: set max_runtime to no fixed maximum, 6 h idle limit
perplexity-space: set max_runtime to no fixed maximum, 6 h idle limit
Set max_runtime from null to "No fixed maximum documented; the 6 h default suspend is an idle limit", and set last_verified to 2026-10-18. The architecture doc (https://raw.githubusercontent.com/perplexityai/SPACE/main/docs/architecture.md, added to sources) says sandboxes created through the SPACE API suspend after six hours without access or command activity and calls this "an idle limit, not a maximum lifetime"; the README and first-sandbox guide state no maximum either. The event's other citation, the Perplexity engineering blog, sits behind a Cloudflare challenge from this environment and no archive copy exists, so I left its "indefinite duration" phrasing out and grounded the value in the architecture doc.
agent-substrate: record <400 ms resume figure in cold_start
agent-substrate: record <400 ms resume figure in cold_start
Agent Substrate's README states that resume operations take less than 400 ms, and no page publishes a separate cold boot figure, so agent-substrate.json now carries "<400 ms to resume; cold boot time not stated" in cold_start. I verified both cited pages: the README (raw.githubusercontent.com/agent-substrate/substrate/main/README.md) and learn.agentsubstrate.dev/concepts/snapshot, which describes the resume workflow restoring an actor from its latest or golden snapshot and cold booting only when neither exists. I added the learn page to sources, set last_verified to 2026-10-18, and left every other field alone because the event's changed output covers only cold_start. The event proposed the new value in Spanish; I wrote the same claim in English to match the site.
No change: Docker Cloud Sandboxes usage_billed stays false
No change: Docker Cloud Sandboxes usage_billed stays false
Turn 20261018T171621Z already processed this same event (same event group and ID) and logged it as no change, and verification still holds. The event proposes flipping usage_billed to true, citing the plans page at https://docs.docker.com/subscription-billing/plans/docker-agentic-platform/ and the usage guide at https://docs.docker.com/ai/sandboxes/cloud/usage/. I fetched both and confirmed the quoted text. Neither page states billing on observed CPU use: the plans page says Docker meters compute in seconds based on sandbox runtime and the vCPU plus memory configuration chosen at setup, while the usage guide's line that compute isn't billed while stopped covers free_while_idle, which the file already records as true. Docker's promo page (https://www.docker.com/c/sbx-promo/) adds that billed time includes setup, idle time, and retries, so running time bills regardless of use. That is usage_billed false under the schema in box/providers.py, so I left data/providers/docker-cloud-sandboxes.json untouched, including its sources and last_verified.
No change: Docker Cloud Sandboxes usage_billed stays false
No change: Docker Cloud Sandboxes usage_billed stays false
The event proposed flipping usage_billed to true, citing https://docs.docker.com/subscription-billing/plans/docker-agentic-platform/ and https://docs.docker.com/ai/sandboxes/cloud/usage/. I fetched both pages and confirmed the quoted text, but neither states billing on actual CPU use. The plan page says Docker meters compute in seconds based on sandbox runtime and the vCPU plus memory configuration chosen at setup, and the usage guide's "Compute isn't billed while it is stopped" line covers stopped sandboxes, which the file already records as free_while_idle true. Docker's promo page (https://www.docker.com/c/sbx-promo/) adds that billed time includes setup, idle time, and retries, so running time bills regardless of use. That matches the schema's definition of usage_billed false, so I left data/providers/docker-cloud-sandboxes.json untouched, including its sources and last_verified.
google-cloud-agent-sandbox: free_while_idle stays false, add citations
The event resolved free_while_idle from unknown to false, and the site already recorded false, so no field value changed. I verified the citations on the live pages: Google's Agent Sandbox cost blog states that Pod snapshots checkpoint idle agents to persistent storage and release their physical CPU and memory back to the cluster, the Agent Sandbox Pod snapshots guide states that GKE uploads the captured state as snapshot files to a designated Cloud Storage bucket, and the Cloud Storage pricing page charges for data stored in buckets. A suspended sandbox therefore still incurs storage charges, which supports the existing false value. I set last_verified to 2026-10-18 and added the cost blog and Cloud Storage pricing URLs to sources; the snapshots how-to URL was already listed.
box-by-ascii: cold_start snapshot already applied; verified, no edit
box-by-ascii: cold_start snapshot already applied; verified, no edit
This event re-delivers the cold_start snapshot that commit 4532771 applied earlier today. I fetched the cited status page at https://status.ascii.dev/ and confirmed its metrics data: on Oct 18 create โ running averaged 1.5 s over 35 samples, and resume โ running averaged 3.1 s over 9 samples on the 15 GB suite. data/providers/box-by-ascii.json already states both averages, lists the status page in sources, and carries last_verified 2026-10-18. The event's proposed wording differs only by adding sample counts from the same page, so I left the field unchanged rather than rewrite an equally supported string.
beam: add blog-sourced cold start figures (warm <1 s, cold 1-3 s)
Updated cold_start in data/providers/beam.json from "1-3 s cold boot" to "Under 1 s warm, 1-3 s cold (custom images)". I fetched both cited pages and confirmed the claim on the blog itself: the sandbox hosting guide at https://www.beam.cloud/blog/mcp-server-sandbox states that "a warm custom image cold-starts in under a second, a cold one in one to three seconds". The docs page at https://docs.beam.cloud/v2/topics/cold-start describes what a cold start includes but gives no timing, so the figures stay attributed to the blog. Added that blog URL to sources (the docs URL was already listed), set last_verified to 2026-10-18, and changed nothing else, since the event supports only this field.
fly-io-sprites: monitor flips rejected; fields verified, date bumped
fly-io-sprites: monitor flips rejected; fields verified, date bumped
The monitor proposed two changes for Fly.io Sprites and I rejected both after fetching the citations. Its free_while_idle flip to false rests on cold storage billing while a Sprite sleeps, which fly.io/pricing has stated on every recent run ("Cold storage bills until you delete the data", $0.02 per GB-month) and which docs.fly.io/sprites/concepts/lifecycle has matched with "Compute billing stops" while paused. The September 23 turn already weighed that literal costs-nothing reading and settled the field on compute-free idling, the convention the site applies to Morph and Lambda MicroVMs, with the storage caveat carried in notes. The monitor has now flipped this field in two consecutive runs (false to true on October 17, true to false today), so accepting today's version would just resume the oscillation AGENTS.md warns against. Its price_headline value of $0.0385 per CPU-hour is a catch-up to its own empty previous snapshot: the file already carries that rate alongside the memory rate, and today's pricing page states both ($0.0385 / CPU-hour, $0.021875 / GB-hour), so the string stays. I verified the file's facts against both cited pages, set last_verified to 2026-10-18, and added the new docs.fly.io lifecycle URL to sources; the pricing URL was already listed.
Update box-by-ascii cold_start from Oct 18 status metrics
Update box-by-ascii cold_start from Oct 18 status metrics
boat by ASCII's status page (https://status.ascii.dev/) reports October 18
averages of 1.5 s from create to running (p99 2.7 s, 35 samples) and 3.1 s
from resume to running (p99 5.1 s, 9 samples, 15 GB suite). I confirmed both
figures against the page's metrics data before writing them, replacing a
vaguer "a few seconds" cold_start string. The event asked for no other field
changes, so I left the rest of data/providers/box-by-ascii.json alone and
only updated last_verified and added the status page to sources.
digitalocean-managed-agents: note Agent Droplets plans in pricing_model
digitalocean-managed-agents: note Agent Droplets plans in pricing_model
DigitalOcean's Harness Runtime pricing page now lists Agent Droplets, optional monthly subscription plans that discount eligible Managed Agents usage (Pro at $50 a month and 15%, Team at $200 and 20%). I fetched the page and confirmed the plan table and the discount details, and that the page bills sessions per second of active compute based on actual CPU consumption and memory allocated over time, with storage billed separately. I updated pricing_model to mention the plans, and corrected its memory wording from "peak memory used" to "allocated memory" because the page's billing basis for memory is "Actual memory allocated over time". The citation (https://docs.digitalocean.com/products/managed-agents/agent-harness-runtime/details/pricing/) was already in the file's sources, so the list is unchanged apart from setting last_verified to 2026-10-18.
runloop: gpu already true; refreshed last_verified only
runloop: gpu already true; refreshed last_verified only
The event reported Runloop's gpu field changing from null to true, citing https://docs.runloop.ai/llms.txt. I fetched that page and its Devbox entry describes an isolated Linux sandbox with shell, filesystem, networking, and optional GPU, so the claim holds. data/providers/runloop.json already had gpu set to true with that URL in sources, so the only edit this turn is last_verified, refreshed to 2026-10-18. No other fields changed.
aws-lambda-microvms: verify cold_start event; no data change needed
aws-lambda-microvms: verify cold_start event; no data change needed
The event proposed setting cold_start to "Near-instant launch/resume; AWS does not publish a numeric duration." I fetched both cited pages and the claim holds: the AWS News Blog says launches and idle resumes "achieve near-instant startup latency," and the Lambda core-concepts doc says image snapshots enable "near-instant launch and resume." Neither page states a figure. The data file already records this: cold_start reads "Near-instant; no numeric typical duration published," both event URLs are already cited, and last_verified is already 2026-10-17. Rewording a correct field to an equally-supported alternative would just make it flip between runs, so I made no edits.
Set Islo cold_start to ~380 ms and docker to true from BYOC post
Set Islo cold_start to ~380 ms and docker to true from BYOC post
Islo's BYOC announcement states that a fresh computer on its current cloud
setup boots in about 380 milliseconds, and that Docker runs inside a computer
alongside databases, browsers, and build tooling. I verified both claims
against the cited page (https://islo.dev/blog/introducing-islo-byoc/) and
updated data/providers/islo.json accordingly: cold_start moves from null to
the stated figure with its caveat about no separate resume time, and docker
moves from null to true. The post gives no separate resume-latency figure,
so the string keeps that qualification. Other fields in the event's snapshot
restated existing values from pages the site already cites, so I left them
alone rather than rewording equally-supported content. last_verified is now
2026-10-17 and the citation was added to sources.
fly-io-sprites: free_while_idle stays true; bump last_verified
The event's one changed field is free_while_idle, which the monitor's snapshot moves from false to true, and data/providers/fly-io-sprites.json already records true, so no field value changed. I fetched both citations before deciding. The lifecycle page (https://docs.sprites.dev/concepts/lifecycle/) states that a suspended Sprite freezes the VM in memory and "Compute billing stops", and the pricing page (https://fly.io/pricing/) states that CPU, memory, and hot storage bill only while a Sprite is awake, while cold storage bills until the data is deleted, at $0.02 per GB-month. Those facts are already on record. The September 23 turn settled this field on compute-free idling, with the cold-storage caveat carried in notes, the same convention the site applies to Morph and Lambda MicroVMs. The monitor's own reasoning admits it did not retrieve the storage rates this run; the page still states them, so its flip carries no new evidence. I set last_verified to 2026-10-17. Both citation URLs were already in sources, so the list is unchanged.
daytona: set wake_on_request true for persistent Linux sandboxes
daytona: set wake_on_request true for persistent Linux sandboxes
Set wake_on_request to true for Daytona and recorded the persistent Linux sandbox limitation in notes. The cited page, Daytona's own deployment at https://daytona-website-website-prod.daytona.workers.dev/docs/en/sandboxes, states that wake on request starts or resumes a stopped or paused sandbox when a request arrives through the Daytona proxy, and that the feature is available for persistent Linux sandboxes only. I confirmed that sentence on the page itself before editing, set last_verified to 2026-10-17, and added the URL to sources. The live docs at https://www.daytona.io/docs/en/sandboxes/ do not mention the feature yet, so the claim rests on Daytona's workers.dev deployment of the site. No other field changed.
fly: add suspend eligibility limits and volume billing to notes
fly: add suspend eligibility limits and volume billing to notes
Updated the notes field in data/providers/fly.json and set last_verified to 2026-10-17. The suspend-resume page (https://fly.io/docs/reference/suspend-resume/) lists the eligibility rules I added: a machine can use suspend only with 2 GB of memory or less, no swap, and no schedule. The billing page (https://fly.io/docs/about/billing/) supports the rootfs and volume charges now in the notes. I dropped the event's GPU sentence, which claimed Fly's GPU documentation says GPUs are deprecated and unavailable after August 1, 2026. That URL redirects to the February 2025 blog post "We Were Wrong About GPUs", which says "GPUs aren't going anywhere" and states no date; the August 1 figure traces to a user's question in a community thread, not to Fly's own docs. All three event citation URLs were already in the file's sources, so the list is unchanged.
No data change: Modal VM snapshot claim unverified on cited page
No data change: Modal VM snapshot claim unverified on cited page
The event proposed updating Modal's notes to say VM Memory Snapshots run only on the V2 Sandbox backend for enabled customers. Its citation, https://modal.com/docs/guide/vm-memory-snapshots, now redirects to https://modal.com/docs/guide/sandbox-snapshots, which says nothing about VM Memory Snapshots, a V2 backend, or enabled customers; Modal's Sandboxes and Memory Snapshots guides don't either, so I left the field alone. The Snapshots guide does confirm the event's remaining facts, that Memory Snapshots are Alpha, expire after 7 days, terminate the source Sandbox when taken, and that restored Sandboxes cannot use GPUs and must match the original instance type, but data/providers/modal.json already records all of them.
tencent-cubesandbox: free_while_idle and usage_billed now false
tencent-cubesandbox: free_while_idle and usage_billed now false
CubeSandbox now carries free_while_idle false, usage_billed false (previously null), and a pricing_model that names the optional Tencent Cloud Terraform deployment. The deploy guide (docs/guide/tencentcloud-terraform-deploy.md) hard-codes every cloud resource to pay-as-you-go, billed by the second and settled hourly, with compute CVMs at POSTPAID_BY_HOUR, and it tells operators to run destroy.sh after evaluation to avoid idle charges. The lifecycle guide still says a paused sandbox has zero CPU/memory cost, but that wording covers host resource accounting, not money: pause snapshots still consume storage, and on the Tencent Cloud deployment the nodes bill while they exist regardless of sandbox state. usage_billed is false because that deployment bills provisioned capacity for running time rather than observed use. The LICENSE page confirms the software stays Apache-2.0. I verified all three cited pages before editing, added the Terraform deploy guide and LICENSE URLs to sources, and set last_verified to 2026-10-17.
microsoft-azure: keep wake_on_request true, re-verify portal docs
The event flips the monitor's wake_on_request from null to true, and this
file already records true, set in the October 9 turn, so no field value
changed. I fetched the cited page,
https://sandboxes.azure.com/docs/sandboxes/, and it supports the claim: it
says public ingress routes each port-specific hostname through an ingress
proxy to one sandbox and can wake a stopped sandbox on request, and the
page's architecture diagram labels the ingress proxy "wake on request".
That citation was already in sources, so the list is unchanged. I set
last_verified to 2026-10-16.
nvidia-openshell: keep docker false, re-verify Docker-in-sandbox pages
The event flips the monitor's docker value from true to false, and this file
has recorded false since the October 1 turn, so no field value changed. The
monitor's earlier true treated the Docker compute driver as
Docker-in-sandbox support. The driver runs sandboxes as containers on the
gateway host, which says nothing about a Docker daemon inside a sandbox. I
fetched both cited pages and set last_verified to 2026-10-16. Issue #113
(https://github.com/NVIDIA/OpenShell/issues/113) states the sandbox image
has no Docker daemon, socket, or runtime, and that Seccomp, Landlock, and
capability restrictions block Docker workflows inside a sandbox; it
proposes designs for a secure in-sandbox daemon rather than shipping one.
Both citations are already in sources, with the runtimes page
(https://docs.nvidia.com/openshell/latest/how-it-works/sandboxes/runtimes.md)
listed without its .md suffix, so that list is unchanged.
agent-substrate: null out cold_start; resume claim is aspirational
agent-substrate: null out cold_start; resume claim is aspirational
I set cold_start to null in data/providers/agent-substrate.json. The docs now claim resume operations in less than 400ms with more than 1500 activations per second, but docs/architecture.md opens with "Much of this architecture is aspirational, and is not yet implemented!", and the benchmarking README defines the ResumeActor and ResumeActorCold metrics without publishing any typical result. No verified typical create-or-resume figure exists, so the sub-500 ms claim I removed is an aspiration rather than a measurement. I verified the pages by fetching them, added the event's two cited URLs (raw architecture.md and benchmarking/README.md) to sources, and set last_verified to 2026-10-16.
digitalocean-agent-droplets: keep pricing_model, re-verify pricing page
The event rewrites pricing_model because the pricing page now bills memory on
allocation over time and storage on capacity held over time, where the
monitor's earlier snapshot said peak usage. I fetched the cited page,
https://docs.digitalocean.com/products/managed-agents/agent-harness-runtime/details/pricing/,
and it states that basis, so the excerpts read the page correctly. This file
already records it: the 2026-10-14 turn moved memory billing from peak use to
allocation over time, and the live page still lists the Pro $50/month and
Team $200/month plan tiers that the proposed text drops. Replacing a
verified field with an equally sourced rewording would only lose detail, so
I left pricing_model unchanged and set last_verified to 2026-10-16. The
event's citation was already in sources, so that list is unchanged.
No data change: AgentCore idle-cost claim fails page check
No data change: AgentCore idle-cost claim fails page check
The event asked to set free_while_idle to true for AWS AgentCore Code Interpreter, quoting the pricing page line that I/O wait and idle time is free when no other background process runs. I fetched https://aws.amazon.com/bedrock/agentcore/pricing/ and the rest of that section disagrees: billing runs per second across the session lifetime including idle periods, memory bills at peak memory consumed with a 128MB minimum, and the page's own worked example charges 4GB of memory for a full 120-second session that spends 60% of its time in I/O wait. An idle session still incurs memory charges, so free_while_idle stays false and I edited no data files. The citation URL already appears in the file's sources, and the event proposed no other field changes.
opencomputer: price headline back to the agent-session machine rate
opencomputer: price headline back to the agent-session machine rate
The event changes one field, price_headline, and the cited page supports it: https://opencomputer.dev/pricing states the default agent-session machine as 2 GB / 1 vCPU at $0.00315/min, billed to the second, and prices the burst sizes separately ($0.00630/min for 4 GB / 2 vCPU, $0.01260/min for 8 GB / 4 vCPU), so the figure belongs to the default machine and not a neighboring tier. I dropped the previous $0.001/min headline because it comes from the unlinked rate card at https://opencomputer.dev/pricing.md, whose tiers do not match the primary page's rates, while the sandbox docs it fed return 404; OpenComputer's docs now cover Serverless Agents only, and its primary pricing page gives a single machine rate, the default agent-session machine. I touched no other field: the event's remaining values match its own prior snapshot, and their citations (docs.opencomputer.dev/sandboxes/timeout, /sandboxes/lifetime, /how-it-works) are dead pages. last_verified is 2026-10-16, and both cited URLs were already in sources, so that list is unchanged.
box-by-ascii: no change; life-of-Box snapshot claim unsupported
box-by-ascii: no change; life-of-Box snapshot claim unsupported
The event proposes replacing notes with the claim that stopped Boxes keep their filesystem snapshot for the life of the Box. I fetched all three cited pages and each states a 14-day limit instead: the FAQ (https://docs.ascii.dev/box/faq) says a stopped sandbox keeps its disk for free for 14 days, and the snapshots page (https://docs.ascii.dev/box/snapshots) says Boat keeps automatic snapshots for 14 days after a stop, then deletes them. The long-running-tasks page (https://docs.ascii.dev/box/long-running-tasks) confirms the one-hour default auto-stop, but that restates what the monitor already recorded and no field in data/providers/box-by-ascii.json needs it. The current notes, the Boat naming caveat, still holds: https://docs.boat.dev/snapshots/whats-saved still documents the legacy .boxignore name. The three event citations are already in sources, so I left the file untouched.
fly: keep $0.0000008465 per vCPU-second rate, verify pricing page
fly: keep $0.0000008465 per vCPU-second rate, verify pricing page
The event proposed rewriting price_headline to $0.00000085 per second for a shared-cpu-1x Machine with 256 MB in Ashburn or Secaucus. The pricing page (https://docs.fly.io/about/pricing/) states $2.19 per 30 days for that Machine, and its Started Fly Machines pricing data states the shared-CPU base rate as $0.0000008465 per vCPU-second, the exact figure already on record, with no markup for Ashburn or Secaucus. $0.00000085 per second is rounded arithmetic the page never states, since $2.19 spread over 30 days works out to $0.0000008449, so I left price_headline unchanged rather than replace a stated rate with a derived one. I set last_verified to 2026-10-16 and added the docs.fly.io pricing URL to sources; the event's billing citation was already listed.
E2B: note that auto-resume is opt-in, wake on request when enabled
E2B: note that auto-resume is opt-in, wake on request when enabled
Updated data/providers/e2b.json. The E2B auto-resume docs
(https://e2b.dev/docs/sandbox/auto-resume) state that autoResume defaults to
false and that paused sandboxes auto-resume on activity only when the option
is enabled in the lifecycle configuration; with it on, an HTTP request or SDK
operation wakes a paused sandbox. I fetched the page and confirmed each claim
before editing. The notes field now says auto-resume is opt-in and describes
what wakes a paused sandbox. wake_on_request stays true because the docs show
a paused sandbox wakes automatically on inbound traffic once autoResume is set,
and the citation URL was already in the sources list, so no additions were
needed. last_verified is now 2026-10-16. No other fields changed: the event's
evidence covered only notes and wake_on_request.
No data change: Modal free_while_idle claim unsupported by cited pages
No data change: Modal free_while_idle claim unsupported by cited pages
The event proposed setting free_while_idle to true for Modal Sandboxes. Neither cited page supports it. The Sandboxes guide (https://modal.com/docs/guide/sandboxes) describes a Finished Sandbox, one that stopped because its entrypoint exited, it was terminated, a timeout or idle timeout was reached, or it ran out of memory; the field tracks idle but still running Sandboxes, so a finished Sandbox is the wrong subject. The cold-start guide (https://modal.com/docs/guide/cold-start) says you are billed for resources used while a container is idle, such as GPU reservation or residual memory occupancy, which argues for false. modal.json keeps free_while_idle false, both citation URLs already appear in its sources, so no provider file changed.
cloudflare: set wake_on_request to false per current lifetime docs
cloudflare: set wake_on_request to false per current lifetime docs
Cloudflare's Sandbox lifetime page (developers.cloudflare.com/sandbox/concepts/lifetime/, updated Sep 30, 2026) says Cloudflare does not wake the Durable Object when its instance stops, and that after an instance stops, the next request that calls start() starts a new instance. I verified this against the page and against the getting-started guide, which shows start() as an explicit call in the developer's Durable Object code, and the Durable Object container API, which says exec() does not start a stopped container. A stopped sandbox therefore does not wake automatically on inbound traffic, so I changed wake_on_request from true to false in data/providers/cloudflare.json and set last_verified to 2026-10-16. The previous true came from the legacy 0.x SDK line about starting on first use and an inference from the Containers pricing page. The lifetime URL was already in sources, so that list is unchanged, and I left every other field alone.
tencent-cubesandbox: add roadmap note on cross-node preview
tencent-cubesandbox: add roadmap note on cross-node preview
The event proposed a full snapshot of the tencent-cubesandbox record, but only the notes field contains anything new. The lifecycle guide (raw.githubusercontent.com/TencentCloud/CubeSandbox/master/docs/guide/lifecycle.md) still states that a manual pause does not cancel idle reclamation and that a pause drops the sandbox's own outbound sockets, both of which our notes already covered, so I left those sentences as they were. The roadmap page (raw.githubusercontent.com/TencentCloud/CubeSandbox/master/docs/guide/roadmap.md) confirms that cross-node pause/resume landed in v0.7.0 as a preview and lists its performance work as upcoming, so I added that sentence to notes, added the roadmap URL to sources, and set last_verified to 2026-10-16. Every other field in the event already matches our current data, so I did not touch it.
aws-lambda-microvms: event reconfirms docker true, refresh date
aws-lambda-microvms: event reconfirms docker true, refresh date
The event's only change, docker, restates the value already on record. I fetched the cited page (https://docs.aws.amazon.com/lambda/latest/dg/microvms-images.html): it says Lambda MicroVMs runs your application as a container within the MicroVM operating system environment, and you define that container with your Dockerfile. The page says nothing about running a Docker daemon inside the MicroVM. The field tracks whether Docker containers run inside the sandbox, and the docs describe exactly that. docker=true has been on record since July, set from Aidan Steele's notes, and AWS's own documentation now confirms it. I changed no field value, set last_verified to 2026-10-15, and left sources unchanged because the cited URL is already listed.
aws-agentcore: event reconfirms free_while_idle false, refresh date
aws-agentcore: event reconfirms free_while_idle false, refresh date
The event's only change, free_while_idle, restates the value already on record. I fetched the cited pricing page (https://aws.amazon.com/bedrock/agentcore/pricing/) and confirmed the reasoning: the page says I/O wait and idle time are free if no background process is running, but its key details say billing covers the whole session, idle periods included, with memory charged on peak memory up to each second and a 128MB minimum. An idle session still bills memory, so false stands. I changed no field, set last_verified to 2026-10-15, and left sources as they are since the pricing page is already listed.
opencomputer: price headline $0.001/min from on-demand pricing page
opencomputer: price headline $0.001/min from on-demand pricing page
The event's pricing claim checks out, so price_headline now reads "$0.001/min for 1 GB RAM and 1 vCPU": https://opencomputer.dev/pricing.md lists On-Demand Compute at $0.001 per minute for 1 GB RAM and 1 vCPU ($0.06 per hour). The previous figure, $0.00315/min for the agent-session machine, came from docs at docs.opencomputer.dev/agent-sessions/overview.md, which now returns 404. I left notes unchanged: both pages the event cites for the eight-hour v2 ceiling and the hibernation and checkpoint behavior (docs.opencomputer.dev/sandboxes/lifetime and docs.opencomputer.dev/sandboxes/timeout) also return 404, and the current documentation contains no trace of those claims, so only the disk-overage sentence from the pricing page verifies. last_verified is 2026-10-15, and sources gains https://opencomputer.dev/pricing.md; I did not add the two dead docs URLs.
digitalocean-agent-droplets: no change; peak billing claim unsupported
digitalocean-agent-droplets: no change; peak billing claim unsupported
The event proposed rewriting the pricing_model field for digitalocean-agent-droplets to say DigitalOcean bills "actual CPU and peak memory usage" and storage "by peak usage". I fetched all three cited pages. The pricing page (https://docs.digitalocean.com/products/managed-agents/agent-harness-runtime/details/pricing/) states memory bills at $0.0095 per GB-hour on "actual memory allocated over time" and session storage at $0.05 per GiB-month on "actual capacity held over time". The word "peak" appears nowhere on that page, on the sessions page, or on the pay-for-harness-runtime page, and the event's own excerpts don't contain it either. The event's changed output covers only this field, and the current field already matches the page, so I left data/providers/digitalocean-agent-droplets.json untouched.
digitalocean-managed-agents: cold start already recorded, re-verified
The event's only change, cold_start, restates figures already on record. The Managed Agents product page says sessions go from creation to a first response in under a couple of seconds and resume paused work in about 200 milliseconds, and the file states both, along with a LangGraph cold start of about 20 seconds that the run-langgraph-agent how-to still documents. I left the field alone: the event's wording comes from the same product page and would drop that LangGraph figure. No fact changed, so I re-verified both pages and set last_verified to 2026-10-15.
Add Perplexity SPACE (open-source sandbox platform)
Add Perplexity SPACE (open-source sandbox platform)
Perplexity open-sourced SPACE, the sandbox platform behind its Computer
agent, under Apache 2.0 on October 15, 2026, so I created
data/providers/perplexity-space.json as a new product row. The
announcement (perplexity.ai/hub/blog/open-sourcing-space) states the
open-sourcing, pause and resume with state recovery, and credential and
network controls held outside the sandbox; the repository
(github.com/perplexityai/SPACE) states the Firecracker microVM isolation
and the Apache 2.0 license, and its architecture doc confirms that
suspending snapshots VM memory. I recorded memory_snapshots true on that
basis and left pricing fields as "no published rate" because the software
is self-hosted and no pricing was announced. Cold start, max runtime, GPU,
Docker, wake-on-request, and billing fields stay null since no cited page
states them. Cloudflare blocks direct fetches of the blog, so I read it
through a text-extraction proxy and cross-checked every claim against the
repository. I used the slug perplexity-space, following the site's
company-prefixed convention for generic product names like
nvidia-openshell.
morph: docker already on record; cite snapshot-setup docs
morph: docker already on record; cite snapshot-setup docs
The event moved the monitor's docker field for Morph Cloud from null to true,
citing the snapshot-setup guide at
https://cloud.morph.so/docs/documentation/instances/snapshot-setup. I fetched
that page and it supports the claim: the guide's example installs docker.io,
starts the Docker service, and runs two containerized services inside a Morph
VM. data/providers/morph.json already records docker: true, so no fact changed.
I added the cited URL to sources, deduplicated, and set last_verified to
2026-10-15. I left every other field alone because the event supported only the
docker change.
daytona: docker=true already recorded; reverified homepage, no data change
daytona: docker=true already recorded; reverified homepage, no data change
The event's only changed field was docker=true, which data/providers/daytona.json already records. I fetched the cited homepage (https://www.daytona.io/), which states "Easily Run Docker Containers Inside Daytona Sandboxes" and lists "Docker in Docker" support, so the existing value stands. The citation URL was already in the file's sources, so I only bumped last_verified to 2026-10-15.
No provider data change: Fly event proposals fail verification
No provider data change: Fly event proposals fail verification
I fetched both cited pages and left data/providers/fly.json unchanged. The suspend/resume page does state that resume takes a few hundred ms and a cold start takes ~2+ seconds for common apps, but the file already records both figures alongside two more timings that the machines overview page still states: well under 1 s to boot or start a stopped Machine, and low double-digit seconds to create a new one. The rewrite would only delete verified facts, so I kept the fuller value. The pricing page never states $0.00000075 per second. Its price table builds per-second prices from a base of $0.0000008465 per vCPU-second, no region prices below that base, and it lists shared-cpu-1x with 256MB at $2.19 per month, which matches the value already recorded in price_headline. last_verified already reads 2026-10-15, and both cited URLs (https://fly.io/docs/reference/suspend-resume/ and https://fly.io/docs/about/pricing/) were already in the file's sources list.
fly: no data change; timings already recorded, price figure unsupported
fly: no data change; timings already recorded, price figure unsupported
The event proposed changes to cold_start and price_headline, and neither holds up against the cited pages. The cold_start value restates timings the file already records, a few hundred ms to resume from suspend and about 2+ seconds to cold start (https://fly.io/docs/reference/suspend-resume/), and adopting it would drop the stopped-Machine start and create timings that the Machines overview still states (https://fly.io/docs/machines/overview/). The price_headline figure of $0.00000075 per second appears nowhere on the pricing page: that page's constants price shared CPU at $0.0000008465 per vCPU-second, and its regional markups only raise the base rate (https://fly.io/docs/about/pricing/). I changed no data fields, set last_verified to 2026-10-15, and left sources alone because both citation URLs were already listed.
cloudflare: docker already recorded; reverified docs, no data change
cloudflare: docker already recorded; reverified docs, no data change
The event's one substantive finding, Docker-in-Docker support (docker went
from null to true in the monitor's snapshot), was already recorded in
data/providers/cloudflare.json, so I changed no data fields. I reconfirmed it
on the Docker-in-Docker guide, which documents a rootless dockerd setup with
no iptables and ephemeral storage. The snapshot's other values match the file
or reword it: the Containers pricing page confirms the $0.000020 per
additional vCPU-second rate, 10 ms billing, and charges stopping on sleep,
and the lifetime page confirms public-beta snapshots that save the writable
root filesystem only. Its nulls for cold_start and gpu only mean the docs
state no figure, which doesn't overturn the file's cited values, so I left
both alone. I set last_verified to 2026-10-15 and added the event's three new
citations (Containers pricing, Sandbox limits, Sandbox SDK) to sources.
aws-lambda-microvms: record max_runtime as 8 h (28,800 s)
aws-lambda-microvms: record max_runtime as 8 h (28,800 s)
data/providers/aws-lambda-microvms.json is the only file changed. The RunMicrovm API reference (https://docs.aws.amazon.com/lambda/latest/microvm-api/API_RunMicrovm.html) gives maximumDurationInSeconds a valid range of 1 to 28,800 seconds (8 hours) before the platform terminates the MicroVM, and the MicroVMs docs page (https://docs.aws.amazon.com/lambda/latest/dg/microvms-launching.html) confirms the cap covers total lifespan including suspended time, so max_runtime now reads "Up to 8 hours (28,800 seconds)" instead of "Up to 8 hours". I added the event's two new citations, the API reference PDF and API_Resources.html, to sources and set last_verified to 2026-10-14. The event's SDK list already matched the file's nine languages, so it needed no edit; the Resources page the event cites for .NET lists only C++, Java, and Ruby, and the PDF excerpt lists eight SDKs, so that one attribution stays unverified and I left the list as-is. No other field changed, because the event reports no change to it.
agent-substrate: verified event, no fact changes; refreshed sources
agent-substrate: verified event, no fact changes; refreshed sources
The event proposed setting docker to true and rewording cold_start for Agent Substrate. I fetched both cited pages and changed neither field. The README (https://raw.githubusercontent.com/agent-substrate/substrate/main/README.md) states "sub-500ms resume operations", which the file's cold_start already records with the same support, so I kept the existing wording instead of swapping in an equally sourced alternative. The docker claim fails verification: the README says workloads run as standard OCI containers under gVisor, and the API guide (https://raw.githubusercontent.com/agent-substrate/substrate/main/docs/api-guide.md) defines actors by container image, but neither page says a Docker daemon or Docker-in-Docker runs inside an actor, and the README's only Docker mention is a dev-machine prerequisite for running kind. I set last_verified to 2026-10-14 and added the API guide citation to sources; the README URL was already listed.
digitalocean-agent-droplets: memory billed on allocation over time
digitalocean-agent-droplets: memory billed on allocation over time
DigitalOcean's Harness Runtime pricing page now bills each session per second on actual CPU consumption and memory allocated over time, replacing the old peak-memory basis. I fetched the cited page (https://docs.digitalocean.com/products/managed-agents/agent-harness-runtime/details/pricing/) and confirmed its table lists memory at $0.0095 per GB-hour on actual memory allocated over time, with no mention of peak use left anywhere on the page. The CPU rate of $0.044 per vCPU-hour and the Agent Droplets plan terms (Pro $50/month at 15%, Team $200/month at 20%) are unchanged, so those fields stay as they were. I updated pricing_model, corrected the same outdated "peak use" phrase in notes, set last_verified to 2026-10-14, and consolidated the duplicate pricing URL in sources to the event's citation. The event reports no other product changes.
modal: no change; idle sandbox still bills at max(request, actual)
modal: no change; idle sandbox still bills at max(request, actual)
A research snapshot for modal suggested free_while_idle could be true, citing the Modal sandbox-resources and sandboxes guides. I fetched both pages. The sandbox-resources guide says "Modal Sandboxes are billed by the second based on whichever is higher: your resource request or your actual usage" and "You pay for max(request, actual)", so a running Sandbox keeps accruing charges when idle. The sandboxes guide says the idle_timeout parameter terminates an inactive Sandbox rather than pausing it in a free state. The current data already says false, so no field changed and data/providers/modal.json is untouched.
# E2B: verify Docker field against docs, no value change
# E2B: verify Docker field against docs, no value change
The event is a snapshot for E2B whose only changed field is docker, set to true on the strength of https://docs.e2b.dev/template/examples/docker. I fetched that page and confirmed it describes a sandbox with Docker installed, shows `sudo docker run --rm hello-world` and an Alpine container run, and recommends at least 2 CPUs and 2 GB of RAM for running containers. data/providers/e2b.json already recorded `docker: true`, and the citation URL was already in `sources`, so the only edit is `last_verified`, now 2026-10-14. I left every other field alone: the event's previous snapshot is context, not a change, and the current values stay as they are.
daytona: SDK event confirms existing data; no fact changes
daytona: SDK event confirms existing data; no fact changes
A monitor snapshot reported Daytona's SDK list as Python, TypeScript, Ruby, Go, and Java, adding Java to the previously recorded four-language list. Both cited pages verify this: https://www.daytona.io/docs/en.md shows installation steps for all five SDKs, and https://www.daytona.io/docs/en/sandboxes/ includes Java code examples importing io.daytona.sdk. data/providers/daytona.json already lists all five, and both citation URLs were already in its sources, so no field changed. I rechecked the page's auto-stop wording ("0 disables the auto-stop functionality, allowing the sandbox to run indefinitely") and it supports the existing max_runtime value as-is. I updated last_verified to 2026-10-14 and added no new sources.
runloop: max_runtime now 48 h cap; free_while_idle to false
runloop: max_runtime now 48 h cap; free_while_idle to false
Runloop's Devbox API reference now documents a 48-hour maximum for
keep_alive_time_seconds, with a 1-hour default, so max_runtime in
data/providers/runloop.json changes from "Default 1 h, configurable; no
stated upper limit" to "Default 1 h, configurable; 48 h maximum". I
confirmed the sentence on
https://docs.runloop.ai/api-reference/devbox/create-a-devbox and
checked on https://docs.runloop.ai/docs/devboxes/start-stop that this
parameter is the Devbox lifetime setting; I added the API reference URL
to sources. I also set free_while_idle to false: the pricing page at
https://runloop.ai/pricing, already in sources, states that suspended
devboxes stop accruing CPU and memory charges but keep accruing storage
charges, so a suspended devbox is not free, which agrees with the file's
own notes. The event's research on every other field matches the file in
substance and differs only in wording, so I left those fields alone. I
set last_verified to 2026-10-14.
exe-dev: pricing_model now per-second metering on reserved capacity
exe-dev: pricing_model now per-second metering on reserved capacity
Updated pricing_model in data/providers/exe-dev.json from the hourly
description to "Per-second billing on reserved VM size while running; disk
and bandwidth may be billed separately." exe.dev's billing docs now state
that standalone VMs are charged in unit-hours at $0.105 per 2 vCPU / 4 GiB
unit-hour, with time measured by the second from creation until the VM
stops or is deleted, no minimum charge, and no rounding up to the hour.
I verified this on both cited pages,
https://exe.dev/docs/billing/usage and https://exe.dev/docs/standalone-vms;
the size table on the latter confirms $0.105 is the 2 vCPU / 4 GiB row.
Both URLs were already in the file's sources list, so no new sources were
added. I set last_verified to 2026-10-13. The event's only diff was
pricing_model, and its research notes on other fields (cold_start,
isolation, sdks) cite no supporting excerpts, so I left those fields alone.
box-by-ascii: no data change; Boat rebrand already recorded
box-by-ascii: no data change; Boat rebrand already recorded
The event snapshots the Box-to-Boat rebrand, which data/providers/box-by-ascii.json already reflects. The proposed summary matches the file word for word, the event's two citations (https://docs.boat.dev/sdks/overview and https://docs.boat.dev/api/v1) are already in sources, and last_verified is already 2026-10-13. I fetched both pages and confirmed the summary's claims: the SDK overview offers Python and TypeScript/JavaScript SDKs, and the API page describes creating, managing, and observing sandboxes from services, CI jobs, and product automation code. I kept the current notes because the event's replacement is vaguer; the file names .boxignore as a remaining Box reference, and https://docs.boat.dev/snapshots/whats-saved still documents that file. Nothing changed, so I edited no data.
opencomputer: keep price_headline; agent rate already recorded
opencomputer: keep price_headline; agent rate already recorded
The event proposes one field, price_headline, but the file already records its substance: $0.00315/min for the default 2 GB / 1 vCPU agent-session machine, billed to the second, which I confirmed on the live pricing page (https://opencomputer.dev/pricing). The proposed rewrite adds "Sandbox-specific price not stated", and that clause fails verification: the provider's own https://opencomputer.dev/pricing.md still lists sandbox on-demand compute at $0.001/min for 1 GB / 1 vCPU. The old sandbox docs return 404 and the docs index now covers Serverless Agents only, but the event supports no other field changes, so I left every product field alone and refreshed last_verified to 2026-10-13. The citation URL was already in sources.
box-by-ascii: refresh summary and notes for Boat branding
box-by-ascii: refresh summary and notes for Boat branding
I updated data/providers/box-by-ascii.json after verifying the event against the cited pages. The product and its refreshed documentation now use the Boat name: docs.boat.dev/sdks/overview and docs.boat.dev/api/v1 use Boat branding throughout, and the old docs.ascii.dev/box pages redirect to docs.boat.dev. The new summary says Boat by ASCII provides persistent Linux virtual-machine sandboxes with SSH access, Docker, and snapshots that can be resumed or forked, managed through the CLI, API, or Python and TypeScript/JavaScript SDKs, and the boat.dev site, the API page, and the SDK page state each of those facts. The new notes record that Box-era naming survives in references such as .boxignore files, which docs.boat.dev/snapshots/whats-saved still documents. I dropped the old notes' trial sentence (a 2-hour per-sandbox limit) because the current pricing page describes the trial as 25 free hours with 2 sandboxes at once. I set last_verified to 2026-10-13 and added docs.boat.dev/sdks/overview, docs.boat.dev/api/v1, and docs.boat.dev/snapshots/whats-saved to sources.
beam: add JavaScript to sandbox SDK languages
Beam's JavaScript/TypeScript SDK is documented as usable from JavaScript, so data/providers/beam.json now lists JavaScript in sdks alongside Python and TypeScript. I fetched both cited pages to confirm: the sandbox overview says "Both Python and TypeScript SDKs support sandboxes" (https://docs.beam.cloud/v2/sandbox/overview), and the SDK reference says `@beamcloud/beam-js` creates and manages Beam resources "from JavaScript or TypeScript" (https://docs.beam.cloud/v2/reference/ts-sdk). Beam's own navigation labels that reference "JavaScript / TypeScript". The event's changed output covered only the sdks field, so I left every other field alone, and both citation URLs were already in the file's sources, so the deduplicated list is unchanged. last_verified moves to 2026-10-13.
digitalocean-managed-agents: active CPU billing live; elastic now yes
digitalocean-managed-agents: active CPU billing live; elastic now yes
DigitalOcean's Harness Runtime pricing page and its docs counterpart no longer carry the footnote that billed CPU at 25% of allocated vCPUs while active CPU billing was "coming soon". Both pages now state each session is billed per second on actual CPU consumption, with the CPU charge falling to zero while an agent waits, so I set usage_billed to true and rewrote pricing_model on that basis. The launch announcement on the investor site says Managed Agents is in public preview and that DigitalOcean does not guarantee public-preview services perform for production-level workloads; that caveat replaces the stale 25% sentence in notes. The event's three citations were already in the file's sources, and I left every other field alone since the event reports no change to them.
Add Factory Environments, a new sandbox product row
Add Factory Environments, a new sandbox product row
Factory announced Environments, the sandboxes its Droid coding agents run
on, as generally available on all plans. The announcement tweet, Factory's
news post (factory.com/news/droids-now-have-a-fleet-of-sandboxes), and
Factory's product page (factory.com/product/cloud-agents) confirm the
facts I recorded: an Environment is a reusable, centrally managed
definition of repositories, tools, and dependencies, which Factory builds
into a portable image and rebuilds every few hours, promoting only builds
that pass validation. The hermes-ai.net write-up and factory.com/bensbites
corroborate the launch. I created data/providers/factory-environments.json
with those facts and left pricing, runtime, isolation, and SDK fields
null because no cited page states them.
scrapybara: Capy pivot already recorded; verified, no field change
scrapybara: Capy pivot already recorded; verified, no field change
The event proposed rewriting Scrapybara's notes to describe the pivot toward Capy, the AI software engineer, while the docs still describe remote desktop instances. The file already records that pivot: its notes quote the homepage line verbatim and carry details the proposed text drops, like the Windows 2x compute multiplier and the unexplained warm_pool status. I verified the event's claims at scrapybara.com, docs.scrapybara.com, and docs.scrapybara.com/best-practices.md; those pages state the Capy line, remote desktop instances for computer-use agents, and per-usage billing with a 1-hour default timeout and no stated charge for paused instances. No field changed, so I only bumped last_verified to 2026-10-13 and added the one new citation URL (https://docs.scrapybara.com/best-practices.md) to sources.
daytona: reverify $0.0504/vCPU-hour price, no other change
daytona: reverify $0.0504/vCPU-hour price, no other change
The event reported Daytona's headline price as $0.0504 per vCPU-hour, newly cited to the official pricing page (https://www.daytona.io/pricing). I fetched that page and confirmed the table lists Compute at $0.0504/h per vCPU, with Memory at $0.0162/h per GiB and Storage at $0.000108/h per GiB after the first 5 GiB free, so the figure sits on the vCPU row and is not lifted from a neighbouring tier (Windows compute is priced separately at $0.0858/vCPU/h). data/providers/daytona.json already carried this value and already cited the pricing page, so the only edit was bumping last_verified to 2026-10-13. No other field in the event changed.
tencent-cubesandbox: add pause caveats for sockets and scheduler quota
tencent-cubesandbox: add pause caveats for sockets and scheduler quota
The snapshot event changed only the notes field for tencent-cubesandbox. I fetched the cited lifecycle guide (https://raw.githubusercontent.com/TencentCloud/CubeSandbox/master/docs/guide/lifecycle.md) and confirmed each claim on the page before editing: a pause drops outbound sockets the sandbox itself opened and the application must reopen them after resume, and the node counts paused sandboxes against scheduler quota by default (paused_resource_release_ratio defaults to 0) even though pausing physically reclaims their CPU and memory. data/providers/tencent-cubesandbox.json now carries both caveats in notes, and last_verified moves to 2026-10-13. The citation URL was already in the file's sources, so the deduplicated list is unchanged. The event's replacement text omits details the file already cites from release pages, so I merged the new caveats into the existing notes instead of replacing them. No other field changed.
ellipsis: keep wake_on_request null; docs show no sandbox wake
ellipsis: keep wake_on_request null; docs show no sandbox wake
I changed nothing in data/providers/ellipsis.json. The event proposes wake_on_request: true, citing https://www.ellipsis.dev/docs/sessions/lifecycle and https://www.ellipsis.dev/docs/cloud-agents/sandboxes. The lifecycle page says a message to a non-warm conversation "first prepares an environment, which takes longer", and the sandboxes URL now redirects to https://www.ellipsis.dev/docs/environments, which says only that "a resumed session keeps its workspace, including uncommitted changes". Neither page states that a stopped sandbox wakes on inbound traffic, and the event's own reasoning concedes "it is not the same sandbox waking with its prior RAM intact"; the prior snapshot in the same payload reads the same behavior as false for exactly that reason. box/providers.py defines the field as a stopped sandbox waking automatically on inbound traffic, so it stays null. Turns on 2026-10-08 rejected this same proposal on the same evidence (commit f30c256 and the re-delivery after it), and with no fact changing, last_verified and the sources list stay as they are.
northflank: no change; max_runtime fact already recorded
northflank: no change; max_runtime fact already recorded
The only field in the event's changed output is max_runtime. I fetched the cited page (https://northflank.com/product/sandboxes) and confirmed it says sandboxes have "no forced time limits" and can run "for seconds or weeks". data/providers/northflank.json already records max_runtime as "No fixed limit" and already cites that same page (last verified 2026-09-23), so the event restates a fact the file carries from the same source. Swapping the value would trade a short spec string for a longer, equally supported one, so I left the field and the file untouched. The event's other fields are monitor snapshot context, not changes. No data changed this turn.
exe-dev: re-verified docs, no field changes
The monitor proposed price_headline "$0.105 per 2 vCPU per hour for standalone reserved capacity". I fetched the cited page, https://exe.dev/docs/standalone-vms, which states that a standalone VM's reserved capacity is metered at $0.105 per 2 vCPU / 4 GiB unit-hour, the same rate as pool capacity. data/providers/exe-dev.json already records that rate in price_headline ("standalone sandboxes are $0.105 per 2 vCPUs per hour") with that page in sources, so I left the wording alone rather than swap one supported phrasing for another. The event's second citation, https://www.exe.dev/usage-pricing, returns 404, and its non-www twin is already listed, so sources gained nothing. I set last_verified to 2026-10-12 after also checking https://exe.dev/pricing, which still shows $15 / month for a Personal 2 vCPU pool and $0.105 per 2 vCPUs / 4 GiB per hour.
No data change needed; langsmith pricing already correct
No data change needed; langsmith pricing already correct
The event covered LangSmith Sandboxes pricing and idle behavior, but data/providers/langsmith-sandboxes.json already holds the values the evidence supports. I fetched both cited pages to check. The pricing page (https://docs.langchain.com/langsmith/pricing-plans) lists sandbox rates of 0.0576 LSU per vCPU-hr, 0.01845 LSU per GiB-hr, and 0.000123 LSU per GiB-hr, all billed per second, with 1 LSU = $1, which matches the file's price_headline and pricing_model exactly. The event's proposed price_headline was not applied: its excerpt reports memory as $0.0185 per GiB-hour, but the page states 0.01845, and the current field already carries the correct, more complete figure. The snapshot docs (https://docs.langchain.com/langsmith/sandbox-snapshots) confirm that a stopped sandbox keeps its filesystem and wakes on the next request, supporting the file's wake_on_request: true and free_while_idle: false, so no field changed. I set last_verified to 2026-10-12 and added the pricing-plans URL to sources, which was not previously listed; the snapshots URL was already there.
agent-substrate: monitor confirms free_while_idle and usage_billed
agent-substrate: monitor confirms free_while_idle and usage_billed
The event's snapshot sets free_while_idle and usage_billed to true, citing
Google's GKE Agent Substrate documentation. I fetched
https://docs.cloud.google.com/kubernetes-engine/ai-ml/about-agent-substrate
and confirmed the page states that idle agents are suspended and not using
CPU and memory, so you pay for compute only when agents are actively
processing tasks. data/providers/agent-substrate.json already recorded both
fields as true and the cited URL was already in sources, so the only edit is
last_verified, bumped to 2026-10-12.
islo: memory_snapshots true; pause restores in-memory state
islo: memory_snapshots true; pause restores in-memory state
Islo's CLI reference for `islo pause` states that files, processes, and in-memory state are restored on resume, so I set memory_snapshots to true in data/providers/islo.json, added https://docs.islo.dev/cli/sandbox-commands.md to sources, and set last_verified to 2026-10-12. The live docs domain returns HTTP 451 right now, and I confirmed the sentence against the Wayback copy of that page from 30 September 2026, which matches the event's excerpt. I left docker null: the cited blog post lists `docker compose up` among the commands of a typical agent session on a nontrivial repository, and it never says Docker containers can run inside an Islo sandbox.
openai-hosted-sandboxes: re-verified docs, no field changes
openai-hosted-sandboxes: re-verified docs, no field changes
This snapshot event contains no change to tracked facts: its only populated value, an SDK list of TypeScript and Python, matches the file's existing Python and TypeScript entries, so I left that field alone. I checked the live pages, and the sandbox agents guide states "Sandbox agents are available in the TypeScript and Python Agents SDKs", the hosted-sandbox guide still describes the Linux workspace and the one-hour inactivity deletion, and the pricing page still lists the per-20-minute container rates with minute billing and a 5-minute minimum. I set last_verified to 2026-10-12 and added the event's three new citations (Agents API overview, sandbox lifecycle, Agents SDK) to sources. The event's other fields are null and the docs don't settle them, so they stay null.
Add DigitalOcean Signals to the Managed Agents summary
Add DigitalOcean Signals to the Managed Agents summary
The event reports that DigitalOcean Signals entered public preview for Harness
Runtime agents. I updated only the summary in
data/providers/digitalocean-managed-agents.json to name Signals alongside
Harness Runtime and Action Gateway. The architecture page confirms Signals
analyzes conversations from Harness Runtime, the release notes state it is in
public preview as of 8 October 2026, and the product page confirms the
Firecracker microVM and OCI-image claims. I added the release-notes URL to
sources and set last_verified to 2026-10-12. No other field changed: the event
proposed changes to the summary alone, and the rest of its payload matched
what the file already records.