Kiro

Kiro CLI is AWS’s coding agent for the terminal. E2B provides a pre-built kiro template with Kiro CLI already installed.

CLI

Create a sandbox with the E2B CLI.

e2b sbx create kiro

Once inside the sandbox, start Kiro CLI.

kiro-cli

Run headless

Use kiro-cli chat --no-interactive to run a single prompt without user input, and --trust-all-tools to auto-approve all tool calls. Headless runs authenticate with a Kiro API key passed as the KIRO_API_KEY environment variable. API keys are available on the Kiro Pro, Pro+, Pro Max, and Power plans. Create one in the Kiro web console. On the Free plan, log in with device flow instead.

Auto-approving tool calls is contained by the sandbox: the agent cannot touch your host machine, local files, or credentials. It can still make outbound network requests — internet access is enabled by default. To limit where an auto-approved agent can connect, configure outbound network rules (allowInternetAccess, plus allow/deny lists by CIDR or hostname). Hostname rules apply to HTTP(S) traffic only; use CIDR rules for other protocols.

import { Sandbox } from 'e2b'

const sandbox = await Sandbox.create('kiro', {
  envs: { KIRO_API_KEY: process.env.KIRO_API_KEY },
})

const result = await sandbox.commands.run(
  `kiro-cli chat --no-interactive --trust-all-tools "Create a hello world HTTP server in Go"`
)

console.log(result.stdout)
await sandbox.kill()

import os
from e2b import Sandbox

sandbox = Sandbox.create("kiro", envs={
    "KIRO_API_KEY": os.environ["KIRO_API_KEY"],
})

result = sandbox.commands.run(
    'kiro-cli chat --no-interactive --trust-all-tools "Create a hello world HTTP server in Go"',
)

print(result.stdout)
sandbox.kill()

Example: work on a cloned repository

import { Sandbox } from 'e2b'

const sandbox = await Sandbox.create('kiro', {
  envs: { KIRO_API_KEY: process.env.KIRO_API_KEY },
  timeoutMs: 600_000,
})

await sandbox.commands.run(
  'git clone --depth 1 https://x-access-token:$GITHUB_TOKEN@github.com/your-org/your-repo.git /home/user/repo',
  { envs: { GITHUB_TOKEN: process.env.GITHUB_TOKEN } }
)

const result = await sandbox.commands.run(
  `cd /home/user/repo && kiro-cli chat --no-interactive --trust-all-tools "Add error handling to all API endpoints"`,
  { onStdout: (data) => process.stdout.write(data), timeoutMs: 0 }
)

const diff = await sandbox.commands.run('cd /home/user/repo && git diff')
console.log(diff.stdout)

await sandbox.kill()

import os
from e2b import Sandbox

sandbox = Sandbox.create("kiro", envs={
    "KIRO_API_KEY": os.environ["KIRO_API_KEY"],
}, timeout=600)

sandbox.commands.run(
    "git clone --depth 1 https://x-access-token:$GITHUB_TOKEN@github.com/your-org/your-repo.git /home/user/repo",
    envs={"GITHUB_TOKEN": os.environ["GITHUB_TOKEN"]},
)

result = sandbox.commands.run(
    'cd /home/user/repo && kiro-cli chat --no-interactive --trust-all-tools "Add error handling to all API endpoints"',
    on_stdout=lambda data: print(data, end=""),
    timeout=0,
)

diff = sandbox.commands.run("cd /home/user/repo && git diff")
print(diff.stdout)

sandbox.kill()

Stream events as JSON

Add --output-format stream-json to get the run as JSON Lines on stdout, one event per line. Each event has a type and a data field. This option implies --no-interactive, so you don’t need to pass it. Parse each line as it arrives. See Kiro headless mode for the event format.

import { Sandbox } from 'e2b'

const sandbox = await Sandbox.create('kiro', {
  envs: { KIRO_API_KEY: process.env.KIRO_API_KEY },
})

let buffer = ''
await sandbox.commands.run(
  `kiro-cli chat --output-format stream-json --trust-all-tools "Create a hello world HTTP server in Go"`,
  {
    timeoutMs: 0,
    onStdout: (data) => {
      buffer += data
      const lines = buffer.split('\n')
      buffer = lines.pop() ?? ''
      for (const line of lines.filter(Boolean)) {
        const event = JSON.parse(line)
        console.log(event.type, event.data)
      }
    },
  }
)

await sandbox.kill()

import json
import os
from e2b import Sandbox

sandbox = Sandbox.create("kiro", envs={
    "KIRO_API_KEY": os.environ["KIRO_API_KEY"],
})

buffer = ""

def on_stdout(data):
    global buffer
    buffer += data
    *lines, buffer = buffer.split("\n")
    for line in filter(None, lines):
        event = json.loads(line)
        print(event["type"], event["data"])

sandbox.commands.run(
    'kiro-cli chat --output-format stream-json --trust-all-tools "Create a hello world HTTP server in Go"',
    on_stdout=on_stdout,
    timeout=0,
)

sandbox.kill()

Resume a session

Add --resume to continue the most recent conversation in the same working directory.

kiro-cli chat --no-interactive --trust-all-tools --resume "Now add tests for the server"

Log in without an API key

On the Kiro Free plan, or when you sign in with AWS Builder ID, GitHub, or Google, log in once per sandbox with device flow instead of an API key. Run the command from a sandbox terminal (see CLI). It prints a URL and a code — open the URL in your browser, confirm the code, and the command finishes once the login is confirmed.

kiro-cli login --license free --use-device-flow

After logging in, run headless commands without KIRO_API_KEY.

Kiro stores login credentials inside the sandbox, under /home/user/.local/share/kiro-cli. They persist across pause and resume, so anyone with access to the sandbox can act with your Kiro account until the sandbox is killed or you run kiro-cli logout.

Build a custom template

If you need to customize the environment (e.g. pre-install dependencies, add config files), build your own template on top of the pre-built kiro template.

// template.ts
import { Template } from 'e2b'

export const template = Template()
  .fromTemplate('kiro')

# template.py
from e2b import Template

template = (
    Template()
    .from_template("kiro")
)

// build.ts
import { Template, defaultBuildLogger } from 'e2b'
import { template as kiroTemplate } from './template'

await Template.build(kiroTemplate, 'my-kiro', {
  cpuCount: 2,
  memoryMB: 2048,
  onBuildLogs: defaultBuildLogger(),
})

# build.py
from e2b import Template, default_build_logger
from template import template as kiro_template

Template.build(kiro_template, "my-kiro",
    cpu_count=2,
    memory_mb=2048,
    on_build_logs=default_build_logger(),
)

Run the build script to create the template.

npx tsx build.ts

python build.py

Sandbox persistence

Auto-pause, resume, and manage sandbox lifecycle

SSH access

Connect to the sandbox via SSH for interactive sessions

Agents

MCP gateway

CLI

Run headless

Example: work on a cloned repository

Stream events as JSON

Resume a session

Log in without an API key

Build a custom template

Sandbox persistence

SSH access

​CLI

​Run headless

​Example: work on a cloned repository

​Stream events as JSON

​Resume a session

​Log in without an API key

​Build a custom template

​Related guides

Sandbox persistence

SSH access

CLI

Run headless

Example: work on a cloned repository

Stream events as JSON

Resume a session

Log in without an API key

Build a custom template

Related guides