Test the apps you build with Trae before real users log in
Trae's agent builds your web app from a prompt, but it reasons over code and cannot see the rendered UI. Point Kane CLI at the running app and verify the flow in a real browser. Free to install.
or read the documentation
Why test apps built with Trae
Trae is an AI IDE whose autonomous agent builds and edits a full web app from your prompts. That speed is the point, but the agent reasons over source code, so it ships fast without ever seeing the page a user lands on.
That is where Trae apps break. A button wired to the wrong route, a form that fails to save, a deployed build that goes blank while the preview looked fine. The agent reports done because the code compiled, not because the flow ran.
Kane CLI is the second pair of eyes. Describe the journey in plain English and it drives the running app in a real Chrome browser, signs up fresh, and checks each step. Trae can run Kane via the --agent flag and fix the break itself.
What Kane CLI tests in your Trae app
Signup, forms, routes, and the deployed build, verified for a real user.
Signup and auth for a fresh user
Kane CLI registers a brand new account in the Trae build, follows the post-login redirect, and confirms the session survives a reload. The agent often scaffolds auth that passes in its own context but locks out a real second user.
Forms and CRUD that actually save
It fills the forms Trae wired to your backend, trips the validation, submits, and reloads to confirm the row persists and reads back. That surfaces the insert the agent believes works because the handler compiled.
Deployed build, not just preview
Aim Kane CLI at the URL you actually shipped to catch the blank screen from a missing env var, the refresh 404 from client-side routing, and chunks that vanish after a redeploy. The preview Trae rendered is not the build users hit.
Routes and navigation wired right
It clicks through the nav Trae generated and confirms each link lands where the label promises, with no redirect dead ends. A button pointed at the wrong route still lets the agent call the build done.
Evidence the agent can read
Each run hands back a structured pass or fail with a step trace, video, and replay link, in a shape Trae's agent can parse and act on to repair the exact failing step.
Regression after every prompt
Every new prompt has Trae's agent rewriting components, and the next change can silently break a flow that worked an hour ago. Save the journeys that pass and replay them after each generation.
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.
Close the loop Trae leaves open
Trae's agent takes you from prompt to running app, then stops at code that compiles. Kane CLI is the verify half of that loop, proving the generated auth, forms, and routes actually work for a user.
Check the rendered app, not the agent's mental model
Trae reasons about source it cannot see running. Kane CLI opens the live build in a real browser and walks the flow, so the result reflects what loads on screen, not what the agent assumed would.
Feed the fix straight back to Trae
Every run leaves a video, a step trace, and a replay link, ready to drop into a PR or hand to Trae's agent so it can pinpoint and patch the failing step.
Test your Trae app in three steps
Install Kane CLI
Run npm install -g @testmuai/kane-cli and sign in with your TestMu AI account. There is nothing to add to the project Trae built or its backend.
Point it at the build Trae shipped
Hand Kane CLI the local preview URL while you iterate, or your deployed domain before release. Run it yourself from the terminal, or let Trae's agent fire it with the --agent flag.
Describe the journey, get a verdict
Spell out the flow Trae generated in plain English, such as sign up, submit a form, confirm the record shows. Kane CLI walks it in a live browser and tells you the step that passed or the step that broke, with video and a replay link.
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
After Trae's agent finishes a build, install Kane CLI and write the journey in plain English, for example "open the running app, sign up as a new user, submit the form, and confirm the record shows on the dashboard." Kane CLI opens the app Trae generated in a real Chrome browser, walks the flow as a user would, and reports where it holds and where it breaks with video to back it up. Run it against the local preview while you iterate, or your deployed domain before you ship, or hand it to Trae's agent with the --agent flag.
Trae's autonomous agent ships features fast from a prompt, but it reasons over source code, not the rendered page. It cannot see that the login button is wired to the wrong route, that a form silently fails to save, or that the deployed build renders a blank screen while the local preview looks fine. The agent declares "done" based on code that compiles, not on a flow that works for a real user. Kane CLI runs the live app in a browser, as a real user, and verifies the flow before you ship.
The full signup and authentication journey for a new user, create-read-update-delete on the forms and tables Trae's agent generated, the deployed build rendering instead of a blank screen, and regression after every edit. It also catches SPA 404s on refresh, console errors, and broken API calls. Kane CLI checks each step, not just the final screen, and flags the exact point where the app breaks.
Yes. Trae's agent runs commands inside your project, so it can verify its own build. Point it at the guide at testmuai.com/kane-cli/agents.md and it will install Kane CLI, drive the flow with the --agent flag, read the structured pass or fail back into context, and repair the broken route or unsaved form before it hands the build to you. Prompt to build, run to verify, fix, all inside Trae.
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. Because Trae's agent reships components on every prompt, running your signup, form, and CRUD journeys on each deploy stops a regression it could not see from reaching production.
Yes, the CLI is free to install and run. Local runs against your Trae preview or deployed domain cost nothing; cloud runs on the TestMu AI grid are billed against your TestMu AI plan. Start on the free tier and verify a Trae build end to end without a credit card.
Teach Trae to test what it builds
Trae's agent can run commands in your project. Point it at the Kane CLI guide and it will install, authenticate, and verify the signup, form, and CRUD flows in a real browser on its own.
Point your agent to: testmuai.com/kane-cli/agents.md