What's new in 0.15.0¶

Published on 2026-10-21: Python SDK rayito 0.15.0, TypeScript SDK rayito 0.15.0 and rayd 0.15.0.

0.15.0 brings rayito setup, one command that prepares the account and the region, and lets you deploy the agent you already have to Amazon Bedrock AgentCore Runtime with the same command as 0.14 and one more option: --target agentcore. The default target is still a MicroVM fleet, and nothing changes for anyone who does not use it.

Everything that costs money is still off by default: without --target agentcore nothing is created and no AgentCore, CodeBuild or ECR client is loaded, and --dry-run makes no AWS call.

`rayito setup`: prepare the account in one command¶

rayito setup does in one idempotent command what used to be several manual steps, like cdk bootstrap. It reads the account, shows the plan and the approximate cost, asks for confirmation (--yes; --dry-run only reads) and ends with rayito doctor:

rayito setup --dry-run   # the plan and the cost; read-only
rayito setup             # reuses or creates the bucket, creates the IAM stack and publishes rayito-base

Artifact bucket. It reuses --bucket, RAYITO_BUCKET, the IAM stack's or the CDK bootstrap's; if there is none, it creates one with the rayito-m0-artifacts stack (encrypted, private, TLS only). It always checks that the bucket belongs to your account: one with the same name in another account is not reused.
IAM stack rayito-m0-iam, created, or updated when the bucket changed.
Base image rayito-base, from the rayito-image.zip of your version's release (checked against its SHA256SUMS) or from --artifact. An interrupted build is resumed instead of starting another.

Errors have a closed code (bucket_unavailable, bucket_taken, artifact_stack_conflict…) and with --json the output is a single document. rayito agent deploy and deploy_agent() find the bucket it created. Step by step: Configure AWS.

An agent on AgentCore¶

CLIPythonTypeScript

rayito agent deploy ./my-agent --target agentcore --dry-run   # the plan, the security notes and the cost; no AWS call
rayito agent deploy ./my-agent --target agentcore \
  --bedrock-model us.anthropic.claude-haiku-4-5-20251001-v1:0
rayito agent invoke my-agent "Summarize the README." --target agentcore

from rayito import AgentCoreOptions, AgentDeployOptions, deploy_agent

fleet = deploy_agent(
    "./my-agent",
    options=AgentDeployOptions(bucket="amzn-s3-demo-bucket"),
    target="agentcore",
    agentcore=AgentCoreOptions(
        bedrock_models=("us.anthropic.claude-haiku-4-5-20251001-v1:0",),
    ),
)
reply = fleet.invoke("Summarize the README.")
print(reply.text, reply.session_id)

import { deployAgent } from "rayito";

const fleet = await deployAgent("./my-agent", {
  options: { bucket: "amzn-s3-demo-bucket" },
  target: "agentcore",
  agentcore: {
    bedrockModels: ["us.anthropic.claude-haiku-4-5-20251001-v1:0"],
  },
});
const reply = await fleet.invoke("Summarize the README.");
console.log(reply.text, reply.sessionId);

Rayito builds the linux/arm64 image in CodeBuild (no local Docker), pushes it to Amazon ECR, creates a least-privilege execution role, creates or updates the runtime idempotently (deploying again is an update, never a duplicate), waits until it is ready and enables MMDSv2, which AgentCore requires since 2026-06-30. fleet.invoke() and fleet.stream() have the same signature and the same sessions as a MicroVM fleet. Details in Deploy to AgentCore.

It works with every framework the 0.14 detection already deploys: LangGraph and LangGraph.js, LangChain and deepagents, Strands and its harness, Hermes, OpenCode, the Vercel AI SDK and your own Flask or Express app.

The security difference¶

AgentCore has no Rayito secrets gateway: the agent gets credentials from the runtime role, and any code running in the session can read them. Inside a Rayito MicroVM that does not happen. That is why the role Rayito creates is least privilege: it only invokes in Bedrock the models of --bedrock-model and only reads the secrets of --readable-secret. The plan the CLI prints, the README of the exported context, the guide and Security say so in the same words.

Operating the agents¶

Command	What it does
`rayito agent status NAME --target agentcore`	the runtime's state, version, image and logs
`rayito agent list --target agentcore`	the region's Rayito agents
`rayito agent stop NAME --target agentcore --session-id ID`	ends one session's microVM
`rayito agent delete NAME --target agentcore`	deletes the runtime, the stack with its ECR repository and the log group; only what Rayito created

AgentCoreFleet.connect(name) does the same from the SDK, and --tag K=V passes tags to the stack and the runtime if your organization requires them.

What does not apply to AgentCore¶

The options that size a MicroVM fleet (min_vms, max_vms, warm_vms, memory_mib, --port, --idle, --secret, --token-file…) do not exist on AgentCore: in the call they are an error (option_not_supported) and in the project file a warning in the plan. Rayito never approximates them silently. The full table says what each one does.

AWS CDK constructs¶

If your infrastructure lives in AWS CDK, two new constructs declare Rayito's pieces in your own app and deploy them with cdk deploy, in Python (rayito.cdk, extra cdk) and TypeScript (rayito/cdk):

RayitoAgent: the same agent as --target agentcore, with the same template and IAM as the CLI. The image is built by default in CodeBuild (AgentImageBuild.codeBuild(), no local Docker) or with your Docker (localDocker()), and a custom resource turns on MMDSv2.
RayitoMicrovmImage: a Lambda MicroVMs image with rayd (and its sizes), from a release's rayito-image.zip checked against its SHA256SUMS (MicrovmImageArtifact.downloadRelease()) or from a zip of your own. Sandboxes are still created with the SDK by the image name.

PythonTypeScript

import aws_cdk as cdk
from rayito.cdk import RayitoAgent

app = cdk.App()
stack = cdk.Stack(app, "Agents", env=cdk.Environment(region="us-east-1"))
RayitoAgent(
    stack,
    "SupportBot",
    project="./my-agent",
    bedrock_models=["us.anthropic.claude-haiku-4-5-20251001-v1:0"],
)
app.synth()

import { App, Stack } from "aws-cdk-lib";
import { RayitoAgent } from "rayito/cdk";

const app = new App();
const stack = new Stack(app, "Agents", { env: { region: "us-east-1" } });
new RayitoAgent(stack, "SupportBot", {
  project: "./my-agent",
  bedrockModels: ["us.anthropic.claude-haiku-4-5-20251001-v1:0"],
});

cdk synth makes no AWS call. The CLI and the SDK list, inspect and invoke a CDK agent like any other, but rayito agent deploy, rayito agent delete and rayito image publish refuse to change what CloudFormation manages. Step by step, with the tagged bootstrap, the cost and how to migrate a CLI agent: Deploy with CDK.

Changes to be aware of¶

There are no breaking API changes.

Exported context for AgentCore. The Dockerfile of rayito agent export --target agentcore takes its base image from an AGENT_BASE_IMAGE build argument (with the same digest-pinned reference as the default) and the README.md explains how to deploy it. The Dockerfile and README.md of the docker target are unchanged.
Once, the image of your MicroVM agents is rebuilt. The agent host and, for Node frameworks, the node_bridge.mjs bridge now carry the AgentCore support (session id and role credentials). They are part of the build context, so the first deploy_agent after upgrading creates one new image version (about $0.011 and at least one week of snapshot storage) even though your code did not change; later ones reuse it.
TypeScript: four new optional peers (@aws-sdk/client-bedrock-agentcore-control, @aws-sdk/client-bedrock-agentcore, @aws-sdk/client-codebuild and @aws-sdk/client-ecr), which are only needed with target: "agentcore".
A new exception, AgentCoreException / AgentCoreError, with a closed list of code (Errors).
Optional CDK constructs. rayito.cdk needs the cdk extra (aws-cdk-lib and constructs) and rayito/cdk the optional peers aws-cdk-lib and constructs; without them, import rayito and the CLI load nothing from CDK. An AgentCore runtime deployed with CDK carries the marker rayito.agentcore/1+cdk: the ones you already have (rayito.agentcore/1) keep working the same.

How to try it¶

Update the SDKs to the version that includes it, run rayito setup (first with --dry-run) and check the region and the bucket it left.
Add the guide's permissions to the credentials of whoever deploys.
Try rayito agent deploy ./my-agent --target agentcore --dry-run.

The full detail will be in the Changelog.