# Quick ↔ Kiro: ACP Connection Guide & Lessons Learned

## How We Connected Amazon Quick to Kiro

### The Architecture

Amazon Quick Desktop connects to Kiro CLI via **ACP (Agent Client Protocol)** — an open protocol for connecting editors/IDEs to coding agents. It's the opposite direction of MCP:

- **MCP** = connects agents to tools/data (outward)
- **ACP** = connects editors to agents (inward)

Quick is the **orchestrator** — it calls Kiro. The reverse direction (Kiro → Quick) does NOT exist because Quick Desktop has no CLI agent endpoint.

```
┌─────────────────┐        ACP         ┌─────────────────┐
│  Amazon Quick   │ ──────────────────▶ │   Kiro CLI      │
│  (orchestrator) │                     │   (agent)       │
└─────────────────┘                     └─────────────────┘
```

### Prerequisites

1. **Kiro CLI** installed and authenticated (`kiro --version` works)
2. **Amazon Quick Desktop** version 1.8+ (check Settings → About)
3. **ACP enabled** in Kiro: `kiro server --port 7800` (or your chosen port)

### Setup Steps

#### Step 1: Start Kiro in ACP Mode

```bash
kiro server --port 7800 --host localhost
```

Keep this running in a terminal while using Quick.

#### Step 2: Connect Quick to Kiro

In Amazon Quick Desktop:
1. Open **Settings → Integrations → ACP Agents**
2. Click **Add Agent**
3. Enter:
   - **Name**: Kiro
   - **URL**: `http://localhost:7800`
   - **Agent ID**: (leave blank for default)

#### Step 3: Test the Connection

In Quick, type: `@Kiro write a Python function to reverse a string`

Quick should route the request to Kiro and stream the response back.

---

## Multi-Agent Architecture Lessons Learned

### What Worked Well

**Quick as orchestrator + Kiro as specialist** is a powerful pattern:
- Quick handles reasoning, planning, and tool orchestration
- Kiro handles code generation, file editing, and terminal commands
- The boundary is natural: Quick asks "what should we build?" and Kiro builds it

**Parallel agent calls** — Quick can call Kiro and other ACP agents simultaneously for independent subtasks (e.g., generate tests while writing implementation).

### What Didn't Work

**Context sharing** — Quick and Kiro don't share memory/context. You need to explicitly pass context in each call. Workaround: include relevant context in your Quick prompt.

**File system awareness** — Kiro operates in a workspace; Quick doesn't automatically know what files Kiro has created. Use MCP file tools in Quick to read Kiro's output.

**Long-running tasks** — ACP has a timeout (~60s). For tasks like "refactor the entire codebase," break them into smaller chunks.

### Recommended Patterns

```
Pattern 1: Research → Build
Quick: Research the best approach for [problem]
→ Quick calls Kiro: Implement [approach] in [file]

Pattern 2: Spec → Code → Test  
Quick: Write a spec for [feature]
→ Quick calls Kiro: Implement spec
→ Quick calls Kiro: Write tests

Pattern 3: Review → Fix
Quick: Review [code] and list issues
→ Quick calls Kiro: Fix issue #1 in [file]
→ Quick calls Kiro: Fix issue #2 in [file]
```

---

## Quick's 3 Sub-Agents

When you connect Kiro via ACP, Quick exposes 3 sub-agents you can configure:

1. **Code Agent** — handles implementation requests (routes to Kiro)
2. **Review Agent** — handles code review (can route to Kiro or use Quick's built-in models)
3. **Debug Agent** — handles error analysis and fixes (routes to Kiro)

Configure each in Settings → Integrations → Sub-Agents.

---

## Troubleshooting

**Connection refused**: Make sure `kiro server` is running before connecting Quick.

**Timeout errors**: Reduce task complexity or increase timeout in Quick Settings → Advanced → ACP Timeout.

**"Agent not found"**: Verify the Agent ID in Quick matches what Kiro reports on startup.

**Auth issues**: Ensure your Midway session is active for both Quick and Kiro.

---
*Guide by Rafael Araujo (@raraujo) — shared in #kiro-productivity-for-all, May 15, 2026*
*Based on hands-on experiments connecting Quick Desktop to Kiro via ACP*