Kiro MCP Server
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Kiro MCP Server Have Kiro add unit tests for the auth module in my project"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Kiro MCP Server
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-cliwith the V3 engine, installed and signed in, on the machine that runs this server.
Install it:
curl -fsSL https://cli.kiro.dev/install | bash(orbrew install kiro-clion macOS).Sign in: run
kiro-cli loginin a terminal (kiro-cli login --use-device-flowon a machine without a browser).Trust each workspace once: run
kiro-cli --v3in the folder and choose Trust, continue (see Workspace trust).Without the CLI, tools return
CLI_NOT_FOUNDwith the install command, and the server prints the same warning on stderr at startup. A signed-out CLI givesCLI_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 anoutputSchema, and returnsstructuredContent. 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-cliargv is built issrc/argv.ts. Values are attached as--flag=valueor follow--; prompts go on stdin. The v2-only--agent,--model,--effort, and--trust-*flags are never passed toacp: agent mode, model, and effort are set through session options.Operator policy. Kiro runs only inside
KIRO_MCP_ROOTS(checked withrealpath). 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-cli2.37 or later with the V3 engine (kiro-cli acp --agent-engine=v3must start), signed in. SetKIRO_BINwhenkiro-cliis not on the server'sPATH.
Install
npx -y @sohampatwardhan/kiro-mcp-server@latestClaude Code
claude mcp add kiro -e KIRO_MCP_ROOTS=$HOME/code -- npx -y @sohampatwardhan/kiro-mcp-server@latestCursor, 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 -gInstall 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 codexEach 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 |
|
| CLI path or name |
| process cwd | Default root when |
|
| Comma-separated absolute directories Kiro may run in. |
|
|
|
|
| Unanswered permissions are rejected after this long |
| off | Lets shell-command requests be approved. Off: they are rejected at once |
| off | Allows |
|
|
|
|
|
|
| off | Allows headless |
| off | Allows agent, MCP config, settings, and powers writes |
| unset (no check) | An integer from 1 to 100. New work fails with |
|
| Subcommand timeout |
|
| ACP request timeout (prompts have none) |
|
| Headless job timeout; |
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:
| Cause | Hint |
| Shell approvals are off | Set |
|
| Set it to |
| Nobody answered within | Answer with |
| The client's user, or the client itself, rejected the approval form | If no person saw it, set |
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_atandcached: a reading is reused for 60 s, and concurrent calls share one request. Passrefresh: truefor a new reading;stop_percentandblocked_by: the operator's threshold, and the reason new work would be refused (nullwhen 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
kiro_statuschecks the CLI, sign-in, V3 engine, trust, and policy.kiro_session_new(orkiro_session_load) attaches a session;kiro_session_configurepicks mode (vibe,plan,spec,quick-spec,bug-fix,autonomous, or a custom agent), model, and effort.kiro_promptsends a prompt and waits up towait_s. If the turn is still running, pollkiro_events(orkiro_stream_session) with the returned cursor until the status iscompleted,cancelled, orfailed.Answer
pending_permissionswithkiro_permission_respond. When the client supports MCP elicitation, the request is also shown to its user (see Approval forms).Steer with
kiro_steer, stop withkiro_cancel, branch withkiro_session_forkorkiro_tangent, and close withkiro_session_close.
Tool reference
Tool | What it does |
| CLI path and version, V3 engine, capabilities, sign-in (account type, email, profile), roots and trust, policy, log paths, optional diagnostics |
| Plan usage and credits ( |
| New local or cloud session, with mode, model, effort, title |
| Saved sessions by workspace or user scope, with source, title, and limit filters |
| Resume a session by id, or the latest for a workspace, with replay |
| Mode, model, effort, other advertised options, title |
| MCP servers, tools, steering, skills, powers, governance, agent errors, commands, modes, config, context, |
| Paged transcript and rewind points |
| Fork, optionally at a user message ( |
| Export to a file inside the roots |
| Compact an idle session's context |
| Close a session (cancels its turn, rejects its permissions) |
| Delete a session from Kiro's store ( |
| Prompt with text, files, images, or an advertised command; wait or queue |
| Cursor-based event feed for a session or headless job, with long-poll |
| Steer a running turn |
| Cancel a running turn, or stop a headless job |
| Pending permission requests |
| Answer one with an offered option |
| Branch, merge, and list tangents |
| List and read |
| List, read, create, update, delete memories; sync status |
| Knowledge base subcommands |
| Code intelligence subcommands |
| Workflow recipes and runs |
| Connected source providers and repositories |
| Headless run as a job |
| List and validate custom agents; create, set default, upgrade (gated) |
| List and status of MCP config; add HTTP servers and remove (gated) |
| List and get settings; set and delete (gated, sensitive keys withheld) |
| List powers; install and uninstall (gated) |
| 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 |
|
|
| Kiro reports a missing login; run |
|
|
| The ACP host exited during the call; the session re-attaches on next use and the prompt is not resent |
| Kiro does not advertise or implement the method or target |
| Other Kiro JSON-RPC error; |
| Kiro answered |
| CLI or Kiro output could not be parsed |
| A subcommand, request, or job passed its timeout; its process group was stopped |
| A subcommand exited nonzero; |
| A path resolves outside |
| Export destination exists and |
| A file or image is too large, not UTF-8, or not an allowed image type |
| The session is unknown to Kiro or not attached here |
| The session already has a running turn |
| Steering needs a running turn |
| Five prompts already wait for this session |
| Mode, option, value, command, or recipe input is not advertised; lists the allowed values |
| The permission is not pending |
| The option id was not offered |
|
|
| Shell approvals need |
| A headless trust flag is not allowed by the operator |
| Config writes need |
| Stdio MCP servers run arbitrary commands and cannot be added |
| The setting key is withheld |
| The call needs |
|
|
| Unknown or expired headless job |
| The spec or document does not exist |
| Not part of a tangent tree, or no tangent with that name |
| The merge destination resolves to the tangent itself or nothing |
| 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-cliTests 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 toolskiro_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 jobAIdempotent
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 providersARead-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 eventsARead-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 memoriesADestructive
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 permissionsARead-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 sessionAIdempotent
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 sessionAIdempotent
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 sessionADestructive
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 transcriptARead-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 sessionsARead-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 sessionAIdempotent
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 stateARead-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 settingsBIdempotent
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 documentsARead-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 statusARead-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 transcriptARead-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 creditsARead-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 workflowsBDestructive
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
Scored across 32 tools
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.
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.
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.
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
Related MCP Connectors
Operate Linux, macOS and Windows from your LLM. Every action runs through an auditable allowlist.
Use your own Windows, Mac or Linux computer from ChatGPT, Claude, Cursor or Gemini CLI: run commands, read, write and search files, run long processes. Your computer only makes an outgoing connection (no open ports or VPN). Read-only mode, allowed folders, blocked commands and an action log keep you in control. Free plan available.
Hosted runtime for persistent agent teams, durable workflows, memory, schedules, and goals.
Build, validate, deploy — HTTP APIs, cron jobs, webhooks and MCP tools — from your AI client.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceEnables local, permissioned development workflows from compatible AI clients, including filesystem editing, interactive terminals, durable jobs, Git operations, and semantic browser testing.53 npm1Apache 2.0
- FlicenseNot gradedqualityAmaintenanceExposes 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.-
- FlicenseNot gradedqualityAmaintenanceExposes 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.-
- AlicenseNot gradedqualityAmaintenanceEnables 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