pdlc.statusShows which step a PDLC session has reached.
Try: “Where did we get to with the password reset feature?”
Check where a PDLC session is in the loop — inputs and examples →Test Maze gives your coding agent 55 Model Context Protocol (MCP) tools to plan features, keep test cases, record test runs against the exact git commit and get a deterministic pass/fail verdict — plus exploratory testing, coverage gap analysis, regression baselines and code-quality checks. You ask in plain English; your agent picks the tools.
A session is an optional tracker for one piece of work as it moves plan → write tests → code → verify → ship. Read where a session is and what it expects next.
pdlc.statusShows which step a PDLC session has reached.
Try: “Where did we get to with the password reset feature?”
Check where a PDLC session is in the loop — inputs and examples →pdlc.listLists the PDLC sessions in the connected workspace, most recently updated first, up to 50.
Try: “What work sessions do I have open in Test Maze?”
List PDLC sessions — inputs and examples →A test case is one check of your app: steps to follow and the result you expect. Create, find, update, archive, delete or waive them here.
case.listLists the test cases in the connected workspace, 20 per page, sorted by caseId.
Try: “What test cases do we already have for login?”
List test cases — inputs and examples →testcase.getReads one test case in full: title, description, pre-condition, steps (in order), expected result, post-condition, priority, status, acceptance-criterion label, waiver details (isWaived, waivedReason, waivedBy, waivedAt), severity, automationStatus, the store…
Try: “Show me the steps of the checkout test”
Get one test case — inputs and examples →case.createCreates one test case in the connected workspace: a written check of the app with steps to follow and the result to expect, for example "Guest can check out without an account".
Try: “Write a test case for signing up with an email address”
Create a test case — inputs and examples →case.updateChanges an existing test case, for example to fill in the steps and expected result of a draft, or to archive it with status INACTIVE.
Try: “Fill in the missing steps for the checkout test”
Update a test case — inputs and examples →case.create_batchCreates up to 200 test cases in one call and can file them all under a feature or user story.
Try: “Write test cases for every acceptance criterion of the checkout feature”
Create several test cases at once — inputs and examples →case.waive_acMarks an acceptance-criterion test case as waived: a deliberate, recorded decision that this promise does not have to be proven for now (for example "Apple Pay is out of scope for the beta").
Try: “We are skipping the Apple Pay criterion for the beta, mark it as waived”
Waive an acceptance criterion — inputs and examples →case.deletePermanently deletes one test case.
Try: “Delete that duplicate login test you just made”
Delete a test case — inputs and examples →case.delete_batchPermanently deletes up to 200 test cases in one call.
Try: “Clean up all the duplicate test cases you created”
Delete several test cases — inputs and examples →case.unwaive_acUndoes case.waive_ac: the acceptance criterion (a testable promise the feature makes) must be proven again.
Try: “Apple Pay is back in scope, remove the waiver”
Remove a waiver — inputs and examples →A test run records the results of running a set of test cases against a specific version of your code (git commit and branch). Create runs, record pass/fail per case and read them back.
testrun.listLists the test runs in the connected workspace, newest first, 20 per page, optionally filtered by name.
Try: “Did the last test run pass?”
List test runs — inputs and examples →testrun.getReads the summary of one test run in the connected workspace: { id, uri, name, buildVersion, description, startDate, endDate, status, gitSha, branch, workingTreeClean, releaseId, frozen, numberOfTestCases }.
Try: “How many tests were in yesterday's run?”
Get one test run — inputs and examples →testrun.record_resultsSaves the outcome of each test case onto a test run that already exists: Pass, Fail or Not Executed, plus optional details (what actually happened, the error text, a note, a screenshot).
Try: “I ran the checkout tests: 4 passed, the coupon one failed. Record that”
Record test results on a run — inputs and examples →testrun.createCreates a test run: one execution of a chosen set of test cases, where each case gets a result (Pass, Fail or Not Executed).
Try: “Run the checkout tests against my current commit and tell me if it is ready to ship”
Create a test run — inputs and examples →Your workspace describes one product: its vision, the problem it solves and who it's for. Check which workspace this connection is using, and read or update that description.
project.whoamiTells you which Test Maze workspace this connection reads from and writes to, which user your changes are credited to, and which access token was used.
Try: “Which Test Maze workspace am I connected to?”
Check which workspace this connection uses — inputs and examples →product.getReads the product description stored on the connected workspace.
Try: “What does Test Maze know about my app so far?”
Get the product details for this workspace — inputs and examples →product.updateEdits the product description stored on the connected workspace (the "product" is the workspace itself).
Try: “Save this product vision and target audience to Test Maze”
Update the product details for this workspace — inputs and examples →Describe what you're building: features, smaller sub-features and user stories ("as a …, I want …, so that …"). Each is stored as a test suite that holds the test cases proving it works.
feature.listLists the features, sub-features, user stories and regression suites in the connected workspace.
Try: “What features do we already have in Test Maze?”
List features and user stories — inputs and examples →feature.createCreates a feature: a named capability of the product, such as "Checkout" or "Password reset".
Try: “Add a feature for guest checkout”
Create a feature — inputs and examples →userstory.createCreates a user story: one specific thing a user needs from a feature, written in three parts.
Try: “Write a user story for paying with a saved card”
Create a user story under a feature — inputs and examples →feature.set_lifecycleRecords where a feature, sub-feature or user story is in its life.
Try: “Checkout is built, mark it as being verified”
Move a feature or story to a new stage — inputs and examples →feature.set_releaseLinks a feature (or user story) to the release, sprint or milestone it is planned to ship in, or removes that link.
Try: “Put guest checkout into the June release”
Plan a feature into a release — inputs and examples →A test plan is a named bundle of test cases you run together, like a smoke test before every deploy or a full regression pass before a release.
testplan.listLists the test plans in the connected workspace, 20 per page, optionally filtered by name.
Try: “Do we already have a smoke test plan?”
List test plans — inputs and examples →testplan.createCreates a test plan: a named, reusable bundle of existing test cases you want to run together (for example a "Checkout smoke" plan with the five most important checkout cases).
Try: “Group the login and checkout tests into a smoke test plan”
Create a test plan — inputs and examples →Group work into releases, sprints or milestones, then mark them shipped or cancelled.
release.listLists the releases, sprints and milestones in the connected workspace, newest first.
Try: “What releases do we have planned?”
List releases, sprints and milestones — inputs and examples →release.createCreates a time-boxed bucket to plan work into.
Try: “Create a v2.0 release targeting the end of June”
Create a release, sprint or milestone — inputs and examples →release.shipRecords that a release, sprint or milestone is done and out: sets status to "shipped" and stamps shippedAt with the current time.
Try: “We just shipped v2.0, record it”
Mark a release as shipped — inputs and examples →release.cancelMarks a release, sprint or milestone as cancelled, for when the plan is dropped and it will not ship.
Try: “Cancel the v2.1 release, we are not doing it”
Cancel a release — inputs and examples →Track whether the product and each feature actually succeed: product KPIs (e.g. weekly active users), per-feature metrics (e.g. checkout conversion) and the measurements recorded against them.
productkpi.listLists the product KPIs in the connected workspace, newest first.
Try: “What KPIs are we tracking for the product?”
List product KPIs — inputs and examples →featuremetric.listLists the success metrics attached to features in the connected workspace, newest first.
Try: “How are we measuring whether checkout is working?”
List per-feature success metrics — inputs and examples →productkpi.createDefines a new product KPI (key performance indicator): one number that shows whether the whole product is succeeding.
Try: “Track weekly active users with a goal of 5,000”
Create a product KPI — inputs and examples →featuremetric.createDefines how you will tell whether one feature is working for users.
Try: “How will we know guest checkout worked? Track conversion rate from 42% to 55%”
Create a success metric for a feature — inputs and examples →metric.observeRecords one measured value for a product KPI or a feature metric at a point in time, building up its history.
Try: “Log 4,200 weekly active users for this week”
Record a metric value — inputs and examples →Screenshots, PRDs and other files attached to test cases, runs and features.
media.listLists files stored in the connected workspace, such as screenshots taken during test runs, newest first.
Try: “Show me the screenshots from the last test run”
List uploaded files and screenshots — inputs and examples →media.upload_urlUploads a file you already have, such as a screenshot of a bug, a short screen recording or a spec document, and optionally attaches it to a test case, test run or feature.
Try: “Attach this screenshot of the broken checkout page to the checkout test”
Upload a file (base64) and attach it to a test — inputs and examples →Start here. Each workflow tool kicks off a multi-step job (set up the product, plan a feature, turn a plan into tests, grade a run) and tells your agent exactly what to do next.
project.initializeStep 1 of the Test Maze loop: project.initialize → feature.implement → feature.verify → testrun.create (or testrun.record_results) → pdlc.verify.
Try: “Set up Test Maze for this project”
Start the build-and-verify loop for this repo — inputs and examples →feature.implementStep 2 of the loop (project.initialize → feature.implement → feature.verify → testrun.create → pdlc.verify).
Try: “Let's build a password reset flow, plan it and write the tests first”
Start a new feature and plan its tests — inputs and examples →feature.verifyStep 3 of the loop (project.initialize → feature.implement → feature.verify → testrun.create → pdlc.verify).
Try: “Write the full test steps for the password reset stories”
Write out the full test cases for a feature — inputs and examples →pdlc.verifyFinal step of the loop (project.initialize → feature.implement → feature.verify → testrun.create / testrun.record_results → pdlc.verify).
Try: “Did the last test run pass? What should I fix first?”
Grade a test run and say what to fix next — inputs and examples →Find what a feature is not tested for yet: happy path, edge cases, errors, permissions, accessibility, performance, browsers and unusual data.
coverage.gap_for_featureChecks which kinds of testing a feature or user story has no test cases for yet.
Try: “What kinds of tests is the checkout feature missing?”
Find what a feature's tests are missing — inputs and examples →Lock in a fully passing run as the "must stay green" baseline. From then on, any case from it that breaks fails the verdict, so fixed things stay fixed.
regression.freeze_runFreezes a test run as a regression baseline: a set of tests that must keep passing from now on.
Try: “Everything passes now, lock this in so we notice if it breaks later”
Lock in a passing test run as a regression baseline — inputs and examples →regression.unfreeze_runUnfreezes a test run so its cases no longer have to keep passing.
Try: “We removed the old checkout, stop requiring its tests to pass”
Retire a regression baseline — inputs and examples →regression.list_frozenLists every frozen test run (regression baseline) in the connected workspace, most recently frozen first.
Try: “Which tests are locked in as must-stay-green?”
List regression baselines — inputs and examples →Label what your agent is doing so it shows up clearly on the Agent Sessions page.
pdlc.recordPromptSaves the message the user just typed to you onto the Agent Sessions page in Test Maze.
Try: “Keep a log of what I ask you in Test Maze”
Record what the user asked for — inputs and examples →Let your agent click through your app in its own browser (for example with Playwright MCP) while Test Maze keeps a verified record, suggests what to try next and turns the journey into test cases. Test Maze never opens a browser itself.
exploration.startStarts an exploration session: a recorded walk through a running web app to discover its pages, links and forms, which can later become test cases.
Try: “Explore my app at http://localhost:3000 and find all the pages”
Start exploring a web app — inputs and examples →exploration.observeThe core of the exploration loop.
Try: “Keep exploring the app and tell me what pages you find”
Report the page your browser sees and get next steps — inputs and examples →exploration.finishCloses an exploration session so no more observations can be added.
Try: “That's enough exploring, wrap it up”
Finish an exploration session — inputs and examples →exploration.to_casesTurns what an exploration session recorded into draft test cases.
Try: “Turn that exploration into test cases”
Draft test cases from an exploration — inputs and examples →exploration.listLists recent exploration sessions in the connected workspace, from every user, most recently updated first.
Try: “What explorations have we run so far?”
List exploration sessions — inputs and examples →exploration.getReads one exploration session from the connected workspace in full.
Try: “Show me everything the last exploration found”
Show an exploration session in full — inputs and examples →Two helpers for the code your agent writes: a code-smell check (fixed rules, same code gives the same result) and design advice that ranks proven design patterns and refactorings against your problem. Backed by a built-in knowledge base.
quality.smell_checkScans a file, function or diff for code smells: warning signs that code will be hard to change, such as a very long function, a function with many parameters, or the same block copy-pasted.
Try: “Check the file I just wrote for code smells”
Check code for smells — inputs and examples →architecture.adviseSuggests ways to structure code for a design problem you describe in plain words, such as "three payment providers with different APIs", "undo for editor actions" or "one class that changes for every feature".
Try: “How should I structure support for Stripe, PayPal and Razorpay without a giant if/else?”
Suggest a design for a code structure problem — inputs and examples →kb.searchSearches the built-in code-quality guide (a knowledge base of design patterns, code smells and refactorings) by a symptom you notice or by a name, e.g.
Try: “What is it called when a function takes way too many arguments?”
Search the code-quality guide — inputs and examples →kb.getReads one entry of the code-quality guide in full: a design pattern, a code smell or a refactoring, with what it is, when to use it, how it looks, an example, trade-offs and step-by-step mechanics.
Try: “Explain the strategy pattern with an example”
Read a code-quality guide entry — inputs and examples →Records an agent can open directly by address, like opening a file. Tool results link to them.
testmaze://product/{spaceId}testmaze://feature/{spaceId}/{suiteId}testmaze://userstory/{spaceId}/{suiteId}testmaze://case/{spaceId}/{caseId}testmaze://testplan/{spaceId}/{planId}testmaze://testrun/{spaceId}/{runId}testmaze://release/{spaceId}/{releaseId}testmaze://media/{spaceId}/{mediaId}testmaze://productkpi/{spaceId}/{kpiId}testmaze://featuremetric/{spaceId}/{metricId}testmaze://metric-observations/{spaceId}/{metricType}/{ownerId}testmaze://kb/{spaceId}/{kind}/{slug}testmaze://exploration/{spaceId}/{id}Step-by-step instructions stored in Test Maze that guide your agent through a job. In Claude Code they appear as slash commands such as /mcp__tm__feature-spec.
code-smell-reviewarchitecture-reviewexplore-featureexploration-to-casesproduct-initfeature-specac-to-testcasefind-coverage-gapsThe Model Context Protocol (MCP) is an open standard that lets AI coding agents call external tools. Each Test Maze tool is a named action, such as case.create or pdlc.verify, that your agent can call with structured inputs and get structured results back.
No. You describe what you want in plain English, for example "write test cases for the password reset flow", and your coding agent picks the tools and fills in their inputs.
Any MCP client. Setup instructions in the app cover Claude Code, Cursor, Cline, Gemini CLI and Codex CLI.
Create an MCP token in your Test Maze workspace, run "npx -y @testmaze/mcp init <token>" in your project folder, then register the server with your agent, for example "claude mcp add tm --scope project -- npx -y @testmaze/mcp".
No. Test Maze never clones or scans your repository. It only receives what your agent sends in a tool call: test cases, run results and git identifiers, plus a code snippet when you explicitly ask for a code-quality check.
No. pdlc.verify computes the verdict with fixed rules over the recorded results, so the same results always give the same verdict. AI may only add an optional hint about what to fix.