Kiro IDE

The Kiro IDE is a desktop code editor built on Code OSS, the open-source core of VS Code, with the agent woven into it. If you have used VS Code your hands already know the layout, and on first run you can import your settings and extensions rather than starting over.

What is the Kiro IDE?

It is the surface most people start on, because it is the one that shows you everything. What the IDE adds over a plain editor:

• The agentic chat panel, with Autopilot and Supervised modes
• The specs experience: create, review each phase, execute tasks
• Steering and hook panels
• MCP server management with a status view and a logs channel
• Visual diff review of every agent change
• Agent Focus, an experimental chat-first view from the 1.0 release that runs several agent sessions in parallel across workspaces
• Agent Artifacts (1.1), the durable outputs an agent leaves behind, previewed in chat and reviewed in Agent Focus
• Workflows (1.2, opt-in), multi-step plans that run in the background with each step as its own agent session, tracked in a Workflows area above the chat
• Checkpoints, and a searchable session history panel

Platform support is worth checking before you plan a team rollout: macOS on Intel and Apple silicon, Windows 10 and 11 on 64-bit, and Linux with glibc 2.39 or newer (Ubuntu 24+, Debian 13+, Fedora 40+, Arch, Mint 22+). Since 1.1 there are native ARM64 builds for Windows and Linux on the downloads page, so an ARM laptop or server no longer runs the editor under x64 emulation. Sign-in works with Google, GitHub, AWS Builder ID, or organization identity and SSO.

Why it exists

An agent that edits your files needs somewhere to show you what it did. Chat interfaces can describe a change; only an editor can put the old and new versions side by side, let you accept one hunk and reject the next, and jump you to the file. Most of the IDE’s Kiro-specific surface exists to make agent work reviewable rather than to make it possible.

The choice to build on Code OSS follows from the same logic. Nobody wants to relearn keybindings to try an agent, so the editor half is familiar on purpose and the new half is the panels.

How it works

Choosing an autonomy level. Settings → Agent → Agent Autonomy, stored as kiroAgent.agentAutonomy, selects between two modes. Autopilot works end to end: creating files, modifying code, running commands, everything viewable and revertible. Supervised pauses after each turn that edits files and hands you the diff for hunk-by-hunk accept or reject. Permissions are additive on top of both, not a replacement for them.

Checkpoints. Kiro creates a checkpoint automatically on every prompt, snapshotting the files the agent changed with its built-in tools. Restoring puts those files and the agent’s context back and discards the chat after that point. The IDE also has a “revert last turn” action, which the CLI does not.

Context providers. The # menu is the feature people skip and then complain about the results. #codebase, #file, #folder, #git diff, #terminal, #problems, #url, #code, #repository, #current, #steering, #docs, #spec, and #mcp each feed the agent precise, current material. Pasting a snippet gives the agent a stale copy with no path; #file gives it the file.

Agent Artifacts. Added in 1.1, these are the outputs an agent produces as things in their own right rather than as messages: documents, diagrams, code, images, and whatever else a turn produces. The problem they solve is the one everybody has after a long session — the design note the agent wrote an hour ago is somewhere in the transcript, and finding it means scrolling past everything that happened since. An artifact stays addressable. There are three ways to reach one: a compact preview inline in the conversation, enough to see what it is without leaving the thread; full review in Agent Focus, where the artifact sits alongside the chat that produced it so you can read it properly and still see the reasoning; and the Agent Focus context panel, which is how you come back to an artifact later, after the conversation has moved on. Treat it as the difference between an agent that tells you things and an agent that hands you things.

Recent releases worth knowing. v1.0.395 (August 27, 2026) made third-party extensions work alongside Kiro, added support for the latest MCP protocol revision with more reliable sign-in, reduced extension host crashes during large agent responses, and kept agent turns alive through brief network drops. v1.0.437 (September 1, 2026) added cloud configuration across IDE surfaces, so agents, MCP servers, powers, steering, skills, and hooks defined in Kiro Web appear locally as read-only previews, with cloud-synced powers listed among your installed ones. Earlier in August, v1.0.337 kept ignored files out of search results and tightened filesystem and command permission rules.

v1.1 (September 14, 2026) is the first release off the 1.0.x line, and Agent Artifacts is its headline feature. It also brought the native ARM64 builds for Windows and Linux and moved the editor foundation to Code OSS 1.131, which is the upstream VS Code core the IDE is built on. Four smaller fixes are worth knowing because each one removes a specific annoyance: compacted conversations now retain context rather than losing the thread after a summarize; MCP failures surface more clearly instead of looking like the agent ignoring a tool; Hooks are more reliable; and enterprise profiles route requests to the region you selected, which matters if you chose one for compliance reasons.

v1.1.70 (September 24, 2026) added kiroAgent.terminalCommandTimeout, a default timeout for agent-run terminal commands that applies to open local sessions without a restart (a timeout set on a specific command still wins). Markdown links to workspace files in agent responses now open in the editor, and restored Agent Focus sessions no longer come back to a blank chat pane.

v1.2 (September 30, 2026) brought Workflows: ask Kiro to run a reusable, multi-step plan and keep working in the parent chat while each step runs in its own agent session. Workflows are off by default; turn them on under Workspace Configuration in Agent Focus (the setting is kiroAgent.workflows.enabled) and start a new chat. The same release tightened safety around Kiro’s own configuration, covered under permissions below, and added enterprise controls over which sign-in methods are allowed. Patches 1.2.37 and 1.2.56 (October 5 and 8) put model search and the Effort slider in one panel, kept Effort chosen before the first message, limited local state to your operating-system account on macOS and Linux, and let PreToolUse and PostToolUse hooks match categories such as shell, read, and write.

v1.3 (October 13, 2026) added the local command sandbox: agent-run shell commands and their child processes run inside an operating-system sandbox with outbound network blocked, limited to common development hosts, or open. Select Command sandbox in the status bar to configure it and confirm it is active; see Turn on the command sandbox. The same release added /workflow-run to start a saved workflow recipe from chat, live working and needs-input status on chat tabs, and notices when a turn falls back to another model.

v1.3.11 (October 15, 2026) brought Markdown Review to every user. Open a workspace .md file in a rendered review panel, comment on exact passages, and send all the comments to Kiro at once; spec documents have a Review button. Generate Commit Message also works before you stage anything.

v1.4 (October 19 and 20, 2026) added Memory: Kiro can carry repository conventions, corrections, and approaches already ruled out from one session to the next. Open the Memories icon in the activity bar to see them. Since 1.4.10 the Kiro Agent: Memory setting defaults to Off, so choose a level to use it. 1.4.5 shows a proposed workflow’s steps in a permission card before they run, and limits the MCP configuration file to your operating-system account on macOS and Linux.

Common mistakes

Pasting code into chat. It costs context, arrives without a path, and goes stale the moment you edit the file. The fix: use #file and #folder. For a change in progress, #git diff is usually the single most useful provider on the list.

Leaving Autopilot on for everything. Autonomy is cheap when tests can catch the mistake and expensive when only careful reading can. The fix: switch to Supervised for unfamiliar code, and back for work with a safety net.

Treating checkpoints as version control. They only track edits made with the agent’s built-in file tools. Manual edits, formatter runs, MCP writes, and anything a shell command changed are not captured. The fix: commit before a long run.

Assuming your machine is supported because a teammate’s is. The IDE and the CLI have different requirements, and they are asymmetric: the IDE supports Windows 10 where the CLI needs Windows 11, and the CLI runs on older Linux (glibc 2.34) where the IDE needs 2.39. The fix: check both before committing to a surface.

Permissions and safety

Permissions in the IDE are capability-based and checked on every file read, command execution, and MCP call. When a rule says ask, the approval prompt offers Allow, Deny, Always allow, and Always deny, and your choice persists to all workspaces, this workspace, or this session. Rules land in ~/.kiro/settings/permissions.yaml for you and ~/.kiro/workspace-roots/<hash>/permissions.yaml for a workspace, kept outside the repository on purpose. The effects rank as deny > ask > allow, with deny always winning.

Alongside permissions, .kiroignore keeps paths out of reach entirely. The IDE has full .kiroignore support, including the kiroAgent.agentIgnoreFiles setting, and since v1.0.337 ignored files stay out of search results too.

Since v1.2, Kiro always asks before the agent changes agent, hook, or power files, or the workflow recipes in .kiro/workflows/, even when a broader file permission would allow the write. In an untrusted workspace it goes further: it asks before changing any other Kiro configuration and before every command, even one you previously allowed, and it does not load workflow recipes until you trust the workspace. That closes the obvious hole where a cloned repository ships configuration that tells the agent to rewrite its own rules.

Where it fits

The IDE is the surface with the most local affordances, which makes it the natural home for specs, diff review, checkpoints, and .kiroignore. The CLI is the surface for servers, SSH, and CI. Kiro Web is the surface for repository work with no install. Cloud sessions connect the IDE to work running elsewhere, through Agent Focus mode. Kiro Crew is the always-on layer beside all of them.

Every building block on this site works in the IDE: specs, steering, hooks, MCP, custom agents (as Markdown files), skills, and powers.

Learn more

• Beginner Tutorial installs the IDE and builds a first feature.
• Checkpoints and rewind covers the undo model properly.
• Keep secrets out with .kiroignore is a ten-minute safety win.
• Permissions in permissions.yaml goes deeper than the prompts.
• Troubleshooting has the install and sign-in symptom tables.