Kiro

Kiro Delegation via Orca Lanes

Delegate work to Kiro CLI (kiro-cli, the rebranded Amazon Q Developer CLI) when Claude Code's context window is running low, when you need an independent session for isolated analysis, or when you want a cross-family code review.

The delegation runs as a lane: an Orca-managed terminal that Kiro works in. This matters because a plain headless call blocks the caller for the whole task (measured: 2m38s for a one-file review), which means no parallelism, no progress visibility, and a dead orchestrator while it runs. A lane returns a handle in about a second, so you dispatch, do other work, and collect later — and because the lane is a real terminal in the Orca UI, a human can watch it or take over.

Measured on this contract: three lanes dispatched in 5 s total and all three finished in 76 s; the same work sequentially would have blocked for minutes.

Quick start

LANE=/scripts/kiro_lane.sh

# Blocking convenience (start + wait + read + close):
bash $LANE run --tier deep "Summarize /abs/path/to/design.md in 5 bullets"

# Non-blocking — the reason lanes exist:
H=$(bash $LANE start --tier deep --title "analyze-auth" "Analyze /abs/path/auth.ts for authz gaps")
# ... do other work, dispatch more lanes ...
bash $LANE wait  --handle $H --timeout 900   # exits with Kiro's own exit code
bash $LANE read  --handle $H                 # cleaned result
bash $LANE close --handle $H

bash $LANE status --handle $H                # pending | done rc=N | gone

Run several at once by starting each lane, then waiting on each handle:

H1=$(bash $LANE start --tier quick --title "sum-a" "Summarize /abs/a.md in 3 bullets")
H2=$(bash $LANE start --tier quick --title "sum-b" "Summarize /abs/b.md in 3 bullets")
for h in $H1 $H2; do bash $LANE wait --handle $h --timeout 600; bash $LANE read --handle $h; done

Give each WRITING lane its own git worktree. Parallel lanes writing one checkout will clobber each other, and telling a worker "only touch file X" is not isolation — the others still see its uncommitted changes, and one git stash or commit -a eats their work. Read-only lanes (the default) share a directory safely.

Choosing the model: --tier

Naming an exact model is a judgement call you usually don't want to make, and hardcoding one is how a skill rots — the previous version of this skill still listed qwen3-coder-480b and gpt-5.5, both since withdrawn. Describe the work instead; the tier resolves against kiro-cli chat --list-models, so a withdrawn model is skipped rather than trusted.

| --tier | Leads with | Cost | Use for | |---|---|---|---| | quick | gpt-5.6-luna | 0.6x | summaries, extraction, mechanical checks | | deep | gpt-5.6-terra | 1.2x | routine multi-step analysis (good default) | | hard | claude-opus-5 | 2.2x | hardest reasoning, large refactors | | review | gpt-5.6-sol | 2.4x | adversarial review — non-Claude first, on purpose |

Omit --tier to let Kiro's own auto routing decide (1.0x). Pass --model to pin one exactly; it overrides --tier and says so.

claude-fable-5 is in no default tier: at 4.4x it is the most expensive model offered, and the CLI's own catalogue marks it "DEVELOPMENT USE CASES ONLY, NOT FOR CUSTOMER DATA, ITAR OR PII" — so it is opt-in via --model, never a default for a customer's repository.

Trust levels

Pick the least privilege the task needs; read is the default because analysis and review only need to read.

bash $LANE run --trust none "Explain the CAP theorem tradeoffs"     # no file access
bash $LANE run --trust read "Summarize /abs/path/doc.md"            # fs_read (default)
bash $LANE run --trust all  "Refactor /abs/path/project/"           # writes allowed
bash $LANE run --trust "fs_read,execute_bash" "Run the tests and explain failures"

Note that execute_bash is rejected in non-interactive mode — there is no user to approve it. Kiro will try, be denied, and waste a turn, so prefer prompts that reason from files rather than ones that need to run commands.

Code review

scripts/run_kiro_review.sh builds the git scope, feeds an adversarial reviewer prompt (assets/prompts/adversarial-review.md), and returns findings with file:line, a severity, a concrete fix each, and VERDICT: ship | no-ship.

REV=/scripts/run_kiro_review.sh

bash $REV --lane                                  # auto-detect scope, run as a lane
bash $REV --lane --scope working-tree              # staged + unstaged + untracked
bash $REV --lane --scope branch --base origin/develop
bash $REV --lane -- src/payments/ src/auth/handler.ts
bash $REV --focus "concurrency and the retry path" # blocking (no --lane)
bash $REV --lane --json                            # also emit a JSON findings block

--lane prints a handle plus the exact wait/read/close commands to collect it. Reviews are the strongest case for a lane: they take minutes, and blocking the orchestrator for one buys nothing.

Why the reviewer defaults to a non-Claude model. In the normal flow Claude Code wrote the code and then delegates the review here. If the review also ran on a Claude model, the same family would sign off on its own work. So the chain leads with gpt-5.6-sol and falls through gpt-5.6-terra → claude-opus-5 → qwen3-coder-next → deepseek-3.2, and it warns when only a Claude model is left — a clean verdict from a same-family reviewer deserves matching skepticism.

Other properties worth relying on:

• Review-only. It reports; it does not fix, stage, or commit. Hand findings

back to the user or the main agent.

• Read-only by construction. The wrapper pre-computes the diff and runs Kiro

with fs_read only, so it cannot modify anything while reviewing.

• Return findings verbatim. Do not silently fix or paraphrase them.

An optional persistent reviewer agent is bundled at assets/agents/code-reviewer.json; its own config restricts execute_bash to read-only git/grep. Copy it to ~/.kiro/agents/ and set KIRO_REVIEW_AGENT=code-reviewer. The default path needs no installation.

When Orca is not available

The scripts detect this and explain which case it is, because the two need opposite responses: an absent binary needs an install, whereas an installed but closed Orca just needs orca open. Either way the work still runs — it falls back to a direct blocking call rather than failing — but you lose parallelism and visibility, so the recommendation is worth acting on.

On Linux the Stably binary installs as orca-ide (deb/rpm from github.com/stablyai/orca releases; headless servers run orca serve / orca-ide serve with Xvfb). The resolver probes orca-ide alongside the macOS paths, so a deb install is picked up with no configuration; ORCA_BIN still overrides everything when set.

Writing the prompt

Kiro starts with zero context — it has not seen your conversation. Put everything into the prompt: absolute paths (it may not share your working directory), what you want, and the output format you expect. For structured output, ask for a fenced JSON or Markdown block; there is no native JSON mode for chat.

Read /abs/path/to/file.py and identify:
1. Bugs or logic errors   2. Security vulnerabilities   3. Performance issues
Report critical issues only, as a numbered list with file:line and a one-line fix each.

Known limits (verified, not guesses)

• Do not use Orca's terminal wait for lanes. --for tui-idle fires early

(on a 35 s task it reported done after 6.6 s, with one line of output), because headless Kiro paints no TUI for it to track. --for exit never fires, because the shell outlives the command. kiro_lane.sh polls its own completion sentinel instead, which carries Kiro's exit code and cannot fire early.

• Kiro v3 is unusable headless right now. --v3 --no-interactive produced no

output for over four minutes and had to be killed, while the default v2 engine answered the same prompt in 6 s. The v3-only features in the changelog (Introspect Subagent, global hooks, /upgrade-agent, --mode spec) are all documented for interactive kiro-cli --v3, and CLI 3.0 is still early access. Revisit when it leaves early access.

• Interactive slash commands don't work headless (/goal, /plan, pickers).

A human who wants the genuine interactive loop runs kiro-cli chat themselves.

• Lane output can lose the occasional space between words (usedin,

는S) — Orca pty rendering, not our filtering; the same prompt without a pty keeps every space. It is left unrepaired on purpose: every repair rule also splits getUserName or detaches Korean particles from identifiers (userId를 → userId 를), and corrupting a file:line citation is worse than a missing space. Use run_kiro.sh when exact prose spacing matters.

• Lane tab titles drift to the command or cwd; the pty always wins that race.

Each lane therefore echoes a === kiro lane: === banner into its own scrollback, which is what actually identifies it in the UI.

• Each call is stateless (no memory between lanes) unless you use Kiro's session

resume, which is cwd-scoped. Requires Kiro CLI installed and authenticated.

Files

kiro/
├── SKILL.md
├── README.md
├── scripts/
│   ├── kiro_lane.sh          # lane delegation: start|wait|read|status|close|run
│   ├── run_kiro.sh           # direct blocking call (no pty; exact spacing)
│   └── run_kiro_review.sh    # code-review specialization (--lane supported)
└── assets/
    ├── prompts/adversarial-review.md
    └── agents/code-reviewer.json

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: jesamkim
• Source: jesamkim/oh-my-skills
• License: MIT

Install and usage instructions live in the source repository linked above.