Kiro Meets Kane CLI: 4 Paths to Shift-Left Browser Verification in Your Agentic IDE
Add real browser checks to Kiro with Kane CLI. Four setup paths, from a one-click Power to steering files and hooks, so your agent proves its work.
Introduction
By pairing Kiro's spec-driven agentic IDE with Kane CLI's plain-English browser verification, developers get a real Chrome browser inside the loop where code is written. Kiro plans and builds the feature. Kane CLI proves it works. Same IDE, same session, no context switch.
This guide covers four ways to bring Kane CLI into Kiro — from a one-click Power install to persistent steering files and hooks — so your agent stops guessing and starts verifying.
Why This Matters
Agentic IDEs closed the gap between intent and code. The next frontier is the gap between code and proof.
An agent reads the requirements, writes the components, wires the routes, and marks the task done. What no agentic IDE does on its own is open a browser, click through the signup flow, and confirm the feature works as intended. That last mile still lands on a human who alt-tabs to Chrome after every agent run.
Kane CLI closes it. Built by TestMu AI, this AI browser-automation tool takes objectives in plain English, drives a real Chrome browser, and returns a structured pass or fail with a shareable evidence link. It now ships as a terminal-based Kiro Power, so the agent picks it up on demand — no wiring required.
The result is shift-left verification: testing moves earlier in the development cycle, so bugs surface in the same session that created them instead of in a QA cycle days later.
What is Kiro?
Kiro is AWS's agentic IDE, available as an IDE, CLI, and web and mobile. What sets it apart is how it works: instead of autocompleting line by line, it treats a structured specification as the unit of work. You describe what you want, and Kiro produces the requirements, design, and tasks, then implements against them — planning through specs, building through agentic chat, and automating repetitive steps through hooks that fire on events like file save. Along the way, steering files keep it aligned to your project's rules and context, and privacy controls keep your code secure.
To reach beyond your codebase, Kiro connects to external tools and data through MCP servers. But wiring up several MCP servers has a cost: the agent has to load dozens of tool definitions before it writes a single line of code, whether it needs them or not.
Powers solve that. A Power bundles MCP tools, steering, and hooks into one install that stays dormant until the conversation calls for it, then loads only what's needed. The agent gains a specialized capability on demand, without carrying its weight on every request.
Kane CLI ships as one.
Prerequisites
Before you start, make sure you have:
- Kiro: download from kiro.dev and sign in
- Node.js 18 or higher: required by Kane CLI
- Google Chrome: Kane CLI launches it automatically
- A TestMu AI account: sign up at testmuai.com/register . Confirm your plan supports the CLI features used below (agent mode and parallel runs)
- An app to test: anything reachable by URL, including localhost
Getting Started
There are four ways to bring Kane CLI into Kiro. Start with the first. Add the rest as your workflow gets heavier.
1. Install the Kane CLI Power (Recommended)
Kiro Powers bundle MCP tools, steering files, and hooks into a single install. The agent gets specialized knowledge on demand instead of loading every tool definition up front.
Kane CLI is available as a Power — "Kane CLI: Browser Automation and AI Test Authoring" by TestMu AI — which lets the agent drive a real browser from natural-language objectives and author structured test cases and scenarios from a feature description.
What the Power gives Kiro:
- Browser tools: run objectives, assert page state, extract values, capture evidence
- Steering: the agent learns Kane CLI's command surface, objective patterns, and output format
- Test authoring: turn a feature description or spec into structured test cases
- Dynamic activation: the Power loads when you mention testing, verifying, or browser behavior. It stays dormant otherwise
- No context overload: tool definitions do not sit in context on every request
Option A: From within Kiro
- Open Kiro
- Click Powers in the left sidebar
- Find Kane CLI and click Install
Option B: Add Custom Power
- Open the Powers panel
- Click Add Custom Power
- Import from URL or from a local folder
That is it. The Power is installed, and Kiro will reach for browser verification when your conversation calls for it.
2. Install and Run From the Kiro Terminal
Prefer the terminal, or want to run flows yourself outside the agent loop? Open Kiro's integrated terminal and run three commands.
1
2
3
4
5
npm install -g @testmuai/kane-cli
kane-cli login
kane-cli run --url http://localhost:3000 "click Sign Up, fill the email field with 'test@example.com', submit the form, assert the page contains 'Check your inbox'"Chrome opens. The agent works through the objective step by step. You get a pass or fail, a summary of what happened, and a link to the run with video and step trace attached.
No config file. No selectors. No test framework. That is the whole setup.
3. Agent Mode, Steering, and Hooks
The Power covers most workflows. If you want direct control over how Kiro calls Kane CLI, wire it yourself.
Agent mode
Kane CLI ships an agent mode that suppresses the terminal UI and emits newline-delimited JSON (NDJSON) to stdout — one JSON object per line. The final line is always a
run_end event carrying the verdict.1
2
3
4
kane-cli run "Verify the checkout flow completes successfully" \
--url https://myapp.com \
--agent \
--headlessKiro reads the last line and knows exactly what happened:
1
2
3
4
5
6
7
8
{
"type": "run_end",
"status": "passed",
"summary": "Task completed successfully",
"final_state": {"order_total": "$29.99"},
"session_dir": "~/.testmuai/kaneai/sessions/...",
"run_dir": "~/.testmuai/kaneai/sessions/.../runs/0"
}Parse it directly:
1
kane-cli run "..." --agent 2>/dev/null | tail -1 | jq -r '.status'Exit codes make this safe to chain:
0 passed, 1 failed, 2 error, 3 timeout. Kiro can branch on the result, read the failure summary, patch the code, and run the same objective again. That loop closes without a human in it.Tip: Always combine--agentwith--headlessin non-interactive contexts to avoid display-server errors.
Steering files
Kiro's steering files are Markdown documents that load into the agent's context automatically. They live in
.kiro/steering/ for a workspace or ~/.kiro/steering/ globally, and YAML front matter controls when they load.Create
.kiro/steering/kane-cli.md:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
inclusion: always
# Browser verification with Kane CLI
After implementing any UI change, verify it with Kane CLI before marking
the task complete.
Command: kane-cli run "<objective>" --url <app_url> --agent --headless
Parse the final NDJSON line. status is "passed" or "failed".
Objective patterns:
- Actions: "click the Login button", "fill the email field with '{{email}}'"
- Assertions: "assert the page contains 'Order Confirmed'"
- Extractions: "store the cart total as 'total'"
App notes:
- Local dev runs on http://localhost:3000
- Login is at /auth/signin, test user is in variables as {{email}}
- Keep objectives under 15 steps. Split longer flows into separate runs.Set
inclusion: always and every Kiro interaction carries this context. Set inclusion: fileMatch with a glob like "src/components/**/*.tsx" and it only loads when the agent touches UI code. Set it to manual and pull it in with #kane-cli in chat when you need it.Hooks
Pair steering with a Kiro hook and the loop runs itself. Hooks live in
.kiro/hooks/ and fire on IDE events like PostFileSave:1
2
3
4
5
6
7
8
9
10
11
{
"name": "verify-ui-on-save",
"trigger": "PostFileSave",
"matcher": "src/components/.*\\.tsx$",
"action": {
"type": "command",
"command": "kane-cli run \"go to http://localhost:3000, assert the page renders without errors\" --agent --headless"
},
"timeout": 300,
"enabled": true
}Save a component. A real browser checks it. No one asked.
Kane CLI has its own context layer that stacks with this. Global context lives at
~/.testmuai/kaneai/global-memory.md and project context at .testmuai/context.md. Put app structure, nav patterns, and known quirks there so the browser agent stops rediscovering your UI on every run.4. Kane CLI's Official Agent File
Kane CLI publishes a machine-readable agent file at testmuai.com/kane-cli/agents.md . Point Kiro at it once and the agent learns the full command surface: flags, objective patterns, NDJSON parsing, variables and secrets, parallel execution, and how to present results to a human without leaking internal field names.
There is also a packaged skill installer:
1
npx @testmuai/kane-cli-skillFull documentation is at testmuai.com/support/docs/kane-cli-introduction .
Using the Integration
Once the Power is installed, natural-language requests in Kiro turn into real browser runs.
| Query | What Kiro does with Kane CLI now |
|---|---|
| "Verify the signup flow works on localhost:3000" | Calls Kane CLI in agent mode, drives Chrome through signup, returns a pass/fail with evidence on the first run |
| "Run the four smoke tests in parallel" | Spawns sub-agents, one Chrome instance each. Total time equals the slowest test, not the sum |
| "The checkout test failed, fix it" | Reads the failure summary and screenshots, patches the code, reruns the same objective |
| "Export the login flow to Playwright" | Converts the plain-English flow into native Playwright code |
The spec-to-verification loop is where this earns its keep. Kiro writes the spec. Kiro implements the tasks. Kane CLI proves the acceptance criteria hold in a real browser. Nobody alt-tabs.
Responsible AI With Verification
Agentic development moves fast. Verification is what keeps it accountable.
| Pillar | What the integration delivers |
|---|---|
| Transparency | Every run produces a step trace, screenshots, and video. You can watch exactly what the agent did |
| Accountability | Persistent evidence links attach to PRs and bug reports. Claims of "it works" come with proof |
| Reliability | Autoheal and smart waiting adapt to cosmetic UI changes (note: semantic changes to a flow still require updating the objective). Assertions return a binary pass or fail, not a summary |
| Efficiency | Reusable _test.md files cache recordings after the first run and replay deterministically, avoiding repeat LLM cost |
| Security | Credentials pass as variables with "secret": true. Secrets stay out of objectives, logs, and version control |
An agent that reports success without evidence is a liability. An agent that attaches a video of the passing flow is a teammate.
Conclusion
Kiro made specs the unit of work. Kane CLI makes proof the unit of done.
Installing the Power takes one click. From there you can drop to the terminal for direct runs, hand Kiro agent mode so it verifies its own output, add a steering file so it never forgets to, and wire a hook so verification runs on every save.
Developers stop being the manual test step between the agent and the deploy.
Get started today: Install the Kane CLI Power from Kiro's Powers panel. To learn more about Kane CLI, visit testmuai.com/kane-cli .
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article