Test the apps you build with Qodo in a real browser, not just in unit tests
Qodo keeps your code sound with generation, review, and unit tests. What it cannot do is open the running app and confirm the journey works on screen. Point Kane CLI at your live app and verify the flow in a real browser. Free to install.
or read the documentation
Why test apps built with Qodo
Qodo is a code-integrity platform: agents generate code, review diffs, and write unit tests inside your IDE and CI. Its strength is code-level quality, catching the bug in the logic before it ever lands in a branch.
But unit tests and code review run on the code surface. They cannot open the app in a browser and confirm the signup form submits, the redirect lands, or the deployed build renders for a real user. A green suite can still ship a blank screen.
Kane CLI adds that missing layer. Describe the journey in plain English and it drives your live app in real Chrome, signs up fresh, and verifies each step. Qodo proves the code; Kane CLI proves the running app. Your agent can run both.
What Kane CLI tests in your Qodo app
Real-browser verification of signup, forms, and the deployed build, on top of Qodo's code-level tests.
Signup and auth for a fresh user
Sign up as a new account, confirm the redirect after login, and verify the session holds. A unit test mocks the auth call; Kane CLI runs the real flow in a browser and catches the redirect that 404s or the screen that freezes after login.
Forms and CRUD in the real UI
Submit the forms Qodo wired to your backend, check validation, and confirm the row lands and reads back. Catch the silent insert that passes its unit test but never reaches the database in the running app.
Deployed build, not just green tests
Run against your live domain to catch the blank screen from a missing env var, a 404 on refresh from SPA routing, and asset chunks that 404 after a redeploy. Your suite can be all green while the deployed app is broken.
Regression after every Qodo change
Qodo edits and reviews code continuously, and the next change can quietly break a flow even when unit tests still pass. Lock in known-good journeys and re-run them in a real browser on every change.
Evidence a real user could reproduce
Kane CLI only does what a person can do on screen, so a pass means the Qodo-built journey actually renders and works, not that a mock returned the expected value. Each run leaves a video and step trace to attach to the Qodo review.
Runs in CI next to Qodo's checks
Slot Kane CLI into the same pipeline as Qodo's diff review and unit-test stages. Standard exit codes gate the merge on whether the rendered UI behaves, adding a browser verdict to Qodo's code-level one.
Build up confidence before real users sign in
Start in your terminal
Validate on the cloud
Release with confidence
Built for the build-then-verify loop
Kane CLI and KaneAI share the same automation engine and dashboard.
Sound code and a working screen
Qodo locks in code quality through generation, diff review, and unit tests. Kane CLI adds the layer Qodo cannot reach: it drives the deployed app in real Chrome so a clean diff also means a working signup, form, and dashboard for the person using it.
Where the unit test stops, the browser starts
A mocked unit test confirms a function returns the right value; it never sees the broken route, the missing env var, or the runtime error that greets a real user. Point Kane CLI at the live URL Qodo built and it walks the rendered journey to catch what code-level checks structurally miss.
Proof to attach to the Qodo review
Every Kane CLI run captures a video, a step-by-step trace, and a replay link. Drop it straight into the Qodo review thread or PR so reviewers see the running app behind the approved diff, not just green checkmarks.
Test your Qodo app in three steps
Install Kane CLI
Run npm install -g @testmuai/kane-cli and sign in with your TestMu AI account. It sits beside Qodo, with nothing to add to your codebase and no change to your Qodo IDE or CI setup.
Point it at the app Qodo shipped
Use the preview link or deployed domain for the build Qodo just generated and reviewed. Run flows from the terminal, or let your Qodo agent fire them in CI the moment its unit tests pass.
Describe the journey Qodo built
Spell out the flow in plain English: sign up fresh, submit the form Qodo wired up, confirm the row reads back. Kane CLI walks each step in real Chrome and reports exactly where the running app diverges from the code Qodo signed off on.
Get Started With Kane CLI
🎉 Launch offer: Bonus credits for the first 3 months on paid plans
Choose the right plan for you
Local test authoring via CLI
Auto-heal & vision
View test cases on UI
Test Manager
Free
$0
/month
200 Credits
Resets in every
30 days
Starter
$19
/month
2000 Credits
Launch: 4,000 Credits (+100%)
Bonus for first 3 months
Pro
$99
/month
10,000 Credits
Launch: 15,000 Credits (+50%)
Bonus for first 3 months
Enterprise
Get access to solutions built on Enterprise-Grade Security, Privacy, and Compliances.
Need more credits?
Got a bigger use case in mind?
Let’s talk
Choose the right plan for you
Free
$0
/month
200 Credits
Resets in every
30 days
Starter
$19
/month
2000 Credits
Launch: 4,000 Credits (+100%)
Bonus for first 3 months
Pro
$99
/month
10,000 Credits
Launch: 15,000 Credits (+50%)
Bonus for first 3 months
Enterprise
Get access to solutions built on Enterprise-Grade Security, Privacy, and Compliances.
Need more credits?
Got a bigger use case in mind?
Let’s talk
Get the technical rundown
Documentation
Everything you need to install, configure, and run Kane CLI in under 2 minutes.
Frequently asked questions
Qodo owns the code layer, generating code, reviewing diffs, and writing unit tests inside your IDE and CI. Kane CLI owns the running-app layer that begins where those checks end. After Qodo builds and ships a change, install Kane CLI, describe the user journey in plain English, and it drives your live app in real Chrome to confirm the rendered flow holds together. The two stack cleanly: Qodo certifies the code, Kane CLI certifies that the app a user opens actually works.
Unit tests and code review confirm a function returns the right value and a diff is clean. They cannot open the app in a browser and confirm the signup form submits, the redirect lands, or the dashboard renders for a real user. A component can pass every unit test and still show a blank screen because of a missing env var, a broken route, or a runtime error the mocked test never saw. Kane CLI runs the real UI and verifies the journey end to end, closing the gap that code-level tests cannot reach.
The full signup and authentication journey for a fresh user, forms and create-read-update-delete flows wired to your backend, the deployed build rendering instead of a blank screen, and regression on known-good journeys after each Qodo change. It also catches SPA 404s on refresh, console errors, and broken API calls. It verifies each step, not just the final screen, and flags the exact point where the app breaks for a real user.
Yes. Because Qodo's agents already operate in your IDE and CI, they can fold Kane CLI into the same loop. Point the agent at the guide at testmuai.com/kane-cli/agents.md and it will install Kane CLI, run flows with the --agent flag for machine-readable output, parse the structured results, and patch the broken form or route before it reaches you. The agent generates and reviews with Qodo, then verifies the running UI with Kane CLI, in a single pass.
Yes. Authenticate with your TestMu AI credentials, pass --headless and --timeout, and gate the pipeline on the exit code: 0 on pass, 1 on fail, 2 on setup or auth errors, and 3 on timeout. Drop it in right after Qodo's diff review and unit-test stages so each deploy clears both gates, and a missing env var or broken redirect that the code checks never catch cannot slip into production.
The CLI is free to install and use. Local runs cost nothing; cloud runs on the TestMu AI grid bill against your TestMu AI plan. Start on the free tier and put a Qodo-built signup or form flow through a real browser end to end, no credit card required.
Teach your agent to test what Qodo builds
Qodo's agents work in your IDE and CI. Point them at the Kane CLI guide and they will install, authenticate, and verify the signup, forms, and checkout flows in a real browser on their own, right after they review and test the code.
Point your agent to: testmuai.com/kane-cli/agents.md