TestMu AI’s Kane CLI Can Now Design Tests Directly From PRDs and Track What Each Test Proves
The company has launched the Assurance Lifecycle, a new collection of commands that can take product requirement documents and specifications, extract the requirements they contain, design runnable tests around them, execute those tests and report exactly which requirements were verified.
The system also keeps a permanent relationship between a requirement and the test designed to verify it.
That means teams can move beyond simply asking whether a test passed and instead ask a more important question:
What requirement did the test actually prove?
TestMu AI announced the Assurance Lifecycle for Kane CLI on September 15, with the feature available in Kane CLI 0.6.1 and later.
What Is Kane CLI?
Kane CLI is TestMu AI's terminal-native browser automation tool.
The company originally launched it in April 2026 for developers and AI coding agents, including Claude Code, Codex CLI, Cursor and Gemini CLI.
Instead of requiring developers to manually define browser selectors, Kane CLI can work from plain-language intent.
A developer can describe a browser workflow, and the tool can execute it while producing a pass-or-fail result, step trace and screenshot.
Kane CLI can also export workflows into native Playwright code and run tests headlessly inside continuous integration pipelines.
The new Assurance Lifecycle extends that system beyond simply creating and replaying browser tests.
What Is the Assurance Lifecycle?
The Assurance Lifecycle is designed around the relationship between requirements, tests and evidence.
A traditional testing workflow might begin with a requirement document and eventually produce a collection of tests.
Over time, however, those tests can drift away from the original requirements.
A specification changes. A feature is modified. A test remains unchanged.
Eventually, the team may know that hundreds of tests are passing without being able to confidently determine which current product requirements are actually covered.
TestMu AI's new system is designed to maintain that relationship.
The workflow can be summarized as:
Requirements → Use cases → Acceptance criteria → Scenarios → Tests → Evidence → Coverage → Maintenance
Each stage is represented within Kane CLI.
How Kane CLI Turns a PRD Into Tests
The Assurance Lifecycle begins with the documents that define what the software is supposed to do.
These could include:
- Product requirement documents
- Technical specifications
- Policy pages
- Other requirement sources
Kane CLI can ingest these documents into a local, content-addressed store.
An AI agent then reads the material and proposes use cases while citing the source information it used.
Those proposals are not automatically treated as trusted requirements.
Teams can review, edit, approve or reject them before the process continues.
That review stage is an important part of the workflow because it keeps generated interpretations separate from requirements that humans have explicitly approved.
Step 1: Capture the Requirements
The first stage is context ingest.
The command snapshots requirement documents into a local .context/ store.
Because the information is content-addressed, changing a source document creates a new version rather than silently overwriting the previous one.
This gives the system a versioned foundation for the rest of the assurance process.
It also means teams can later determine which version of a requirement was used when a test was created.
Step 2: Extract Use Cases With AI
The next stage is context extract.
The KaneAI agent analyzes the ingested requirement material and proposes use cases.
Importantly, the documentation says the agent cites the exact lines it used when proposing those use cases.
The resulting information begins as derived rather than automatically trusted.
Teams can then review the proposals and promote the ones they accept to a trusted state.
This creates a human review boundary between what the AI inferred and what the development team has accepted.
Step 3: Design Tests From Requirements
After a use case has been reviewed, teams can use kane-cli design tests to turn it into acceptance criteria, scenarios and runnable tests.
The system uses a one-to-one relationship between scenarios and tests.
Each test is tagged with the acceptance criteria it is designed to verify.
This is the central idea behind the Assurance Lifecycle.
Instead of starting with:
"What test should we write?"
The process starts with:
"What does the product need to prove?"
The test is then created from that requirement.
Step 4: Review the Generated Test Design
The generated test design is also treated as derived information.
Teams can review the acceptance criteria, scenarios and tests before they become part of the trusted testing workflow.
According to TestMu AI's documentation, nothing generated by the agent is silently trusted.
This is particularly relevant when AI is involved in software testing.
A generated test can look reasonable while still missing an important condition.
The review stage provides an opportunity for engineers to catch those gaps before execution.
Step 5: Execute the Tests and Seal the Evidence
Once the test design is approved, Kane CLI can execute the tests.
The Assurance Lifecycle uses testmd run and testrun run for execution.
Each run produces an evidence pack.
This evidence is then used to determine what the test run actually proved.
The difference is subtle but important.
A normal test report might say:
100 tests passed.
The assurance system is intended to answer:
These specific requirements were verified by this evidence.
That creates a much more traceable testing record.
Coverage Becomes "Proven" Versus "Owed"
Another major feature is Kane CLI's coverage reporting.
The kane-cli cover command measures two dimensions:
- What the evidence proves
- What the current design still requires
TestMu AI describes missing coverage as a gap, rather than simply ignoring requirements that do not have corresponding tests.
This can make coverage reports more actionable.
For example, if a product has 100 acceptance criteria but tests only prove 85 of them, the system can identify the remaining 15 as coverage gaps.
The goal is therefore not just to produce a percentage.
It is to show what remains unverified.
Kane CLI Can Detect Stale Tests When Requirements Change
Software requirements rarely remain unchanged.
A product specification can be updated after development has already started.
That creates another problem for automated testing: some tests may still be based on older requirements.
The Assurance Lifecycle includes a maintain stage designed to address this.
When a source document changes, Kane CLI can reconcile the test suite against the new source.
Tests and extracted information associated with the previous version can be marked as stale until they are reviewed and verified again.
This is intended to prevent a test suite from quietly becoming outdated.
The Assurance Store Remains Local
The Assurance Lifecycle uses a local .context/ store inside the project.
TestMu AI's documentation says the store is append-only and keeps a replayable history.
Sources, use cases, designs and review decisions remain within the project rather than being stored as the authoritative record on a remote server.
The AI extraction and design steps use the KaneAI service through the user's login, but the assurance store itself remains on the developer's disk.
The company recommends keeping .context/ out of Git merges because the store is designed as a single-writer system.
Why This Matters for AI Coding Agents
AI coding agents are changing how software is produced.
Developers can ask an agent to implement a feature, modify an application or fix a bug and receive code much faster than traditional development workflows.
Testing can become the bottleneck.
The faster software changes, the harder it becomes for teams to manually maintain the relationship between specifications and automated tests.
That is the problem TestMu AI is targeting.
With the Assurance Lifecycle, an AI coding agent could potentially participate in a broader loop:
Read the requirement → build the feature → design requirement-based tests → execute them → produce evidence → identify missing coverage.
TestMu AI says the entire lifecycle can run headlessly in CI or from an AI agent.
Assurance vs Kane CLI Generate
The new system does not replace Kane CLI's existing test-generation capability.
Instead, TestMu AI positions the two workflows for different purposes.
kane-cli generate
This feature is designed for quickly generating test ideas from a plain-language description.
It can produce scenarios and test cases when a developer wants to explore coverage quickly.
Assurance Lifecycle
The Assurance Lifecycle begins with actual requirement documents.
Its purpose is to answer questions such as:
- Which requirements are covered?
- Which requirements remain unverified?
- Which test verifies a particular requirement?
- What evidence proves that requirement?
- Which tests became stale after the specification changed?
TestMu AI therefore describes Assurance as the workflow for teams that need auditable coverage rather than simply a collection of generated test cases.
What Makes the Approach Different?
The key distinction is traceability.
Many AI testing tools focus on generating test cases.
TestMu AI is adding a layer that connects the entire testing chain.
A requirement leads to a use case.
The use case leads to acceptance criteria.
Acceptance criteria lead to scenarios.
Scenarios lead to runnable tests.
The tests generate evidence.
The evidence determines what has been proven.
This structure gives teams a way to trace a test backward to the requirement it exists to verify.
Who Can Use Kane CLI Assurance?
The new capability is primarily aimed at software engineering and quality teams working with formal requirements.
It may be particularly relevant to:
- Product engineering teams
- Quality engineering teams
- Developers using AI coding agents
- Teams operating CI pipelines
- Organizations with detailed PRDs
- Software teams that need auditable test coverage
The system is especially suited to projects where knowing that a test passed is not enough.
Teams may also benefit when requirements change frequently and test suites need to remain synchronized with those changes.
Pricing and Availability
The Assurance Lifecycle is available in Kane CLI 0.6.1 and later.
Existing users can upgrade using npm or Homebrew.
TestMu AI says the context extract, design tests and maintenance reconciliation operations use the KaneAI agent and consume credits.
Review, coverage and local store operations are free because they run locally.
This makes the cost structure different from a conventional testing tool where every local test execution is necessarily tied to a cloud AI request.
What Developers Should Know Before Using It
The Assurance Lifecycle is not simply an automatic button that turns a PRD into perfect tests.
The workflow deliberately includes review stages.
AI-generated use cases, acceptance criteria and test designs begin as derived information and require human validation.
That is important because requirement documents can contain ambiguity, incomplete information or assumptions that an AI system may interpret incorrectly.
The tool's design therefore treats human review as part of the assurance process rather than as an optional afterthought.
Final Thoughts
TestMu AI's Assurance Lifecycle adds a different layer to the rapidly growing AI-powered software testing market.
Instead of focusing only on generating more tests, Kane CLI now attempts to connect requirements, test design, execution evidence and coverage into one traceable workflow.
The most interesting part is the permanent relationship between each test and the requirement it verifies.
When a specification changes, the system can identify affected information and mark outdated material for re-verification rather than allowing the test suite to silently drift.
For teams increasingly using AI coding agents, that could address an important problem: software can now be generated quickly, but proving that the resulting product still satisfies its requirements remains a separate challenge.
Kane CLI's Assurance Lifecycle is TestMu AI's attempt to connect those two sides.
The result is not simply another AI test generator. It is an attempt to turn software testing into a continuously traceable evidence system where teams can see what was required, what was tested, what was proven and what still needs verification.
Frequently Asked Questions
What is TestMu AI Assurance Lifecycle?
It is a new set of commands in Kane CLI that connects software requirements to test design, execution evidence, coverage measurement and test-suite maintenance.
What is Kane CLI?
Kane CLI is TestMu AI's terminal-based browser automation and testing tool designed for developers and AI coding agents.
