Test apps built with GitHub Copilot before the PR merges
GitHub Copilot ships working code fast, but a green build can still hide a form that never submits or a broken API call. Kane CLI drives the running app in a real browser and returns a clean pass or fail. Free to install.
or read the documentation
Why test apps built with GitHub Copilot
GitHub Copilot builds two ways: agent mode in the editor that creates features and self-corrects on failing tests, and the cloud agent that turns an issue into a pull request. Both produce a running app nobody has used yet.
That speed is why the app needs a second pair of eyes. Copilot writes plausible code, but plausible is not working. It is documented to invent npm packages, call APIs the wrong way, and slip logic errors past its own tests.
Kane CLI is that second pair of eyes. Describe the journey in plain English and it drives the running app in a real Chrome browser, hits the API behind the screen, and shows where it breaks. Agent-native, so Copilot verifies it.
What Kane CLI tests in your GitHub Copilot app
The feature the issue asked for, the API calls behind it, and the flow around it, all verified in a real browser.
The exact feature in the issue
Copilot turns an issue or prompt into code. Describe what the issue asked for, like add a project and see it on the dashboard, and Kane CLI confirms the feature works in the browser, not just that the diff applied.
API and data calls behind the screen
Copilot is documented to hallucinate packages and call APIs the wrong way. Kane CLI walks the flow that hits those endpoints, so a request pointed at a wrong or nonexistent route surfaces as a broken screen, not a silent failure in the logs.
Auth and protected routes
Sign up, log in, and confirm the protected pages, sessions, and redirects Copilot wired up hold for a new and a returning user, instead of erroring on the first edge case.
Forms and validation
Submit the forms Copilot generated, check the validation messages fire, and confirm the data lands and reads back. Catch the form that looks right in the diff but never submits.
Console errors and broken UI
Generated UI can compile and still throw at runtime, overflow on mobile, or leave an empty state that never resolves. Kane CLI runs in a real browser and flags the console errors and broken screens a passing build hides.
Regression on the next Copilot edit
The next issue or agent-mode edit can quietly break a working flow. Lock in known-good journeys and re-run them on every change so regressions get caught the moment they land.
Build up confidence before the PR merges
Start in your terminal
Validate on the cloud
Release with confidence
Built for the issue-to-PR loop
Kane CLI and KaneAI share the same automation engine and dashboard.
From a green PR check to a verified journey
Copilot writes the code and passes its own tests. Kane CLI proves the running app works for a user. Close the gap between a green PR check and a verified journey before anything merges.
Verify the agent PR, not just the diff
When the Copilot cloud agent turns an issue into a pull request, the diff reads fine far more often than the app runs fine. You or Copilot agent mode point Kane CLI at the preview deploy, and it drives the live feature in a real browser before you approve the merge.
Evidence you can share
Every run produces a persistent video, a step trace, and a replay link you can drop straight into the Copilot PR, a bug report, or a team message.
Verify what Copilot built in three steps
Install Kane CLI
Run npm install -g @testmuai/kane-cli and sign in with your TestMu AI account. Nothing to wire into your repo or Copilot setup.
Point it at the app, in the editor or on the PR
Run flows from your terminal against your dev server, or let Copilot agent mode run them as it works. In CI, point them at the preview deploy of the pull request the Copilot agent opened.
Describe the flow and verify
Write the journey in plain English, like sign up, build the feature from the issue, and confirm it appears. Kane CLI drives a real browser, verifies each step, and returns a pass or fail with evidence.
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
Install Kane CLI, then describe the journey in plain English, for example "open the app, sign up, create a project, and confirm it appears on the dashboard." Kane CLI drives the running app in a real Chrome browser, checks each step, and returns a clean pass or fail with video evidence. Run it from the terminal against your dev server or deployed URL, or let Copilot agent mode run it as part of its task before it opens the pull request.
Copilot writes plausible code fast, but plausible is not working. It is documented to hallucinate npm packages that do not exist, call APIs the wrong way, and slip subtle logic errors past the tests it wrote. The build goes green, the diff looks clean, and the running app still has a form that never submits, an empty state that never resolves, or a console error that only shows in the browser. Kane CLI verifies the actual app a user touches, so a passing PR check does not become a broken page in production.
The exact feature an issue or prompt asked Copilot to build, the end-to-end journey around it, auth and protected routes, forms and validation, and the API or data calls behind the screen, including ones pointed at a hallucinated or wrong endpoint. It also catches console errors, broken links, and regressions in flows that worked before the last edit. It checks each step, not just the final screen, and flags the exact point where the app breaks.
Yes. Kane CLI is built for AI coding agents, and Copilot agent mode already runs terminal commands and self-corrects on failing tests. Point it at the guide at testmuai.com/kane-cli/agents.md and it will install Kane CLI, run flows with the --agent flag, read the structured results, and fix the broken flow before it tags you for review. Copilot writes the code, Kane CLI verifies the running app, in the same loop.
Yes, and this is where it pays off most. When the Copilot cloud agent turns an issue into a pull request, the diff and unit tests do not prove the running app works. 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. Run your key user journeys against the preview deploy of every agent PR so a broken flow never gets merged.
The CLI is free to install and use. Local runs are free; cloud runs on the TestMu AI grid are billed against your TestMu AI plan. Start on the free tier and verify the app Copilot built end to end without a credit card.
Teach Copilot to test what it builds
Copilot agent mode already runs terminal commands and self-corrects on failing tests. Point it at the Kane CLI guide and it will install, authenticate, and verify the running app in a real browser before opening the pull request.
Point your agent to: testmuai.com/kane-cli/agents.md