Kiro Crew
A persistent workspace for development work that self-improves and continues beyond one session.
Kiro Crew is an open source development workspace that runs locally or remotely on
your hardware. It is persistent, self-learning, and self-evolving. Work with it
from the desktop app, web dashboard, and CLI, or continue the same work through
connection tools like Slack and Discord.
Your multi-step tasks can run unattended, recurring jobs run on your schedule,
and heartbeats monitor systems until something needs attention. Kiro Crew Apps
tailor that experience to a specific job, combining a purpose-built interface
with agents, skills, schedules, integrations, and backend services.
Quick start ·
Build from source ·
Why Kiro Crew ·
Capabilities ·
How it works ·
Security ·
Install ·
Telemetry ·
Docs
Quick start
You choose how to run Kiro Crew: the desktop app with automatic updates, a
one-line install on your machine or a remote host, the Docker image for
always-on servers, or a build from source. Every path runs on kiro-cli
underneath, so the first launch installs it if needed and guides Kiro
device-code sign-in.
App downloads
The desktop app starts a bundled Gateway when no local Gateway is already
running, updates itself on the channel you download, and can connect to a
remote Gateway over an SSH tunnel. See the
desktop app guide.
On Linux, start with the one-line install — it is the smoothest path, works
on every distro and both architectures, and puts kirocrew on your PATH,
which is what makes kirocrew service install (and the AppArmor profile the
agent sandbox needs on Ubuntu 23.10+) reachable:
curl -fsSL https://download.crew.kiro.dev/cli.sh | sh
You then work in the dashboard at http://localhost:5476. Add a desktop
package when you want what only the Electron shell gives you: an
application-menu entry and icon, a native window, a taskbar badge, a system-wide
hotkey, a Gateway that starts and stops with the app, and in-app updates. A
.deb or .rpm installs to a fixed path under /opt, which is what lets it set
the AppArmor profile up for you; the AppImage needs no root but needs FUSE and
carries a manual sandbox step. uname -m prints which architecture you need.
sudo apt install ./KiroCrew-x86_64.deb # Debian, Ubuntu
sudo dnf install ./KiroCrew-x86_64.rpm # Fedora, RHEL, CentOS Stream, AL2023
The Linux desktop app needs glibc 2.34 or newer (Ubuntu 22.04+, Debian 12+,
Fedora, CentOS Stream 9, Amazon Linux 2023). On an older host — Ubuntu 20.04,
Debian 11, Amazon Linux 2 — use the one-line install above.
Every architecture below is a first-class lane: each gets its own build, its own
auto-update feed, and its own SLSA provenance attestation.
| Install path |
x86_64 |
aarch64 (ARM64) |
| CLI one-liner / wheel |
yes |
yes (the wheel is py3-none-any; native libraries are vendored per architecture) |
Desktop .deb / .rpm / AppImage |
yes |
yes |
| Docker image |
yes |
yes (linux/amd64 and linux/arm64 under every tag, so docker pull picks yours) |
Take Stable unless you have a reason not to — the table below says who each
channel is for.
Release channels
Every install path — desktop app, CLI, Docker image — offers the same three
channels. Pick by how much churn you can absorb, not by version number:
| Channel |
Who it's for |
Built from |
Cadence |
| Stable |
Everyone. The default on every install path. |
The Insider build that baked long enough to be promoted |
On promotion, no calendar commitment |
| Insider |
Power users who want features days to weeks early and accept the new bugs that come with them |
Release-branch release-candidate tags |
Every RC |
| Nightly |
Us and contributors. Untested main HEAD — expect breakage. |
main, 06:00 UTC daily |
Daily |
Stable and Insider are two update lanes of the same app. The desktop app
switches between them in Settings → About, a CLI install switches by re-running
the installer with --channel, and a container switches by pulling a different
tag. Either way, the other lane's current version then arrives as an ordinary
update.
Because they are one app, keeping a Stable and an Insider copy side by side
does not give you two independent installs. Both read the same desktop settings
store, so the channel is a single value and whichever copy wrote it last wins —
switch to Insider in one and the other follows. They share one update download
cache as well. KIROCREW_HOME does not separate them either: it moves the data
home, not the desktop settings.
Nightly is a separate app with its own name and icon, so it installs alongside
a Stable or Insider one rather than replacing it. That also makes it the one copy
that keeps its own channel and its own settings store. It is not a sandbox,
though: it reads the same ~/.kiro/crew data home unless you point it elsewhere
with KIROCREW_HOME.
Running Insider or Nightly is a real contribution. When something looks wrong,
please open an issue so it gets
fixed before it reaches Stable.
One-line install
Install the prebuilt, SHA-256-verified wheel from the release CDN without
cloning the repository or running npm and a local build.
Stable, the default:
curl -fsSL https://download.crew.kiro.dev/cli.sh | sh
Track a faster channel, insider or nightly (see
Release channels for who each one is for):
curl -fsSL https://download.crew.kiro.dev/cli.sh | sh -s -- --channel insider
Pin an exact version:
curl -fsSL https://download.crew.kiro.dev/cli.sh | sh -s -- --version 0.1.0
Managed Python by default. The installer runs Kiro Crew on a fully managed
Python instead of the system one: it fetches a SHA-256-pinned
uv and provisions a self-contained CPython 3.12
into ~/.kiro/crew-python, so the install never depends on (or breaks with)
the system interpreter. Existing installs migrate the next time this installer
itself runs — a staged update applied from the dashboard or the CLI's update
command keeps its current interpreter. To run
on the system interpreter instead:
curl -fsSL https://download.crew.kiro.dev/cli.sh | sh -s -- --system-python
The choice is sticky: it is recorded next to the channel, so later re-runs of
the installer keep it without
the flag. Opt back in with --managed-python. If the managed interpreter
cannot be downloaded (no network path to the mirror), the installer falls back
to a usable system Python 3.12+ for that run; point air-gapped hosts at a
mirror with KIROCREW_UV_URL (the uv tarball) and UV_PYTHON_INSTALL_MIRROR
(the interpreter archive).
Open http://localhost:5476 and start a conversation. The web dashboard works
without messaging credentials. Add a messaging channel —
Slack,
Discord,
Telegram,
Teams,
Webex,
WeCom,
WeChat,
WhatsApp,
Feishu, or
iMessage — when you want to continue
working with the same agent away from the dashboard. Apart from Teams (which
needs a public HTTPS webhook — see its guide) and iMessage (which talks to
Messages.app on the same Mac), these channels connect
outbound, so you do not need to expose the dashboard port publicly.
Docker
For always-on servers, the Gateway ships as a public multi-arch image on GHCR:
docker run -d --name kirocrew \
-p 127.0.0.1:5476:5476 \
-v kirocrew-home:/home/kirocrew \
ghcr.io/kirodotdev/kirocrew:stable
See the Docker guide for first-run login, channel tags, and
the container security model.
Build from source
macOS and Linux require Python 3.12+, Node.js 22+ (24 LTS recommended), npm, and
kiro-cli. The first desktop or dashboard launch
can install Kiro CLI on the Gateway host and guide device-code sign-in before
chat opens. Windows is supported through a native source install; follow the
Windows guide instead of the shell steps below.
# 1. Clone and build Kiro Crew
git clone https://github.com/kirodotdev/KiroCrew.git
cd KiroCrew
make build
source .venv/bin/activate
# 2. Configure, verify, and start
kirocrew setup
kirocrew doctor
kirocrew gateway
Why Kiro Crew
Most agent sessions end when the chat closes. Kiro Crew runs continuously on
hardware you control and keeps working between conversations.
Persistent. Sessions, memory, schedules, and task checkpoints survive
Gateway restarts, and scheduled or reactive work continues without someone at
the terminal.
Self-learning. Corrections and task failures become durable lessons.
Preferences and project context carry into new sessions.
Self-evolving. Repeated patterns become reusable skills. Memory, lessons,
and skills stay visible and editable, so each Kiro Crew grows more tailored to
the person and work around it.
Runs where you choose. Your Mac, a local container, or a remote machine
you control.
One Gateway, many surfaces. Work directly in the desktop app or web dashboard,
or continue the same work from the CLI and messaging surfaces like Slack and
Discord.
What Kiro Crew does
| Capability |
What it gives you |
| Persistent sessions |
Run concurrent, isolated conversations, resume them after Gateway restarts, search prior sessions, and carry recent context into new work. |
| Self-learning |
Turn corrections and task failures into durable lessons that change later behavior. Keep preferences, active-project context, and history scoped to the relevant workspace. Say "no, always run the frontend checks before calling a change done" and it becomes a workspace-scoped lesson applied in future sessions. |
| Self-evolving skills |
Synthesize reusable skills from repeated patterns, then inspect, refine, or remove them as your work changes. |
| Long-running tasks |
Give Kiro Crew a task spec and walk away. It plans steps, executes them, validates results, retries failures, and resumes from checkpoints. "Implement this migration plan and stop if the tests fail" runs as a checkpointed task with validation at each step. |
| Unattended autonomy |
Run scheduled agent work or deterministic scripts and commands without a model call. Monitor work until it is done, or react to messaging events and authenticated webhooks without someone at the terminal. "Every weekday at 9, summarize the open work I should review" becomes a timezone-aware recurring job delivered to the surface you choose. |
| Delegation |
Spawn isolated subagents for parallel work and bring their results back into the parent conversation. "Research these three options in parallel and recommend one" fans out to isolated subagents and synthesizes the tradeoffs. |
| Work where you choose |
Work directly in the desktop app or web dashboard, or continue through the CLI and any connected messaging surface without moving the agent runtime or its state. |
| Installable Apps |
Add focused interfaces and domain workflows through dashboard pages, scoped Gateway APIs, events, and lifecycle hooks. |
| Extensible tools |
Add MCP servers, markdown skills, and hooks without changing the core runtime. |
| Visible execution |
Watch tool calls, subagent progress, context usage, approvals, schedules, memory, and logs from the dashboard. |
| Defense in depth |
Combine tool approvals, OS sandboxing, sensitive-path checks, credential redaction, deny rules, audit events, and governance profiles. |
You can also paste a screenshot and ask what is causing an error. Kiro Crew sends
the image to the active Kiro model and keeps the diagnosis in the conversation
history.
The complete inventory is in Features and
What's New.
How it works
flowchart TD
S["Desktop app · Web dashboard · CLI · Messaging channels (Slack, Discord, Telegram, Teams, Webex, WeCom, WeChat, WhatsApp, Feishu, iMessage)"]
G["Gateway<br/>access · sessions · memory · schedules · approvals · apps"]
A["Agent sessions<br/>ACP runtime · kiro-cli · MCP tools · models"]
S --> G --> A
The Gateway separates where the agent runs from where you work with it. In the
desktop app or web dashboard, you can work directly through parallel conversations,
files, task runs, approvals, memory, and apps. From the CLI or any connected
messaging channel, the Gateway routes your work to managed agent sessions under
the same memory, tool, approval, and policy services. Apps extend the dashboard and
Gateway APIs with focused workflows.
Each active conversation or background task uses an agent session. Its session
provider drives kiro-cli over ACP, streams model and tool events, and preserves
conversation state. Depending on the workload, a session is backed by its own
ACP process or by a session handle on a shared multiplexed ACP runtime. The
Gateway manages these sessions along with scheduling, approvals, memory,
security policy, messaging connections, and the dashboard.
The current runtime places the Gateway, agent sessions, ACP processes, and state
on the same host. Run Kiro Crew on your Mac, inside a container on your machine,
or on a remote Linux host you control. Conversation history, memory, and
knowledge indexes remain on that host. Model requests are handled by kiro-cli
and follow the account and model configuration you use there.
Gateway. The Gateway is the long-running Kiro Crew process. It routes
messages from the desktop app, web, CLI, and the messaging surfaces listed below. It persists
session state, injects memory and skills, starts scheduled work, coordinates
subagents, brokers approvals, enforces runtime policy, and exposes activity in
the dashboard.
Agent sessions. A dashboard conversation, Slack thread, or Discord DM maps to
an isolated agent session. Scheduled jobs, task runs, other messaging-channel
conversations, and subagents also use managed sessions. These sessions preserve
conversation context and can run concurrently before returning results to a
parent session or configured surface.
ACP runtime and turns. Kiro Crew supports both a dedicated kiro-cli ACP
process for a session and a shared ACP runtime that multiplexes multiple session
handles. During each turn, the session sends a prompt, streams model and tool
events, resolves approvals, and returns the final result. An agent session is a
logical isolation boundary, not necessarily one OS process.
Use the surface that fits the moment.
| Surface |
Best for |
| Desktop app |
The simplest local experience, with a bundled Gateway plus multi-tab connections to local or remote Gateways. |
| Web dashboard |
Parallel conversations, files, approvals, activity, memory, schedules, apps, settings, and system status at localhost:5476. |
| Slack |
Work from DMs and threads with streaming replies, approvals, notifications, and session links back to the dashboard. |
| Telegram |
Reach your agent from private DMs on your phone or laptop, with streamin |
An open source, agent-powered development workspace that runs on your own hardware, locally or remotely. It persists between sessions, learns from corrections, and keeps working while you are away.