What's new in 0.11.0¶

Published on 2026-10-13: Python SDK rayito 0.11.0, TypeScript SDK rayito 0.11.0 and rayd 0.11.0.

0.11.0 brings three things:

Agent images start sooner. AgentTemplate no longer warms up the run_code kernel and puts the agent binaries into the memory snapshot. create() returns in about 6 s instead of about 19 s. It is a behavior change for anyone who uses run_code with numpy or pandas on the agent image: how to go back to the previous behavior.
Per-run artifact keys when publishing images (rayito image publish --artifact-run-id), so two parallel runs neither share nor delete each other's zip.
The TypeScript SandboxPool no longer lets Node exit while take() or close() wait.

There are no API-breaking changes. To take advantage of point 1 you have to rebuild the agent image: see How to upgrade from 0.10.x.

At a glance¶

Change	Python	TypeScript	Needs a new image
`AgentTemplate` without warming up the `run_code` kernel by default	`kernel_warmup=False`; CLI `--kernel-warmup/--no-kernel-warmup`	`kernelWarmup: false`	yes, the agent's
OpenCode and ripgrep binaries inside the memory snapshot	`AgentTemplate(prefetch=True)` (default)	`prefetch: true` (default)	yes, the agent's
Per-run artifact keys	`rayito image publish --artifact-run-id`	— (the CLI is Python)	no
The pool's `take()` and `close()` hold the process	—	`SandboxPool`	no
`rayito doctor` knows the 0.11 series	CLI	—	—

The agent starts sooner¶

Each Sandbox.create() of an agent image restores a memory snapshot. Up to 0.10, that snapshot carried the run_code kernel with numpy, pandas, matplotlib, scipy and scikit-learn already imported, even though an agent almost never uses them, and the OpenCode and ripgrep binaries had to be read from disk on the first turn. 0.11.0's AgentTemplate changes both:

The run_code kernel is not warmed up (kernel_warmup=False / kernelWarmup: false). The image writes the sidecar's slim marker, so the kernel starts empty.
The agent binaries go into the snapshot. The prefetch daemon reads them once during the build, before the snapshot, and the template waits for it to finish (ready_cmd).

You change nothing in your code: just rebuild the image.

PythonTypeScriptCLI

from rayito import AgentTemplate

info = AgentTemplate(name="rayito-agent").build(bucket="amzn-s3-demo-bucket")
print(info.build_id)  # "<image version>/<build>"

import { AgentTemplate } from "rayito";

const info = await new AgentTemplate({ name: "rayito-agent" }).build({ bucket: "amzn-s3-demo-bucket" });
console.log(info.buildId); // "<image version>/<build>"

rayito agent template build --name rayito-agent --bucket amzn-s3-demo-bucket

Measured on real AWS (2026-10-13, us-east-1, Claude Haiku 4.5)

In 0.11.0's acceptance, with a freshly built AgentTemplate image, closed egress and the model through bedrock_gateway, six OpenCode starts (three from Python and three from TypeScript): create() at a median of 5.9 s (from 3.2 to 8.9 s) and the first token at a median of 12.8 s from the start of create() (from 9.7 to 37.0 s). It matches the change's measurement (AWS_API_NOTES.md Q155 and Q156: 6.4 s versus 19.1 s with the 0.10 image, and a memory snapshot 62 MB smaller). The first token varies a lot from one run to another, so the robust improvement is create()'s.

If you use `run_code` with the scientific stack¶

This is the behavior change. On an agent image built with 0.11.0, the first run_code cell that imports numpy, pandas, matplotlib, scipy or scikit-learn pays for that import; later ones do not. The images you already had do not change.

If your agent or your code uses those libraries right at startup, go back to the 0.10 behavior when building the image:

PythonTypeScriptCLI

from rayito import AgentTemplate

AgentTemplate(name="rayito-agent", kernel_warmup=True).build(bucket="amzn-s3-demo-bucket")

import { AgentTemplate } from "rayito";

await new AgentTemplate({ name: "rayito-agent", kernelWarmup: true }).build({ bucket: "amzn-s3-demo-bucket" });

rayito agent template build --name rayito-agent --bucket amzn-s3-demo-bucket --kernel-warmup

With kernel_warmup=True, create() takes what it did in 0.10 again and the memory snapshot goes back to its previous size. Details in Agent templates.

Per-run artifact keys¶

rayito image publish uploads the image zip to a content-addressed key (rayito/images/rayd-<sha>.zip). If two runs published the same commit at the same time (two parallel e2e runs, or an acceptance), they shared that object, and one's cleanup could delete the other's. With --artifact-run-id, the zip goes to a key of the run's own:

rayito --json image publish --artifact rayito-image.zip --base-image-version 1 \
  --bucket amzn-s3-demo-bucket --image-name rayito-e2e-base --artifact-run-id e2e-42
# uploads to rayito/images/runs/e2e-42/rayd-<sha>.zip

The --json summary adds artifactUploaded: true if this invocation uploaded the object. When cleaning up, delete only rayito/images/runs/<id>/ or, without an id, only the artifacts with artifactUploaded: true. From the repository, make image-publish* passes the flag if you export RAYITO_E2E_RUN_ID or ARTIFACT_RUN_ID. Without the flag nothing changes. Details in CLI.

The TypeScript pool no longer lets Node exit¶

In TypeScript, all of the SandboxPool's timers and those of its warm-ups were unreferenced, so that an idle pool does not keep the process alive. The side effect: a script whose only pending work was await pool.take({ waitMs }) (with the pool empty) or await pool.close() (with a refill in progress) exited with the promise unresolved (unsettled top-level await, code 13) and left the MicroVMs that were warming up alive.

Since 0.11.0, take() and close() hold the process while they run. An idle pool still does not keep it alive. You do not have to change your code:

import { SandboxPool } from "rayito";

const pool = await new SandboxPool({ size: 1, template: "rayito-base" }).start();
const sbx = await pool.take({ waitMs: 60_000 }); // waits for the first slot without Node exiting
console.log((await sbx.runCode("1 + 1")).text);
await sbx.kill();
await pool.close(); // terminates the parked slots before exiting

The Python SDK did not have the problem.

Other changes¶

rayito doctor knows the 0.11 series: it requires the rayd from the rayd-v0.11.0 tag for SDK 0.11 (Compatibility).
rayd 0.11.0 does not change: version in step with the SDKs.

How to upgrade from 0.10.x¶

Upgrade the SDK.

PythonTypeScript

pip install -U "rayito[cli]"

pnpm add rayito@latest

Republish your image on rayd 0.11.0 (Images). rayito doctor requires the rayd from the rayd-v0.11.0 tag for SDK 0.11 and gives FAIL on the compatibility check with a 0.10 image.
If you use the agent, rebuild its image with AgentTemplate or rayito agent template build so it starts sooner. If your code uses the scientific stack in run_code, pass kernel_warmup=True (above).

There are no incompatible changes in the public API from 0.10.x.