Test the apps you build with Codex before the PR merges
OpenAI Codex plans, edits, and opens a PR, but green unit tests do not prove the running app works. Kane CLI drives the live app in a real browser and returns a pass or fail in plain English. Free to install.
or read the documentation
Why test apps built with Codex
Codex is OpenAI's coding agent in your terminal, editor, the Codex app, and cloud sandboxes. It plans a change, edits across files, runs your tests, and opens a PR. Speed is the point, and why the running app needs a check.
The gap is verification. Green unit tests do not prove the running UI works. A change can pass CI and still ship a dead button, a form posting to the wrong route, or a console error that fires only in a real browser.
Kane CLI closes that gap. Describe the journey in plain English and it drives the running app in a real Chrome browser, no selectors. Point Codex at testmuai.com/kane-cli/agents.md so it runs the flow with --agent and fixes them.
What Kane CLI tests in your Codex app
The running journey Codex just touched, verified in a real browser before the diff merges.
The feature Codex just built
Codex plans, edits across files, and opens a PR. Kane CLI drives the new flow end to end in a real browser, so you catch the button wired wrong before the diff merges, not after.
Unit tests pass, but does the app work
Green tests and a clean review do not prove the running UI works. Kane CLI clicks the actual journey a user takes and confirms the app does what the passing tests claim.
Auth, sessions, and protected routes
Sign up, log in, and verify that sessions hold and protected pages gate correctly. Catch the auth edge case that compiles fine but fails for the second user on the running app.
The core action, end to end
Walk the primary flow Codex implemented, from input to result, and confirm each step lands, so a path that looks complete in the diff actually completes for a real user.
Dead buttons and console errors
Surface the click handler that never fired, the link to a route that does not exist, the missing asset, and the console error that only shows in a real browser, not in unit tests.
Regression on the next Codex task
Codex refactors and moves to the next task fast. Lock in the journeys that work and re-run them on every Codex change, so a refactor never quietly breaks a flow that shipped yesterday.
Build up confidence before the PR merges
Start in your terminal
Validate on the cloud
Release with confidence
Built for the plan-edit-verify loop
Kane CLI and KaneAI share the same automation engine and dashboard.
The browser proof Codex's test run misses
Codex already plans, edits, and runs your unit tests in one loop. Kane CLI adds the missing step: it drives the running app in a real browser and proves the journey works before Codex opens the PR.
Codex verifies its own work in the browser
Codex runs commands and reads results natively. Pointed at the Kane CLI guide, it runs the flow it just built with the --agent flag, reads the pass or fail, and fixes the break itself, so the diff you review already passed in a real browser.
Evidence on every pull request
Every run produces a persistent video, a step trace, and a replay link Codex can attach to the PR, so reviewers see the journey pass instead of trusting a green checkmark on faith.
Test your Codex app 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 the project Codex generated, nothing for Codex to set up.
Point Codex at the guide
Add the Kane CLI guide to Codex so it runs flows with the --agent flag against the running app after it edits, or run flows yourself from the terminal against your local or deployed URL.
Describe the flow and verify
Write the journey in plain English. Kane CLI drives a real browser, verifies each step, and returns a pass or fail with evidence before Codex opens the pull request.
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 Codex built in a real Chrome browser, checks each step, and returns a pass or fail with video evidence. Since Codex runs in your terminal, editor, or a cloud sandbox, you can run Kane CLI yourself or let Codex run it before it opens the pull request.
Codex plans a change, edits across many files, runs your unit tests, and opens a PR faster than anyone can review the diff. But green unit tests and a clean review do not prove the running app works. A Codex change can pass CI and still ship a button that does nothing, a form that posts to the wrong route, a loading state that never resolves, or a console error that only fires in a real browser. Codex writes code faster than a human can read it, so the running app needs a check that keeps pace. Kane CLI drives the real app in a browser so the PR Codex opens reflects what actually works.
The exact journey Codex just touched: the new feature end to end, sign-up and login, protected routes, the core action a real user takes, navigation between pages, and the absence of broken links, dead buttons, or console errors. It also re-runs your known-good flows so a Codex refactor or its next task does not silently regress something that worked. It checks each step, not just the final screen, and flags the precise point where the running app breaks.
Yes, and that is the point. Codex already runs commands and verifies results in its agent loop. Point it at the guide at testmuai.com/kane-cli/agents.md and it installs Kane CLI, runs the flow it just built with the --agent flag, reads the structured pass or fail, and fixes the break before it opens the PR. The same loop that runs your unit tests now proves the journey works in a real browser.
Yes. When Codex pushes a branch or opens a PR from its cloud sandbox, 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, 3 on timeout. Run your key journeys on every Codex pull request so a change that passed unit tests but broke a real flow never merges.
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 your Codex app end to end without a credit card.
Teach Codex to test what it builds
Codex already runs commands and verifies results. Point it at the Kane CLI guide and it installs, authenticates, and runs the flow it just built in a real browser before it opens the PR.
Point your agent to: testmuai.com/kane-cli/agents.md