Skip to main content
Glama
Kiro MCP Server

Kiro MCP Server

Kiro MCP Server

npm version CI

MCP server that lets AI agents with an always-on computer (Grok Bot, Claude, Cursor, Codex, and other MCP clients) orchestrate Kiro CLI V3 coding sessions through typed tools instead of shell commands. It is the Kiro sibling of claude-code-mcp-server.

Requires kiro-cli with the V3 engine, installed and signed in, on the machine that runs this server.

  1. Install it: curl -fsSL https://cli.kiro.dev/install | bash (or brew install kiro-cli on macOS).

  2. Sign in: run kiro-cli login in a terminal (kiro-cli login --use-device-flow on a machine without a browser).

  3. Trust each workspace once: run kiro-cli --v3 in the folder and choose Trust, continue (see Workspace trust).

Without the CLI, tools return CLI_NOT_FOUND with the install command, and the server prints the same warning on stderr at startup. A signed-out CLI gives CLI_NOT_SIGNED_IN. This server never logs in for you.

The server drives Kiro three ways: one long-lived ACP host (kiro-cli acp --agent-engine=v3 --auth-method=cli, newline-delimited JSON-RPC) for sessions, prompts, streaming, permissions, and Kiro's extension methods; headless runs (kiro-cli chat --v3 --no-interactive --output-format stream-json) for fire-and-forget work; and a few fixed-argv subcommands (whoami, settings, agent, mcp, powers). It exposes 32 tools and one subscribable transcript resource. The full feature-parity matrix, with what is exposed, composed, gated, withheld, or impossible and why, is in .kiro/specs/kiro-v3-orchestration/requirements.md.

Design

  • Strict schemas, typed results. Every tool has a strict input schema (additionalProperties: false) and an outputSchema, and returns structuredContent. Errors are { "error": { "code", "message", "details" } } with a code from the error table.

  • No escape hatch. No shell tool, no raw argv, no field that forwards free-form CLI flags, and no "send any ACP method" tool. Kiro commands that only exist in the terminal UI are mapped to typed tools, or listed as not possible.

  • Fixed argv. The only place kiro-cli argv is built is src/argv.ts. Values are attached as --flag=value or follow --; prompts go on stdin. The v2-only --agent, --model, --effort, and --trust-* flags are never passed to acp: agent mode, model, and effort are set through session options.

  • Operator policy. Kiro runs only inside KIRO_MCP_ROOTS (checked with realpath). Shell approvals, persistent consent, headless trust flags, and config writes each need an explicit opt-in.

  • Bounded processes. Every child is spawned detached in its own process group and tracked. Closing stdin, SIGINT, SIGTERM, or SIGHUP cancels running turns, closes the host's stdin, and stops every process group.

  • In memory. Event feeds, jobs, tangent trees, pending permissions, and queued prompts live in memory. The server never writes Kiro's session files. No telemetry; no tokens, KIRO_API_KEY, or authorization URLs in output or logs.

Related MCP server: AKIMCP

Prerequisites

  • Node.js 20 or later.

  • kiro-cli 2.37 or later with the V3 engine (kiro-cli acp --agent-engine=v3 must start), signed in. Set KIRO_BIN when kiro-cli is not on the server's PATH.

Install

npx -y @sohampatwardhan/kiro-mcp-server@latest

Claude Code

claude mcp add kiro -e KIRO_MCP_ROOTS=$HOME/code -- npx -y @sohampatwardhan/kiro-mcp-server@latest

Cursor, Claude Desktop, and other JSON configs

{
  "mcpServers": {
    "kiro": {
      "command": "npx",
      "args": ["-y", "@sohampatwardhan/kiro-mcp-server@latest"],
      "env": { "KIRO_MCP_ROOTS": "/Users/me/code" }
    }
  }
}

Codex

[mcp_servers.kiro]
command = "npx"
args = ["-y", "@sohampatwardhan/kiro-mcp-server@latest"]
env = { KIRO_MCP_ROOTS = "/home/me/code" }

Install the skills

The repository ships agent skills that teach agents when and how to use these tools: delegating a task to Kiro, choosing mode, model, effort, and permission handling, following a run live, collecting results and patches, and recovering from failures. Install them with the skills CLI:

npx skills add sohampatwardhan/kiro-mcp-server -g

Install one skill, or only for some agents:

npx skills add sohampatwardhan/kiro-mcp-server -g --skill kiro-orchestration
npx skills add sohampatwardhan/kiro-mcp-server -g -a claude-code -a codex

Each skill's SKILL.md carries a SemVer metadata.version, checked in CI by scripts/check-skill-versions.mjs, and CI installs the skills from the checkout into a throwaway HOME to test this exact path.

Environment variables

All are optional. An invalid value makes the server print the variable name and reason on stderr and exit with code 2. Booleans accept 1, true, yes, 0, false, no.

Variable

Default

Effect

KIRO_BIN

kiro-cli

CLI path or name

KIRO_MCP_CWD

process cwd

Default root when KIRO_MCP_ROOTS is unset

KIRO_MCP_ROOTS

KIRO_MCP_CWD

Comma-separated absolute directories Kiro may run in. / is refused. The first is the ACP host's cwd

KIRO_MCP_PERMISSIONS

ask

ask (the calling agent answers), deny (reject all), or allow (approve once; shell still follows KIRO_MCP_ALLOW_SHELL)

KIRO_MCP_PERMISSION_TIMEOUT_MS

600000

Unanswered permissions are rejected after this long

KIRO_MCP_ALLOW_SHELL

off

Lets shell-command requests be approved. Off: they are rejected at once

KIRO_MCP_ALLOW_PERSISTENT_CONSENT

off

Allows allow_always answers

KIRO_MCP_ELICITATION

on

on also shows pending permissions to the client's user as MCP forms; off never sends forms, so every request waits for kiro_permission_respond

KIRO_MCP_HEADLESS_TRUST

none

tools allows headless trust_tools; all also allows trust_all_tools

KIRO_MCP_ALLOW_TRUST_WORKSPACE

off

Allows headless trust_workspace

KIRO_MCP_ALLOW_CONFIG_WRITES

off

Allows agent, MCP config, settings, and powers writes

KIRO_MCP_USAGE_STOP_PERCENT

unset (no check)

An integer from 1 to 100. New work fails with USAGE_LIMIT_NEAR once this share of credits is used (see Credit budget)

KIRO_MCP_CLI_TIMEOUT_MS

120000

Subcommand timeout

KIRO_MCP_REQUEST_TIMEOUT_MS

120000

ACP request timeout (prompts have none)

KIRO_MCP_HEADLESS_TIMEOUT_MS

3600000

Headless job timeout; timeout_s may lower it

KIRO_API_KEY, when set in the server's environment, is inherited by headless runs only. No tool can read or set it.

Workspace trust

ACP has no method for trusting a workspace. Until a folder is trusted, Kiro does not load its custom agents, steering, MCP servers, skills, or workflows, and asks before every shell and MCP call. Trust each root once: run kiro-cli --v3 in the folder and choose Trust, continue. kiro_status reports the saved trust for every root (read-only, from Kiro's per-workspace permissions file) and warns for each untrusted one. Kiro never saves trust for your home directory.

Shell approvals

Shell approvals are off by default, as in claude-code-mcp-server: Kiro's requests to run commands (including tests and builds) are rejected at once and recorded as policy: "shell_disabled". To let the calling agent approve them one at a time, set KIRO_MCP_ALLOW_SHELL=1. To approve every non-shell request automatically as well, add KIRO_MCP_PERMISSIONS=allow.

Requests the server rejects on its own

A turn result (kiro_prompt, and turn in kiro_events) lists every request the server rejected without the calling agent choosing it under turn.auto_rejected, each with permission_id, tool_call_id, title, policy, and a hint naming what would change it:

policy

Cause

Hint

shell_disabled

Shell approvals are off

Set KIRO_MCP_ALLOW_SHELL=1

deny

KIRO_MCP_PERMISSIONS=deny

Set it to ask

timeout

Nobody answered within KIRO_MCP_PERMISSION_TIMEOUT_MS

Answer with kiro_permission_respond while the turn runs

elicitation

The client's user, or the client itself, rejected the approval form

If no person saw it, set KIRO_MCP_ELICITATION=off

Approval forms (elicitation)

When the MCP client declares form elicitation, a request waiting under ask is also shown to the client's user as a form listing the options the server would accept. Choosing one answers the request, declining the form rejects it, and dismissing it leaves it pending. Some clients declare form elicitation but decline every form without showing it to anyone, so every request is rejected within milliseconds, before the calling agent can answer (policy: "elicitation"). For those clients set KIRO_MCP_ELICITATION=off: no forms are sent, and requests wait for kiro_permission_respond as usual. kiro_status reports the setting as policy.elicitation and whether the client declared forms as policy.client_form_elicitation.

Credit budget

kiro_usage reads the plan's usage with _kiro/account/getUsage, the method behind /usage. It never starts a model turn or spends credits. Besides the plan, reset date, breakdowns, and bonus and add-on grants, it returns:

  • remaining_total: credits left across plan credits, bonus credits, and add-on credits;

  • percent_used: credits used over the credit limit across the same pools, from 0 to 100;

  • checked_at and cached: a reading is reused for 60 s, and concurrent calls share one request. Pass refresh: true for a new reading;

  • stop_percent and blocked_by: the operator's threshold, and the reason new work would be refused (null when nothing blocks).

With KIRO_MCP_USAGE_STOP_PERCENT set, kiro_prompt, kiro_tangent merge, kiro_workflow invoke, and kiro_run_headless check usage first. At or above the threshold they fail with USAGE_LIMIT_NEAR, naming the percent used, the credits left, and the reset date, and nothing is sent to Kiro. kiro_steer, kiro_cancel, and kiro_session_compact are not checked. A prompt sent with when_busy: "queue" is checked when it is queued, not when it starts. The check reads usage through the ACP host, so it starts the host if needed, even before a headless run. If usage cannot be read within 10 s, work goes ahead and the check is skipped for the next 30 s: this is a budget guard, not a security control.

Typical flow

  1. kiro_status checks the CLI, sign-in, V3 engine, trust, and policy.

  2. kiro_session_new (or kiro_session_load) attaches a session; kiro_session_configure picks mode (vibe, plan, spec, quick-spec, bug-fix, autonomous, or a custom agent), model, and effort.

  3. kiro_prompt sends a prompt and waits up to wait_s. If the turn is still running, poll kiro_events (or kiro_stream_session) with the returned cursor until the status is completed, cancelled, or failed.

  4. Answer pending_permissions with kiro_permission_respond. When the client supports MCP elicitation, the request is also shown to its user (see Approval forms).

  5. Steer with kiro_steer, stop with kiro_cancel, branch with kiro_session_fork or kiro_tangent, and close with kiro_session_close.

Tool reference

Tool

What it does

kiro_status

CLI path and version, V3 engine, capabilities, sign-in (account type, email, profile), roots and trust, policy, log paths, optional diagnostics

kiro_usage

Plan usage and credits (_kiro/account/getUsage), credits left and percent used, cached 60 s (refresh for a new reading), plus credits observed for a session

kiro_session_new

New local or cloud session, with mode, model, effort, title

kiro_session_list

Saved sessions by workspace or user scope, with source, title, and limit filters

kiro_session_load

Resume a session by id, or the latest for a workspace, with replay

kiro_session_configure

Mode, model, effort, other advertised options, title

kiro_session_state

MCP servers, tools, steering, skills, powers, governance, agent errors, commands, modes, config, context, /config panel, models

kiro_session_history

Paged transcript and rewind points

kiro_session_fork

Fork, optionally at a user message (/rewind)

kiro_session_export

Export to a file inside the roots

kiro_session_compact

Compact an idle session's context

kiro_session_close

Close a session (cancels its turn, rejects its permissions)

kiro_session_delete

Delete a session from Kiro's store (confirm: true)

kiro_prompt

Prompt with text, files, images, or an advertised command; wait or queue

kiro_events

Cursor-based event feed for a session or headless job, with long-poll

kiro_steer

Steer a running turn

kiro_cancel

Cancel a running turn, or stop a headless job

kiro_permissions

Pending permission requests

kiro_permission_respond

Answer one with an offered option

kiro_tangent

Branch, merge, and list tangents

kiro_specs

List and read .kiro/specs documents with parsed tasks

kiro_memory

List, read, create, update, delete memories; sync status

kiro_knowledge

Knowledge base subcommands

kiro_code_intelligence

Code intelligence subcommands

kiro_workflow

Workflow recipes and runs

kiro_cloud_sources

Connected source providers and repositories

kiro_run_headless

Headless run as a job

kiro_agents

List and validate custom agents; create, set default, upgrade (gated)

kiro_mcp_config

List and status of MCP config; add HTTP servers and remove (gated)

kiro_settings

List and get settings; set and delete (gated, sensitive keys withheld)

kiro_powers

List powers; install and uninstall (gated)

kiro_stream_session

Follow any session's transcript live with a cursor

Resource: kiro-session://<session_id>/transcript returns a session's newest events as JSON. Subscribe with resources/subscribe to get notifications/resources/updated within a second of new events.

Errors

Code

Meaning

CLI_NOT_FOUND

kiro-cli (or KIRO_BIN) is missing; the message has the install command

CLI_NOT_SIGNED_IN

Kiro reports a missing login; run kiro-cli login

ENGINE_V3_UNAVAILABLE

kiro-cli acp --agent-engine=v3 did not initialize; names the CLI version and reason

HOST_EXITED

The ACP host exited during the call; the session re-attaches on next use and the prompt is not resent

UNSUPPORTED_BY_KIRO

Kiro does not advertise or implement the method or target

KIRO_ERROR

Other Kiro JSON-RPC error; details.kiro has Kiro's code, message, and error type

KIRO_REFUSED

Kiro answered success: false or refused for trust or access level

OUTPUT_PARSE_FAILED

CLI or Kiro output could not be parsed

TIMEOUT

A subcommand, request, or job passed its timeout; its process group was stopped

CLI_EXIT

A subcommand exited nonzero; details.cli has cleaned output tails

PATH_OUTSIDE_ROOTS

A path resolves outside KIRO_MCP_ROOTS

PATH_EXISTS

Export destination exists and overwrite is not true

CONTENT_TOO_LARGE

A file or image is too large, not UTF-8, or not an allowed image type

SESSION_NOT_FOUND

The session is unknown to Kiro or not attached here

TURN_ACTIVE

The session already has a running turn

NO_ACTIVE_TURN

Steering needs a running turn

QUEUE_FULL

Five prompts already wait for this session

VALUE_NOT_ADVERTISED

Mode, option, value, command, or recipe input is not advertised; lists the allowed values

PERMISSION_NOT_FOUND

The permission is not pending

OPTION_NOT_OFFERED

The option id was not offered

PERSISTENT_CONSENT_DISABLED

allow_always needs KIRO_MCP_ALLOW_PERSISTENT_CONSENT

SHELL_APPROVAL_DISABLED

Shell approvals need KIRO_MCP_ALLOW_SHELL

HEADLESS_TRUST_DISABLED

A headless trust flag is not allowed by the operator

CONFIG_WRITES_DISABLED

Config writes need KIRO_MCP_ALLOW_CONFIG_WRITES

STDIO_SERVER_WITHHELD

Stdio MCP servers run arbitrary commands and cannot be added

SETTING_WITHHELD

The setting key is withheld

CONFIRMATION_REQUIRED

The call needs confirm: true

USAGE_LIMIT_NEAR

KIRO_MCP_USAGE_STOP_PERCENT is set and that share of credits is used. The message names the percent used, the credits left, and the reset date. Nothing was sent to Kiro

JOB_NOT_FOUND

Unknown or expired headless job

SPEC_NOT_FOUND

The spec or document does not exist

TANGENT_NOT_FOUND

Not part of a tangent tree, or no tangent with that name

INVALID_MERGE_TARGET

The merge destination resolves to the tangent itself or nothing

NOTHING_TO_BRANCH

The session has no messages yet

Development

npm ci
npm run build   # strict tsc is the static check
npm test        # builds, then node --test against the fake kiro-cli

Tests never run a real kiro-cli: test/fixtures/fake-kiro.mjs stands in for it through KIRO_BIN. See AGENTS.md for the architecture and rules.

Releasing

Bump version in package.json, merge, then push a matching tag (git tag v0.1.0 && git push origin v0.1.0). The release workflow checks the tag against package.json, builds, tests, publishes to npm with provenance through trusted publishing (GitHub OIDC, no NPM_TOKEN), creates a GitHub release, and mirrors the package to GitHub Packages.

Credits

Inspired by vanphappi/kiro-cli-mcp. No code was copied.

License

MIT

Available Tools

32 tools
kiro_agentsKiro custom agentsB

Kiro custom agents: list (the custom agents a session advertises as modes, with their source, plus agent config errors) and validate (kiro-cli agent validate --path). The writes create, set_default, and upgrade need KIRO_MCP_ALLOW_CONFIG_WRITES. Editing an agent opens $EDITOR and is not available; agent migrate is withheld as potentially destructive.

Inputs: action (required), from, name, path, +3 more. Returns: note, valid, action, agents, +2 more

kiro_cancelCancel a Kiro turn or headless jobA
Idempotent

Cancel a session's running turn (like Ctrl+C): pending permissions are answered with the offered reject option, session/cancel is sent, and the call waits up to 30 s for Kiro's prompt response before returning the settled turn. Queued prompts are dropped. With job_id, stops a headless run's process group (SIGTERM, then SIGKILL 5 s later). The session stays open.

Inputs: job_id, session_id. Returns: job, turn, job_id, status, +1 more

kiro_cloud_sourcesKiro cloud source providersA
Read-onlyIdempotent

Connected source providers for cloud sessions (_kiro/sourceProviders/list), or, with provider (for example GITHUB), that provider's repositories (_kiro/sourceProviders/listResources). Use the owner/name values as repos for kiro_session_new with execution_target cloud.

Inputs: session_id (required), provider. Returns: providers, resources

kiro_code_intelligenceKiro code intelligenceC

LSP-backed code intelligence (_kiro/codeIntelligence), like /code: init, status, overview, logs. Kiro's success false (for example when it is not enabled) is KIRO_REFUSED.

Inputs: session_id (required), subcommand (required), force. Returns: data, message, success

kiro_eventsRead Kiro session eventsA
Read-onlyIdempotent

Read normalized events after cursor from a session's (or headless job's) event feed: agent text, tool calls, plan updates, permission requests, turn boundaries with credits, mode and config changes, steering, workflow, and notices. Long-polls up to wait_s when nothing is newer. A message or tool call that changes is re-sent with a new seq: keep the latest per segment or toolCallId. Thoughts are left out unless include_thoughts. Returns next_cursor, lowest_cursor (gap: true when older events were dropped), the turn status, and pending permissions.

Inputs: limit, cursor, job_id, wait_s, +2 more. Returns: gap, job, turn, events, +7 more

kiro_knowledgeKiro knowledge basesC

Kiro knowledge bases (_kiro/knowledge), like /knowledge: show, add (a path inside KIRO_MCP_ROOTS), remove, search, update, clear, status, cancel. Returns Kiro's success, message, and data; success false is KIRO_REFUSED.

Inputs: session_id (required), subcommand (required), name, path, +4 more. Returns: data, message, success

kiro_mcp_configKiro MCP server configurationA

Read Kiro's MCP configuration: list (kiro-cli mcp list, optional scope) and status (kiro-cli mcp status --name), parsed from text with the raw text alongside. add (HTTP servers only: an https URL, or http to localhost) and remove need KIRO_MCP_ALLOW_CONFIG_WRITES. Stdio (command) servers and mcp import are withheld because they run arbitrary commands. For live server status in a session, use kiro_session_state include mcp.

Inputs: action (required), cwd, url, name, +6 more. Returns: raw, note, action, status, +1 more

kiro_memoryKiro memoriesA
Destructive

List, read, create, update, or delete Kiro memories (_kiro/memory/*), like /memories, and read the memory sync status. Delete needs confirm: true. Kiro refuses writes in untrusted workspaces or below the configured memory access level (KIRO_REFUSED with Kiro's message).

Inputs: action (required), session_id (required), confirm, content, +1 more. Returns: action, result

kiro_permission_respondAnswer a Kiro permissionA

Answer a pending permission with one of its offered option_ids (never anything else). allow_always needs the operator's KIRO_MCP_ALLOW_PERSISTENT_CONSENT; reject_always is always allowed because it only narrows Kiro. For an always option, scope (session, workspace, or user) and resource (a pattern; default the request's resource) are sent as Kiro consent. Shell commands can be approved only when the operator sets KIRO_MCP_ALLOW_SHELL. A denied tool call fails and the turn continues.

Inputs: option_id (required), permission_id (required), scope, resource. Returns: resolved, option_id, option_kind, permission_id

kiro_permissionsPending Kiro permissionsA
Read-onlyIdempotent

List Kiro's pending permission requests (all sessions, or one), with the options exactly as offered, the consent details (capability, resource, workspace root), and the MCP tool identity, which is untrusted display data. Answer with kiro_permission_respond before expires_at, or the request is rejected.

Inputs: session_id. Returns: policy, pending, shell_approvals, persistent_consent

kiro_powersKiro powersA

Kiro powers: list returns a session's powers snapshot (like /powers). install (a catalog name, or a local path inside KIRO_MCP_ROOTS) and uninstall run kiro-cli powers and need KIRO_MCP_ALLOW_CONFIG_WRITES.

Inputs: action (required), session_id, name_or_path. Returns: note, action, output, powers

kiro_promptPrompt a Kiro sessionA

Send a prompt to an attached session (session/prompt) and wait up to wait_s for the turn to finish. Returns the finished turn (final text, tool calls, credits) or status running with a turn_id and cursor: then poll kiro_events with that cursor until the status is completed, cancelled, or failed, answering any pending_permissions with kiro_permission_respond. A turn finishes only when Kiro answers the prompt. Add files as links (or embedded UTF-8 text with embed: true) and images from a path or base64. command runs an advertised skill, MCP prompt, or sub-agent as /<name> <input>; text starting with @name runs a saved prompt. when_busy queue waits behind the running turn.

Inputs: session_id (required), text, files, images, +3 more. Returns: turn, cursor, queued, status, +3 more

kiro_run_headlessRun Kiro headlessA

Fire-and-forget run of kiro-cli chat --v3 --no-interactive --output-format stream-json in a directory inside KIRO_MCP_ROOTS, locally or in the cloud (cloud + repos). The prompt goes on stdin. Returns a job_id: poll kiro_events with job_id for streamed events and the final result (session id, final text, exit code and meaning: 0 success, 3 MCP startup failed, 4 agent not found), and stop it with kiro_cancel. Headless runs cannot ask for permission: anything not pre-approved is denied. trust_all_tools needs KIRO_MCP_HEADLESS_TRUST=all, trust_tools needs tools or all, and trust_workspace needs KIRO_MCP_ALLOW_TRUST_WORKSPACE. Uses the operator's CLI login or KIRO_API_KEY.

Inputs: cwd (required), prompt (required), mode, agent, +13 more. Returns: cwd, error, cursor, job_id, +14 more

kiro_session_closeClose a Kiro sessionA
Idempotent

Close an attached session (session/close), like /quit: cancels its running turn, rejects its pending permissions, and returns the final cursor. The session stays in Kiro's store (use kiro_session_load to resume it), and its event feed stays readable for an hour so streams can drain.

Inputs: session_id (required). Returns: closed, session_id, final_cursor

kiro_session_compactCompact a Kiro sessionA

Compact an idle session's context with _kiro/session/compact, like /compact, and return the context usage reported afterwards. Fails with TURN_ACTIVE while a turn runs.

Inputs: session_id (required). Returns: kiro, session_id, context_usage

kiro_session_configureConfigure a Kiro sessionA
Idempotent

Switch an attached session's agent mode (session/set_mode: vibe, plan, spec, quick-spec, bug-fix, autonomous, or a custom agent), model and effort (session/set_config_option model and effortLevel), or any other advertised option such as autopilot or memoryReflection, like /model, /effort, /agent, and /plan. Every value is checked against what Kiro last advertised for the session; on VALUE_NOT_ADVERTISED nothing changes. Returns the options as Kiro reports them after the change. title renames the session. For /spec run, select mode spec and prompt the agent to run the named spec.

Inputs: session_id (required), mode, model, title, +2 more. Returns: title, changed, session_id, current_mode, +1 more

kiro_session_deleteDelete a Kiro sessionA
Destructive

Permanently delete a session from Kiro's store (session/delete), like kiro-cli chat --delete-session. Requires confirm: true. Closes the session first when it is attached. Local sessions must live inside KIRO_MCP_ROOTS.

Inputs: session_id (required), confirm. Returns: deleted, session_id

kiro_session_exportExport a Kiro sessionA

Export a session to a file inside KIRO_MCP_ROOTS with _kiro/session/export, like /chat save. Fails with PATH_EXISTS unless overwrite is true. Importing an archive is not possible over ACP.

Inputs: path (required), session_id (required), overwrite. Returns: path, bytes, session_id

kiro_session_forkFork a Kiro sessionA

Fork a session with session/fork, optionally at a user message id from kiro_session_history's rewind_points (that is /rewind). The fork is attached as a new session; the original is unchanged.

Inputs: session_id (required), message_id. Returns: modes, cursor, commands, message_id, +5 more

kiro_session_historyKiro session transcriptA
Read-onlyIdempotent

Read a session's transcript (_kiro/session/history), paged with cursor and limit, like /transcript. Falls back to this server's event feed when Kiro returns no history. rewind_points lists each user message id with its turn number and a prompt preview: pass one as message_id to kiro_session_fork to rewind.

Inputs: session_id (required), limit, cursor. Returns: source, entries, has_more, session_id, +2 more

kiro_session_listList Kiro sessionsA
Read-onlyIdempotent

List saved Kiro sessions with session/list: scope workspace (sessions whose cwd is cwd, default the first root) or user (every workspace; local sessions outside KIRO_MCP_ROOTS are left out and only counted). Filters by source (local or remote cloud sessions), title substring, and limit run on this server and report how many were left out.

Inputs: cwd, limit, scope, source, +1 more. Returns: sessions, omitted_count, omitted_outside_roots

kiro_session_loadLoad a Kiro sessionA
Idempotent

Resume a saved local or cloud session (session/load) and attach it to this server, like kiro-cli chat --resume-id. Pass session_id, or latest: true with cwd for the most recently updated session in that workspace (--resume). Replayed history goes into the session's event feed marked replay; the result has a short replay summary and the cursor to poll from. Cloud sessions keep streaming, and approvals that were waiting are returned in pending_permissions.

Inputs: cwd, latest, session_id, additional_directories. Returns: modes, cursor, source, commands, +8 more

kiro_session_newNew Kiro sessionA

Create a Kiro CLI V3 session (session/new) in a workspace inside KIRO_MCP_ROOTS and attach it to this server. Optionally pick the agent mode (vibe, plan, spec, quick-spec, bug-fix, autonomous, or a custom agent), model, and effort; values Kiro did not apply are listed in warnings. execution_target cloud creates a cloud sandbox session on the given repos. Caller-supplied MCP servers are never accepted. Also how to compose /clear (start a new session) and /spawn (a new session plus kiro_prompt).

Inputs: cwd (required), mode, model, repos, +4 more. Returns: modes, title, cursor, commands, +6 more

kiro_session_stateKiro session stateA
Read-onlyIdempotent

Snapshots of what a session will use: MCP servers (status, failed authorization, tool names), tool tags, steering documents, skills, powers, governance flags, agent config errors, the command catalog, modes, config options, context usage (plus _kiro/session/context), and the /config panel including hooks (_kiro/configuration/getState). A snapshot that has not arrived yet comes back with received: false. Large fields (tool schemas, steering content, skill descriptions) are left out unless verbose. models works without a session (kiro-cli chat --list-models).

Inputs: include (required), verbose, session_id. Returns: state, session_id

kiro_settingsKiro settingsB
Idempotent

Read Kiro settings (kiro-cli settings list --format json, with all: true for every available setting); get returns only the given keys. set and delete need KIRO_MCP_ALLOW_CONFIG_WRITES; keys under chat.agentEngine and acp.*, and any key naming a token, secret, API key, or password, are withheld. Use set chat.defaultModel for /model set-current-as-default.

Inputs: action (required), all, cwd, key, +3 more. Returns: note, action, output, settings

kiro_specsKiro spec documentsA
Read-onlyIdempotent

Read Kiro spec-driven development output under /.kiro/specs, like /spec and /spec view. list shows each spec folder, which of requirements.md, bugfix.md, design.md, and tasks.md exist, their modification times, and checked versus unchecked task counts. read returns one document (truncated at 200 KiB), with parsed tasks for tasks.md. To create or run a spec, select mode spec (or quick-spec, bug-fix) with kiro_session_configure and prompt the agent, for example "run the tasks in the spec".

Inputs: cwd (required), action (required), spec, document. Returns: cwd, specs, document

kiro_statusKiro statusA
Read-onlyIdempotent

Call first. Reports whether kiro-cli is installed (path, version), whether the V3 ACP engine starts, the host's capabilities (prompt and session capabilities, extension methods, session sources, list scopes, execution targets, auto-compaction range), sign-in state from kiro-cli whoami (account type, email, profile only), the roots and their saved workspace trust, the operator policy, and Kiro's log paths. Signed out: run kiro-cli login in a terminal; this server never logs in. include_diagnostics adds kiro-cli diagnostic and kiro-cli doctor --all.

Inputs: include_diagnostics. Returns: cli, roots, policy, account, +9 more

kiro_steerSteer a running Kiro turnA

Send a steering message into the session's running turn (_session/steer), like Kiro's steer mode: Kiro queues it and injects it at the next step (watch for steering events in kiro_events). Fails with NO_ACTIVE_TURN when nothing is running; send a new kiro_prompt instead.

Inputs: text (required), session_id (required). Returns: cursor, turn_id, accepted

kiro_stream_sessionStream a Kiro session transcriptA
Read-onlyIdempotent

Follow a session's transcript live: returns events after cursor (agent text, tool calls and results, plan updates, permission requests, turn events) and the next cursor, waiting up to wait_s (default 1 s) when nothing is newer. Works for sessions this server did not start: they are loaded first, so their history comes first (replay: true), then live events. Re-reading a cursor returns the same events; gap: true means older events were dropped. types filters (skipped events still advance the cursor); max_chars caps the page and sets truncated: true. Also available as the subscribable resource kiro-session://<session_id>/transcript (notifications/resources/updated within a second of new events).

Inputs: session_id (required), limit, types, cursor, +3 more. Returns: gap, uri, events, turn_id, +8 more

kiro_tangentKiro tangentsA

Tangents, like /tangent: branch forks the session at its latest message into a named side conversation (default tangent-N) and attaches it; tree shows the recorded tangent tree; merge prompts the tangent once for a short findings summary, then sends that summary to the destination (parent by default, root, or a tangent name) as a new turn. The tangent itself is left unchanged. The tangent tree is held in this server's memory and does not survive a restart; the forked sessions stay in Kiro's store.

Inputs: action (required), session_id (required), name, wait_s, +1 more. Returns: name, note, tree, merge, +2 more

kiro_usageKiro usage and creditsA
Read-onlyIdempotent

Plan usage from _kiro/account/getUsage, like /usage: plan name, billing cycle reset date, usage breakdowns (resource type, used, limit, percentage), bonus and add-on credits, and whether overages are enabled. With session_id, also the credits this server observed for that session's turns since it was attached. UNSUPPORTED_BY_KIRO errors still carry session_credits in their details.

Inputs: session_id. Returns: plan, breakdowns, reset_date, bonus_credits, +3 more

kiro_workflowKiro workflowsB
Destructive

Kiro workflows (_kiro/workflow/*), like /workflow: list_recipes, list runs, invoke a recipe with inputs (checked against the recipe's declared input names), and inspect, pause, resume, cancel, retry (optionally from node_id), or delete a run. Lifecycle notifications appear as workflow events in kiro_events. For /goal, invoke the goal or iterate recipe when one is listed; otherwise prompt in autonomous mode with explicit acceptance criteria.

Inputs: action (required), session_id (required), inputs, recipe, +2 more. Returns: action, result, workflow_id

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 32 tools

    Disambiguation4/5

    Most tools target clearly distinct Kiro domains or session lifecycle operations, with strong descriptions that explain boundaries. There is some overlap among kiro_events, kiro_stream_session, kiro_session_history, and kiro_session_state, since they all expose aspects of session activity or state, but the distinctions are mostly workable.

    Naming Consistency4/5

    All tools use the kiro_ prefix and snake_case, and session tools follow a predictable kiro_session_<action> pattern. Non-session tools are more noun-oriented (kiro_memory, kiro_workflow, kiro_specs) and encode actions in parameters, so the convention is mostly but not entirely verb_noun.

    Tool Count3/5

    32 tools is heavy for an MCP server and exceeds the typical well-scoped range, with many session-related tools plus domain-specific integrations. The breadth reflects a genuinely large surface, but the set risks overwhelming agents and could benefit from consolidation.

    Completeness4/5

    The surface covers session lifecycle, prompting, events, permissions, specs, memory, knowledge, workflows, cloud sources, agents, settings, and diagnostics comprehensively. Minor gaps exist, such as archive import not being possible over ACP, agent editing being unavailable, and some config writes being intentionally withheld for security.

    Maintenance

    ActivityMaintained
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables local, permissioned development workflows from compatible AI clients, including filesystem editing, interactive terminals, durable jobs, Git operations, and semantic browser testing.
      53 npm
      1
      Apache 2.0
    • F
      license
      Not graded
      quality
      A
      maintenance
      Exposes a governed suite of 38 tools through a single OAuth-gated MCP endpoint, letting web-based AI chats (Claude, ChatGPT, Grok) and local IDEs read and edit files, run whitelisted shell commands, search content, use Git, inspect SQLite and localhost APIs, drive browser automation and DevTools, manage background tasks and ports, and access clipboard or desktop notifications on your own machine. A strict command whitelist and folder-level access controls keep the sessions safe by default.
      -
    • F
      license
      Not graded
      quality
      A
      maintenance
      Exposes a governed, OAuth-gated suite of 38 tools that let web AI assistants like Claude, ChatGPT, and Grok work directly on your local machine — reading and editing files, running whitelisted shell commands, searching, querying SQLite, driving browsers and DevTools, managing background tasks and localhost services, and controlling Git, clipboard, notifications, and Postman. This lets users build, debug, and maintain projects, inspect databases and local APIs, and check on long-running jobs from a browser or phone without granting unrestricted shell access.
      -
    • A
      license
      Not graded
      quality
      A
      maintenance
      Enables web-based AI clients like Claude, ChatGPT, and Grok to securely operate a local machine through an OAuth-gated MCP endpoint, covering files, shell commands, search, Git, SQLite, browser automation, DevTools, background tasks, ports, clipboard, notifications, and Postman. Exposes 38 governed tools with a strict command whitelist, folder allowlisting, and rate limiting so browser chats can build projects, inspect databases and local APIs, and manage long-running jobs without granting unrestricted shell access.
      MIT