Listed by
Rahul Jain
Reviewed by
Deepak Kumar
About Kane CLI by TestMu AI
Kane CLI by TestMu AI ranks #14 of 21 in AI Code Agents, holds a 4.3/5 editor rating, starts at Free.
Kane CLI is a free AI testing agent and browser testing CLI from TestMu AI that runs plain-English test objectives in real Chrome. It returns structured pass or fail results with a sealed evidence pack, works as a verification step for AI coding agents like Claude Code, and gates CI/CD pipelines through standard exit codes. Local and CI runs are free; cloud runs draw on KaneAI plan credits.
Best for: Developers and QA engineers who want plain-English end-to-end browser tests from the terminal, teams that need AI coding agents such as Claude Code, Cursor, or Codex to verify their changes in a real browser, and CI/CD pipelines that need evidence-backed pass or fail gating without maintaining selector-based scripts.
“Kane CLI is a practical AI testing agent for teams that want plain-English browser tests and a reliable way for AI coding agents to verify their own work. The free CLI, clear exit codes, NDJSON output, and sealed evidence packs make it CI-friendly, though it requires a TestMu AI account and is less deterministic than hand-written Playwright or Cypress suites.”
What is Kane CLI by TestMu AI?
Overview
Kane CLI is a terminal-native AI testing agent built by TestMu AI, the company formerly known as LambdaTest. Instead of writing selectors or XPath, you give it a plain-English objective such as "log in as an admin, open the billing page, and verify the plan shows Enterprise", and it launches your locally installed Google Chrome, drives the flow through the Chrome DevTools Protocol, and reports whether the objective passed or failed. TestMu AI positions it as the validation layer for AI coding agents: a way for Cursor, Claude Code, GitHub Copilot, Codex, Gemini, and similar tools to check that the code they just wrote actually works in a real browser before committing.
The CLI is open source under the Apache-2.0 license, published on npm as @testmuai/kane-cli, and ships signed binaries for macOS (Apple Silicon and Intel), Linux (x64 and arm64), and Windows x64.
Three Modes From One Binary
Kane CLI runs in three ways. The interactive TUI (kane-cli --tui) is meant for authoring and exploring objectives with step-by-step progress. Headless CLI mode (--headless) is designed for CI/CD, where exit codes do the gating: 0 for passed, 1 for failed, 2 for setup, auth, or infrastructure errors, and 3 for timeout or cancellation. Agent mode (--agent) switches stdout to NDJSON, one JSON event per line, ending with a run_end event that carries status, summary, extracted values, credits consumed, and a link to the run in the KaneAI test manager. That stable run_end schema is what makes it practical for AI coding agent verification and scripted pipelines.
Official CI recipes cover GitHub Actions, GitLab CI, Jenkins, and Docker.
Evidence, Replay, and Test.md
Every run seals a single .evidence file containing the test definition, results, per-step screenshots, browser console and network logs attributed to each step, and failure records. Packs can be validated, merged, and opened in a hosted viewer. For tests worth keeping, Kane CLI uses _test.md files: Markdown documents where each step is a plain-English objective. The first run authors the steps and saves a recording; later runs replay passed steps from cache without LLM cost, and only edited steps are re-authored. Files support @import for shared helpers such as a login flow, plus tags for batch runs with parallelism.
Playwright Export and Assurance Features
TestMu AI markets native Playwright export as a "hacker mode" for teams that want to take over generated code. Per the configuration docs, code export produces Python or JavaScript output and requires the run to be uploaded to TestMu AI's test manager. Newer commands extend the tool beyond single runs: kane-cli context extract derives use cases from requirements, kane-cli design tests produces requirement-linked tests, and kane-cli cover reports which requirements are proven versus still owed. Other capabilities include autoheal and vision-based smart waiting, human-in-the-loop pauses for OTPs and CAPTCHAs, custom Chrome profiles for authenticated sessions, and native mobile app testing on Android Emulator or iOS Simulator (local mobile runs require macOS on Apple Silicon; cloud grid runs work from any OS).
Pricing
The CLI itself is free to install and use and no longer has separate paid plans. Local runs and CI runs are free. Cloud runs on the TestMu AI grid are billed against KaneAI plan credits. KaneAI credit plans are licensed per agent: Starter at $19 per agent per month (2,000 credits), Pro at $99 (12,000 credits), and Max at $199 (25,000 credits), with roughly 10 percent off on annual billing. A TestMu AI account is required, but signup does not require a credit card.
How It Compares
As a Playwright alternative or Cypress alternative, Kane CLI trades deterministic, hand-written scripts for intent-based objectives that adapt when the UI drifts. That lowers authoring and maintenance effort, but an LLM-driven run is inherently less predictable than a coded assertion, and first-time authoring consumes credits. The Test.md cache and Playwright export partly bridge that gap. Compared with general-purpose browser agents, Kane CLI is narrower and more test-focused, with exit codes, evidence packs, and test-manager integration built in.
Verdict
Kane CLI is a well-documented browser testing CLI that fits naturally into agentic development workflows. Its strongest points are the stable NDJSON contract, CI-friendly exit codes, and auditable evidence packs. The main trade-offs are the mandatory TestMu AI account, dependence on a local Chrome install, and less determinism than traditional test frameworks.
Pros
- Free to install and use, with free local and CI runs
- Plain-English objectives remove the need for selectors, XPath, or framework boilerplate
- Stable NDJSON run_end schema and documented exit codes make it easy to script and to gate CI/CD pipelines
- Sealed .evidence packs with per-step screenshots, console and network logs give auditable pass or fail results
- Test.md files replay passed steps from cache, avoiding repeated LLM cost on stable tests
- Open source under Apache-2.0 with signed binaries for macOS, Linux, and Windows
Cons
- Requires a TestMu AI account; runs authenticate and sync with the KaneAI dashboard
- Cloud grid runs consume KaneAI plan credits, which start at $19 per agent per month
- LLM-driven execution is less deterministic than hand-coded Playwright or Cypress assertions
- Depends on a locally installed Google Chrome (stable channel) for browser runs
- Local mobile testing is limited to macOS on Apple Silicon
- Code export requires uploading runs to the TestMu AI test manager
How to Use Kane CLI by TestMu AI
- 1Install Kane CLI
Install globally with npm using `npm install -g @testmuai/kane-cli` (requires Node.js 18+), or with Homebrew on macOS and Linux using `brew install LambdaTest/kane/kane-cli`. Google Chrome must be installed for browser runs.
- 2Verify the Installation
Run `kane-cli --version` to confirm the binary is available on your PATH.
- 3Log In to TestMu AI
Run `kane-cli login` to authenticate interactively. In CI, use basic auth from secrets via `kane-cli setup --auth-method basic` with your TestMu AI credentials.
- 4Run Your First Objective
Describe a flow in plain English, for example `kane-cli run "Go to https://example.com and assert the page title contains 'Example'"`. Kane CLI drives Chrome and exits with 0 on pass or 1 on fail.
- 5Switch to Agent or CI Mode
Add `--agent` to get NDJSON events on stdout and a final run_end event, and `--headless` plus `--timeout` for CI. Non-zero exit codes fail the pipeline automatically.
- 6Install the Skill for Your Coding Agent
Run `npx @testmuai/kane-cli-skill` to install the Kane CLI skill for Claude Code, Codex CLI, and Gemini CLI, or point any agent at testmuai.com/kane-cli/agents.md.
- 7Commit Reusable Tests
Write `_test.md` files with plain-English steps and run them with `kane-cli testmd run <file>`. Passed steps replay from cache on later runs; review results in the sealed .evidence pack.
Key Features of Kane CLI by TestMu AI
Authoring
2Describe flows in plain English; Kane CLI navigates, clicks, fills forms, extracts data, and validates outcomes without selectors, XPath, or framework boilerplate.
Commit plain-English tests as Markdown files; passed steps replay from cache with no LLM cost, with @import helpers, tags, and parallel batch runs.
Execution
5Launches your locally installed Google Chrome through the Chrome DevTools Protocol, or connects to an existing Chrome or a Playwright WebSocket endpoint.
Interactive TUI for authoring, headless CLI mode for CI/CD, and agent mode with structured output for AI coding agents.
Adapts to UI changes and uses vision-based waiting to detect loaders and animations before acting.
Pauses for OTPs and CAPTCHAs, supports parameterized secrets, and reuses custom Chrome profiles for authenticated, stateful flows.
Runs objectives on native apps in Android Emulator or iOS Simulator locally on macOS Apple Silicon, or on the HyperExecute cloud grid from any OS.
Integration
4The --agent flag emits one JSON event per line, ending with a stable run_end event containing status, summary, extracted values, credits, and a test manager link.
Exit codes 0 (passed), 1 (failed), 2 (setup or infrastructure error), and 3 (timeout) gate pipelines, with recipes for GitHub Actions, GitLab CI, Jenkins, and Docker.
Export recorded flows to Playwright code in Python or JavaScript after the run is uploaded to the TestMu AI test manager.
Install a packaged skill with npx @testmuai/kane-cli-skill for Claude Code, Codex CLI, and Gemini CLI so agents can verify their own changes in a real browser.
Reporting
1Every run produces a .evidence file with per-step screenshots, console and network logs, and failure records that can be validated, merged, and viewed.
Key Specifications
| Attribute | Kane CLI by TestMu AI |
|---|---|
| Primary Focus | AI testing agent and browser testing CLI |
| Test Authoring | Plain-English objectives and Test.md files |
| Free Tier | Yes (CLI free; local and CI runs free) |
| Starting Price | Free (cloud runs use KaneAI credits from $19/agent/month) |
| Browser | Local Google Chrome via DevTools Protocol |
| Output | NDJSON events, exit codes, .evidence packs |
| Code Export | Playwright (Python or JavaScript) |
| AI Agent Support | Claude Code, Codex CLI, Gemini CLI skill; Cursor, Copilot via agents.md |
| Platform | macOS, Linux, Windows (Node.js 18+ for npm) |
| License | Apache-2.0 |
Integrations
- AI Coding Agent
- Claude CodeCodex CLIGemini CLICursorGitHub Copilot
- Browser
- Google Chrome
- Testing Framework
- Playwright
- CI/CD
- GitHub ActionsGitLab CIJenkinsDocker
- Test Management
- KaneAI Test Manager
- Cloud Grid
- HyperExecute
Limitations
A TestMu AI account is required. Browser runs need Google Chrome installed locally (npm installs also need Node.js 18+). Agent runs default to a cap of 50 reasoning steps per objective. Local mobile testing on iOS Simulator or Android Emulator requires macOS on Apple Silicon. Code export supports Python and JavaScript and only runs after a test manager upload. Cloud grid runs consume KaneAI plan credits. The packaged agent skill installer targets Claude Code, Codex CLI, and Gemini CLI.