Kiro Crew: AWS's Open-Source AI Agent Orchestrator
AWS open-sourced Kiro Crew on August 4, 2026. It's an Apache 2.0 licensed, persistent development workspace that orchestrates multiple AI agents, preserves context across sessions, schedules recurring work, and runs while you're offline. This isn't another chat wrapper. It's an orchestration layer designed to eliminate the "glue" work between tools.
The Problem: Developers Are the Integration Layer
After 10+ years building cloud infrastructure, I've accepted a frustrating truth: I spend more time connecting tools than doing engineering. The Kiro Crew blog post nails it: developers are the integration layer between their own tools.
With Kiro CLI, you prompt, it responds, it does solid work. But close the tab? Context is gone. You spend the first ten minutes re-explaining what you're working on. Steering files carry over, but working memory doesn't.
Kiro Crew breaks that pattern. Memory carries forward. Corrections become lasting lessons. Repeated patterns become reusable skills. Work continues on a schedule even when you're not at your keyboard.
Core Capabilities
Self-Learning Memory
This isn't just "remembers your last conversation." Crew maintains:
- Memory: preferences, active projects, relevant history across sessions
- Lessons: corrections become persistent rules. Tell it once to stop using
var, and it never does again. Workspace-scoped, so project A's rules don't bleed into project B. - Skills: repeated patterns get synthesized into named, inspectable Markdown files.
- Knowledge graph: architectural decisions, coding preferences, project context stored with vector embeddings and full-text search.
Everything's visible. Edit it, delete it, scope it. No black box learning you can't audit.
Scheduled and Unattended Work
This is where Crew separates from every other AI coding tool I've used:
- Cron jobs: timezone-aware, per-job timeouts, jitter to avoid thundering herds, skip dates for maintenance windows.
- Webhooks: authenticated endpoints trigger agent work when external events arrive.
- Heartbeats: watches state changes in PRs, deployments, pipelines. Triggers work when conditions are met.
- Checkpoints and retries: long-running tasks save progress and resume after failures.
The key detail: jobs that don't require model reasoning run as plain scripts. No inference call, no credit consumption. A health check script costs nothing. Only reasoning costs credits.
Multi-Agent Orchestration
Crew can run several conversations concurrently, each with isolated context. It delegates independent research and implementation to sub-agents, then returns results to a parent conversation that stays focused on the goal.
You give it a migration task. It spawns one agent to analyze the source code, another to write the target code, another to handle tests. The parent coordinates.
Apps (Purpose-Built Interfaces)
Some work doesn't belong in a chat window. Apps wrap agents, skills, schedules, and integrations into custom UIs:
- DevFleets: work tree management
- Task Runner: long-running task execution
- Issue Radar: PR and issue triage with readiness labels
- Code Review Sage: reviews by blast radius, stages draft GitHub reviews
- Research Lab: fans out sub-questions to parallel agents, streams findings
Build your own with the App SDK (TypeScript or Python). Combine React UI with the agent runtime and event bus.
7 Layers of Security
Giving an agent real access to your code and CI demands real security. Crew ships with:
- OS-level process sandbox
- Tool approval gates (you decide what runs)
- Sensitive path blocking
- Write-protected paths
- Denied command patterns and suspicious bash blocking
- MCP input validation and output redaction
- Credential redaction and signed audit logs (SEL)
Because it's open source, you can verify every layer. Read the code, trace the execution path, confirm the sandbox actually sandboxes.
How It Fits in the Kiro Ecosystem
Kiro now has four surfaces: IDE, CLI, Web, and Crew. Here's how they relate:
| Kiro IDE | Kiro CLI | Kiro Web | Kiro Crew | |
|---|---|---|---|---|
| Sessions | Interactive | Interactive | Interactive | Persistent, autonomous |
| Scheduling | No | No | No | Cron, webhooks, heartbeats |
| Multi-agent | No | Sub-agents | No | Full parallel orchestration |
| Memory | Session only | Session only | Session only | Cross-session persistent |
| Works unattended | No | No | No | Yes |
| Open source | No | No | No | Yes (Apache 2.0) |
Crew runs on the Kiro CLI and reads your existing .kiro configuration. Steering files, skills, custom agents all carry over. No migration. No reconfiguration.
It also uses Agent Client Protocol (ACP) for orchestration, meaning every step is observable live. You watch how it plans, spawns sub-agents, selects tools, gates actions for approval, and synthesizes results.
Where I Would Have Used This Last Month
Let me give you three real scenarios from my past few weeks where Crew would have saved me hours.
The CDK migration that stalled every evening. I was migrating a client's CloudFormation stacks to CDK. Each stack took 20-40 minutes of agent time in Kiro CLI: analyzing the template, generating CDK constructs, running cdk synth to validate. I could do maybe 3-4 stacks per session before context started degrading. With Crew's checkpoints and persistent memory? I could have queued all 12 stacks, let it chew through them overnight, and come back to a PR with all the synthesized outputs validated.
The Monday morning "what happened over the weekend" scramble. Every Monday I open Slack to 40+ messages, check three repos for new PRs, look at whether the weekend deploy held, and scan CloudWatch for anomalies. This takes me 45 minutes before I write a single line of code. A Crew morning digest cron job does this in 5 minutes and hands me a summary before my first coffee. Zero credits for the Slack scan and CloudWatch check (plain scripts), minimal credits for summarizing findings.
The recurring dependency update nobody does. I have a personal project with 15 npm dependencies I should update monthly. I never do. A weekly Crew heartbeat could check for security advisories, test the updates, and open a PR only when tests pass. Cost: nearly zero because most runs would be "nothing to update" (plain script check) with the occasional reasoning call when something actually needs upgrading.
Real Use Cases Worth Trying First
Don't start with something complex. Start with work that already extends beyond one session.
Morning PR digest: Schedule a daily cron job that checks open PRs, summarizes status, and flags what needs your attention. You get a briefing before your first coffee. The plain "list open PRs" part is a script (zero credits). The "summarize what changed and whether it's ready for review" part takes one reasoning call (2-3 credits).
Flaky test hunter: Set a heartbeat on your CI pipeline. When a test fails twice in a row, Crew investigates the logs, identifies the pattern, and opens a fix PR. I have a test suite where test_concurrent_writes fails every third run due to a timing issue I've been "meaning to fix" for two months. A heartbeat that catches and fixes it without me ever opening the file? That's worth the credits.
Incident investigation across repos: Point it at an alert. It pulls logs from multiple repos, correlates timestamps, identifies the likely root cause. You stay focused on the fix while Crew handles the forensics.
Dependency drift detection: Weekly cron that checks for outdated packages, stale branches, docs that no longer match the code, and failing test suites nobody noticed. Most weeks it finds nothing (zero credits, plain script). When it does find something, it opens an issue with the exact versions, breaking changes, and a suggested upgrade path.
Long-running migration with checkpoints: Start a multi-hour migration. It proceeds through checkpoints, validates each step, retries failures, and you come back to progress rather than a stalled process. Each stack is a checkpoint. If stack 7 fails validation, Crew retries with a different approach. You don't restart from stack 1.
Getting Started
Prerequisites: Kiro account (free tier works for testing, Pro+ recommended for real use), Kiro CLI installed and authenticated, macOS/Linux/Windows, familiarity with .kiro configuration.
Installation:
# Clone the repo
git clone https://github.com/kirodotdev/KiroCrew
# Or download from releases (macOS, Linux, Windows)
# https://github.com/kirodotdev/KiroCrew/releases
# Core commands
kirocrew chat # Start a session
kirocrew run # Execute a task
kirocrew cron # Manage scheduled jobs
kirocrew spawn # Spawn parallel agents
The Origin Story
Three engineers inside Amazon built a side project called MeshClaw. They wanted something simple: kick off a task, walk away, come back to something reviewable. Run several tasks at once instead of babysitting one prompt at a time.
Then other Amazon builders picked it up. Not because someone mandated it. Because engineers kept hitting gaps in their workflows, fixing them, and pushing the fix upstream. In less than six months, 39,000+ Amazon builders adopted it. Nearly 500 contributors shipped 597 updates at an average pace of 143 weekly commits.
That organic adoption is the strongest signal. Thousands of engineers chose to use it, hundreds chose to improve it.
What to Watch Out For
Crew is new. Expect rough edges. The open-source repo is young, and while the core features are solid, the ecosystem around it (apps, integrations) is still growing. The pricing model—credits for reasoning, zero for scripts—is refreshing, but you'll need to monitor your usage to avoid surprises. Also, the security model is robust, but it's only as good as your configuration. Start with a sandboxed environment.
The Bigger Picture
Kiro Crew is a significant step toward autonomous development workflows. It's not just another AI coding assistant; it's an orchestration layer that turns your AI agents into a persistent, parallel, and scheduled workforce. If you're already using Kiro CLI, Crew is a natural next step. If you're not, this might be the reason to start.
Next steps: Clone the repo, set up a cron job for a morning digest, and see how it feels to have your agents working while you sleep.
