All of QA, in one project.
Requirements, manual test passes, automation, API testing and reporting live in the same place. Coverage counts everything, nothing falls between tools, and when it is time to ship there is one answer instead of four half-answers to assemble by hand, written once and kept as it was. Axon AI works across all of it in plain English.
One Axon AI interface across all four disciplinesDescribe the outcome. Axon plans and carries out the connected work, then reports back with evidence.12 Aug
Tests9
Passed8
Failed1
Complete checkout with valid information timed out. Not repaired, raised as STORE-141.
App exploration
Point Axon at your app and it maps what it can reach.
Give Axon a publicly reachable URL and it explores in AxonQA Cloud. For a private or firewalled target, choose the local AxonQA Agent instead. It logs in, walks real user journeys, fills and submits forms, and captures the pages, elements and actions it reaches along the way. Anything it should not do without your say-so, like deleting records or completing a purchase, stays behind a toggle you control.
The result is a living map of your application plus the journeys worth testing, each captured with real, verified locators. From there you describe a test in plain language and Axon turns the map into grounded manual and automated tests.
Journeys found
2Click any page in the map to see exactly what Axon captured.
How it works
From a URL to tests, in three steps
Point Axon at your app
Give Axon a URL and any credentials it needs, then choose guided or autonomous. Apps behind MFA or SSO work too: complete the sign-in yourself and Axon carries on from there.
It explores and captures
Axon logs in, walks real journeys, fills and submits forms, and records the reachable pages, identified elements, and observed actions with verified locators where available. Risky actions stay behind toggles you control.
Describe a test, get both
Describe a test in plain language and Axon turns the map into grounded manual steps and runnable automation together.
Two ways to run it
Drive it yourself, or let Axon drive
Either mode captures the same journeys, APIs, elements, screenshots, and errors. Run both against the same target and combine the results.
Guided exploratory
You click through your app like a real user, and Axon learns it as you go. It records the journeys you walk and builds new ones from the pages you explore, capturing elements, locators, and screenshots along the way.
Autonomous exploration
Axon navigates for you, following links, filling forms, and collecting the same evidence automatically. Choose Quick, Smart, or Deep, then customize limits when you need to.
What Axon captures
Everything a real test needs, recorded per page
Screenshot
A full render of each reached page, exactly as Axon saw it.
Elements
Interactive elements Axon identifies, counted and catalogued.
Actions
The clicks, inputs, and navigations that move through the app.
Forms and rules
Fields, required inputs, and validation, so tests know what is valid.
Real locators
Uniqueness-checked selectors where available, matched to your real app.
API calls
The network requests each page makes behind the scenes.
Performance
Load and response timing captured for reached pages.
Axon insights
What Axon noticed about the page and the tests worth writing.
Built for real-world apps
Real logins, every role, both screen sizes
Production apps sit behind real sign-ins and behave differently for every role and screen. Axon explores them the way your users actually reach them.
Multi-role exploration
Give Axon a login per role and it explores as each one in turn, so you know what an admin, a member, and a viewer can each see and do.
MFA & SSO sign-in
Apps behind MFA or SSO are fair game: Axon pauses at the prompt, you finish the login, and it takes the session from there.
Live hints during exploration
Steer an exploration while it runs: drop in a hint, point Axon at an area it missed, or unblock it, no restart needed.
Desktop & mobile web
Crawl the desktop view, the mobile web view, or both, and see how the same journeys hold up on each.
Describe a test
Say the test. Get exactly that test.
Once Axon has explored your app, describe any check in plain language and it builds that one test: not a pile of guesses, the test you asked for. Every step is tied to a page Axon visited and a control it captured, with the locator as it really exists in your markup.
And when Axon has not captured enough to build what you described, it tells you so, names the gap, and points you at exactly what to explore first. A test it cannot ground is a test it will not generate.
You describe it
“A user can add an item to the cart and see the total update”
Build itGenerated test
Add an item to the cart
- 1
Open the products page
found in your app - 2
Click “Add to cart” on the first product
found in your app[data-test="add-to-cart"] - 3
Verify the cart badge shows 1 item
found in your app
Every step is grounded
Steps come from what a crawl of your app actually captured: the real pages, the real controls, the locators as they exist in your markup. Nothing is invented.
It refuses to guess
If Axon has not captured enough to build the test you described, it says so and tells you exactly what to explore first, instead of shipping a test that cannot run.
Prove it immediately
Run the generated test once to watch it pass against your app, then save it to a project as a manual case and runnable automation together.
Test Creation
Create better tests faster.
Turn stories, requirements, recordings, and app discovery into structured test cases.
AI Test Generation
Turn Jira or Azure DevOps stories, documents, or plain-English requirements into structured test cases.
Test Recorder
Capture real user flows in the browser and convert them into tests with real application context.
Crawl Scenario
Describe a scenario and validate it against your app's discovered pages, elements, and journeys.
Bulk Import / Export
Import and export test cases with Excel or CSV, and round-trip your edits.
Test Plans
Organize tests into plans with lifecycle states, duplication, schedules, runs, and reports.
Manual Test Runs
Work a manual pass test by test, record each result as you go, and keep a shared record of who checked what.
Where requirements come from
Import them, or write them right here.
Requirements do not have to live in a tracker. Import epics and user stories from Jira or Azure DevOps, or create and author them directly inside AxonQA. Either way they become the grounding for AI test generation, so every generated case traces back to a real requirement.
- Import epics and user stories from Jira or Azure DevOps in a few clicks.
- Or author epics and stories directly in AxonQA, with no tracker required.
- Both paths feed the same grounding, so generation stays anchored to what you actually need.
As a customer, I can sign in so that I can access my account.
- Guest can check out without an account
- Expired promo code is rejected
- Tax shows before the confirm step
Order total shows tax before the customer confirms.
Manual test runs
Not everything gets automated. Run the rest here.
Exploratory checks, anything needing a human eye, and the cases you have not automated yet still need working through. AxonQA gives you a proper manual runner: one case at a time, the expected result in front of you, pass or fail recorded as you go, and the run moves you straight to the next one.
- Work a plan test by test without losing your place, with progress saved as you go.
- Every result is attributed and timestamped, so you know who checked what and when.
- Manual and automated results land in the same run, so coverage and reports count both.
- A failure here raises a bug the same way an automated one does, recording and all.
Test Automation
Generate and run automation your team can maintain.
Create frameworks, link tests, self-heal locators, and monitor automation health.
Reliable automation is never generated from a sentence alone. AxonQA combines your requirements and test steps, browser recordings, app discovery, real locators from your application, a maintainable framework structure, and validation runs, so what it produces actually works and keeps working.
Automation Frameworks
Maintainable, page-object automation projects your team owns and extends.
Cross-Browser Execution
Run tests across Chrome, Firefox, and WebKit with per-browser results.
Self-Healing
A broken locator is replaced while the run is still going, and a heal can change how a test finds something but never what it expects.
Reuse Existing Tests
Copy a useful test and its dependencies from one framework into another.
Cloud or Local Execution
Run in AxonQA Cloud, or through a local agent for private networks.
App Exploration
Map your app's pages, elements, forms, and journeys automatically.
Raise Bugs From Failures
Turn a failed test into a Jira or Azure DevOps bug with the recording and steps attached, then track it in AxonQA as its status changes in your tracker.
Self-healing
Repair locator drift without rewriting the test.
Most self-healing quietly makes red things green, which is how a real fault ships. AxonQA escalates: the cheapest and most certain checks run first, and AI reasoning is a last resort rather than a first reflex, so healing stays fast and predictable.
AxonQA can repair a locator that moved or was renamed, and it does it while the suite is still running rather than leaving you a queue afterwards. If the expected behaviour itself does not match, the assertion stays red with its evidence for review. A heal can change how a test finds something, never what it expects to see.
Same run, two very different causes.
The app changed, the test did not need to. Fixed during the run, and reversible.
The expected total did not match. Left red with evidence for review.
Cheap, certain checks run before anything expensive, and no fix ever rewrites what your test expects.
API Testing
Test APIs alongside your product workflows.
REST, GraphQL, SOAP, and WebSockets, with collections, chained flows, environments, contracts, mocks, and webhooks.
API Flows & Collections
Build, organize, chain, and run API requests as reusable collections.
GraphQL, SOAP & WebSockets
Test REST, GraphQL, and SOAP services, import operations from a WSDL, and run live WebSocket sessions.
Environments & Datasets
Parameterize requests across environments, tokens, and test data.
Mock Servers
Stub services for isolated, reliable testing.
Contract & Schema Testing
Validate responses against expected contracts and schemas.
Webhooks Inbox
Capture inbound webhooks and assert on payloads, headers, and timing.
Private APIs & mTLS
Client certificates, custom CA bundles, and a local agent for APIs that never leave your network.
Production Safeguards
Mark an environment as production and no request runs against it without an explicit confirmation.
Code Export
Copy any request as ready-to-use code in ten languages.
Insights & Operations
Understand quality, risk, and release readiness.
Coverage, schedules, alerts, reports, visual changes, and recurring failures.
Run Analysis
Video, screenshots, step timelines, logs, and per-browser results for every run.
Visual Regression
Compare baseline, current, and diff screenshots step by step.
Dashboards
AI-powered global and project dashboards that explain quality status.
Coverage Tracking
Track manual and automation coverage by project, story, and target.
Scheduling
Recurring runs and recurring reports, with a calendar view.
Alerts & Notifications
Get alerted in Slack, Microsoft Teams, email, or in-app when runs fail, tests regress, coverage drops, visual changes appear, or a bug is filed.
Stakeholder Reports
Scheduled, shareable reports and a report library.
Automation Health
Flaky tests, healing trends, framework health, and run stability.
Failure Clustering
The same failure across many runs collapses into one unique error, with how often it happens, when it started, and whether it is getting worse.
Incident Tracking
Repeated alerts become incidents with a severity, a start, and a resolution, so a recurring failure is owned rather than re-notified.
Quality insight
See coverage, gaps, and trends at a glance.
Every run feeds the same picture: how your tests are distributed, where coverage is thin, and which way quality is trending. Dashboards read your real data and explain what it means, so you walk into a release review knowing exactly where you stand.
- Coverage by project, story, and target, with manual and automation tracked side by side.
- Trends over time, so a dip shows up long before it reaches your users.
- Requirement drift detection, so coverage stays aligned as your stories change.
- Reports you can schedule and share with the people who need them.
And the assessment at the end is written once, never rewritten. A live dashboard recalculates whenever a test runs, so it answers whether you are ready now. Only a frozen record answers what you believed on the day you shipped, which is the question asked in the incident review.
Gift card codes can be applied at checkout.
Free shipping over $50 $35.
Guests must create an account to check out.
Requirement drift
Stay in sync with your tracker.
AxonQA watches the tracker you connected. The moment a work item you imported changes, it checks whether the acceptance criteria moved, and if they did it shows you exactly what is different: added, changed, and removed. From that prompt you review the difference and, in one click, generate suggested test cases for just the new or changed criteria. Requirements can move without your coverage quietly falling behind.
- See precisely what changed in a work item, with added, changed, and removed acceptance criteria side by side.
- Generate suggested test cases for only the new or changed criteria, in a single click.
- It never edits your test suite on its own, so you stay in control of every change.
- Works in near real time, with a daily check as a safety net so nothing slips through.
Axon AI
Most QA assistants stop at the test. Axon does not.
Ask Axon AI for an outcome in plain English and it works across the same platform you do. It can create the workspace, understand the app, organise tests, build API flows, run and monitor checks, investigate failures, update your tracker, and explain the latest release-readiness assessment. It shows the work as a checklist, asks when something is unclear, and stops for approval before destructive work.
It also stops in the right place: Axon reads the readiness assessment, but cannot change the conditions a release is judged against or accept a risk on your behalf.
Run the Checkout test on Chrome and Firefox and tell me when it is done.
Done. Chrome passed 11 of 11. Firefox passed 10 of 11, and one step self-healed after a button moved. Nothing looks broken from the dev changes. Want the report?
- Anyone can drive Axon from a sentence. A product owner can ask for a run in plain English, and it acts across creation, automation, API, and insight.
- It breaks your request into a checklist of tasks, works through them in order, and reports back in the same chat when each one is done.
- It keeps watching after you move on, tells you when runs finish, and asks a clarifying question instead of guessing when something is unclear.
“Run the smoke tests on Chrome and Firefox.”
Run tests in plain English
Ask for a run by description or by tag, on the browsers you choose, and Axon starts it in the cloud.
“Start the full regression, I will check in later.”
Reports back when runs finish
Axon keeps watching after you move on and reports results in the same chat, with a notification even while you are away.
“Run smoke, and if it passes run regression.”
Conditional run chains
Chain runs on the outcome of the previous one, so a green smoke suite can trigger the bigger job automatically.
“Rerun just the failures from last night.”
Rerun only what failed
No need to repeat the whole suite; it scopes the rerun to the tests that failed.
“What healed in last night's run, and why?”
See what it repaired
Repairs land while the suite is still running. Each one is on the record with its evidence, so a fix that happened overnight is something you review rather than something you discover.
“Point the login test at the new email field.”
Framework edits by chat
Axon finds the right file in your automation framework, makes the change, and shows you exactly what it edited.
“Explore the billing pages and draft tests for them.”
Crawl and generate
It can explore your app, map what it finds, and generate test cases grounded in real pages and elements.
“Run the payments API flow against staging.”
API testing by chat
Axon creates API requests, runs flows and collections, checks the responses, and reports what changed.
“Import PROJ-142 and comment on it when the run passes.”
Requirements in, updates out
It imports stories from Jira and Azure DevOps, writes comments, and moves issues through their transitions.
“Raise a bug for the failed checkout test.”
Raise bugs from failures
Axon drafts the ticket, attaches the recording, and files it in Jira or Azure DevOps once you confirm, into the sprint you choose.
“Import the Payments suite from TestRail.”
Import from your test tools
Bring test cases in from TestRail, Azure DevOps, or Zephyr Scale, filed under the epic or story you name.
“What is this dashboard telling me?”
Explain this page
Axon reads the page you are on and explains it using its real data, and offers guided interactive tours of the product.
Safety by design
Asks instead of guessing
When a request is ambiguous, Axon asks a clarifying question rather than acting on an assumption.
Confirmation for destructive actions
Destructive and selected high-impact actions require your explicit confirmation before they run.
Work stays traceable
The conversation shows Axon's actions and outcomes, and writes are recorded in the audit trail.
Project Brain
AI that knows your product, not just testing.
Project Brain is a per-project knowledge base of your documents, screenshots, and imported stories. When AxonQA generates tests, it draws on this material, so the output reflects your real flows, rules, and terminology.
- Documents, screenshots, and imported stories, organized per project.
- Grounds AI test generation in your actual product context.
- Secrets and personal data are scrubbed from content before any AI call, and your data is never used to train models.
Every tool call recorded in the audit log
MCP Server
Bring your own AI agent.
The AxonQA MCP server lets Claude, VS Code, and other MCP-compatible assistants drive AxonQA directly: import a ticket, generate tests, run them, and fetch the results, all without leaving your agent.
- Access is controlled with API keys you create and revoke.
- Every tool call is captured in a full audit log.
Integrations
Connected to the tools you already use
Trackers, chat, CI, device clouds, and downstream systems, all first-class.
Jira
Connect with OAuth, import stories and epics, keep them continuously in sync, and file bugs straight from failed runs.
Azure DevOps
Connect with a personal access token, import work items, and keep your projects in sync.
Slack
Route alerts and run results to the channels your team already watches.
Microsoft Teams
Send alerts and run notifications to your Teams channels.
Email alerts
Alert rules and scheduled reports delivered to any inbox.
Signed webhooks
Outbound webhooks signed with HMAC, so downstream systems can verify every event they receive.
TestRail export
Export test cases to TestRail in a format it understands, ready to import.
BrowserStack
Execute runs on BrowserStack browsers directly from AxonQA.
Works with your CI
Ready-made templates for GitHub Actions, GitLab CI, Jenkins, and CircleCI trigger an AxonQA cloud run and gate your pipeline on the verdict. Your test code never leaves AxonQA.
More on the way
We are steadily adding integrations across trackers, chat, and CI. Tell us what your team relies on and it helps us prioritize what comes next.
See the whole platform on your own app.
Create a project, connect your tracker, and generate your first tests in minutes.