Introduction
Arcus is a testing platform run by AI agents. Your test cases, test plans, test runs, and reports live in one place, and the agents write, automate, run, and maintain the test cases alongside you, for web, mobile, desktop, API, and Salesforce applications. Desktop means Windows applications, tested on your own Windows computer.
You give the agents context that already exists: a Jira story, a Linear issue, a Confluence page, a Figma design, a pull request, a recording, or the URL of your app. From that, they plan each sprint’s generation, explore the app to find what is untested, write the test cases, build the test plans, learn your application to turn manual steps into automated ones, fix broken locators during runs, analyze the results for recurring failures, and score release readiness. Runs execute on Testsigma Lab in the cloud or on your own machine through the Arcus Agent.
Developers can work from their own tools. Plugins for Claude Code, Cursor, GitHub Copilot, and Codex send each coding session to Arcus as context. The CLI lets a coding agent write, validate, and run test cases on your own machine. The MCP server lets an AI client read your projects and draft test cases into them.
What the agents do
Section titled “What the agents do”Each agent owns one part of the testing cycle. Most have no screen of their own. AI in Arcus lists where you see each one.
| Agent | What it does |
|---|---|
| Sprint Planner Agent | Builds the Generation Plan for a sprint when you click Generate, from the sprint’s stories and their linked context |
| Test Authoring Agent | Writes test cases from the context you attach, mapped to your modules |
| Explorer Agent | Crawls your app in a browser and maps its screens, so test cases follow paths that exist |
| Coverage Agent | Tracks coverage per module, flags gaps, and scores release readiness |
| Test Plan Agent | Builds test plans for generated test cases by reading your test case library |
| Copilot | Walks through a test case’s manual steps in your app and writes the automated steps, records steps you perform, and runs them |
| Healer Agent | Corrects element locators that fail during a run |
| Analyzer Agent | Explains why a step failed, and reads run results for recurring failures and risk signals |
| Bug Reporter Agent | Raises a failed run as a defect in your issue tracker, written up from the run |
How Arcus is organized
Section titled “How Arcus is organized”Arcus has 2 layers.
| Layer | Holds |
|---|---|
| Core test management | Test cases, step groups, datasets, test plans, test runs, reports |
| QI Home | Context, sprint and Adhoc sessions, test case review, coverage, release readiness |
QI Home is where the agents work. A test case behaves the same in the core layer whether an agent generated it or you created it manually, and everything the agents generate lands in the same library.

Where test cases come from
Section titled “Where test cases come from”Generation is the default route. There are 2 ways to start it, and everything after generation is identical for both.
| Adhoc | Sprints | |
|---|---|---|
| Generation starts when | You write a prompt, attach context, and click Send | You click Generate on a sprint synced from your project management tool |
| Context comes from | Sources you attach yourself | The stories linked to the sprint |
| Reach for it when | You are covering a feature outside a sprint cycle, or want to control exactly what the Test Authoring Agent reads | Your team works in sprints and you want coverage to start with the sprint |

Context sources are Jira, Azure DevOps, Linear, ClickUp, or OpenProject for stories, Confluence for PRDs and specifications, Figma for designs, pull requests from GitHub, Bitbucket, or GitLab, files such as PDFs and Word documents, and video recordings. Trackers, design tools, and repositories need their integration connected. You upload files and videos directly. See Context Management.
Creating a test case manually is the third route, for a flow you already know and want exact control over.
What happens after generation
Section titled “What happens after generation”You review the generated test cases grouped by story or module, then accept or reject them one at a time or a group at once. Four things update as you go.
- Coverage is accepted test cases divided by accepted plus pending. Rejected test cases are left out, so rejecting a weak test case doesn’t lower it.
- Gaps are the pending test cases nobody has accepted yet. Each story or module in the review shows its coverage and its open gap count.
- Test plans are generated in 4 types: Smoke, Feature, Regression, and Deep Regression. Each is a superset of the one before it.
- QI Metrics are 4 cards in each sprint and Adhoc session: Coverage, Pass Rate, Confidence, and Readiness. A release gate checks them against your thresholds and gives a verdict: Ready, Conditional, or Not Ready. See Release readiness.
How a test case gets automated
Section titled “How a test case gets automated”An accepted test case carries manual steps until it is automated. You don’t write any code to automate it.
Learn with Copilot reads the test case’s manual steps and expected results, drives your web or mobile app through them, and writes an automated step for each one. It runs on Testsigma Lab in the cloud or on your own machine through the Arcus Agent. You review the learned steps and save them.
Copilot then runs those steps, with a live panel showing each step in turn. You can pause the run, add or edit steps, and save your changes to the test case.
Keep coverage current
Section titled “Keep coverage current”When developers work in Claude Code, Cursor, GitHub Copilot, or Codex, or open pull requests in GitHub, Bitbucket, or GitLab, that context arrives on the Unlinked Contexts tab of Context Management. A coding session arrives with a suggested module and sprint. You map each entry to a sprint or an Adhoc session, and the Test Authoring Agent writes new test cases or updates existing ones from the changes.

Your first generated test case
Section titled “Your first generated test case”On a project with Jira connected, this is the shortest path to a generated test case. It needs no test plan, no test run, and no manually created test case.
-
Go to Settings > Integrations and connect Jira.

-
Open QI Home and describe what to test in the prompt box.
-
Under the prompt box, click Jira Requirements, select the project and a story, and click Save.
-
Click Send. The new session appears on the Adhoc tab.
-
When generation finishes, open the session and click Review test cases. Click Save to Library on each test case that is accurate.
Where to go next
Section titled “Where to go next”- Generating from your own requirements: QI Home, then Generate test cases
- Automating what you accepted: Learn with Copilot, then Copilot
- Building a library manually: Test cases, then step groups and datasets
- Running and reporting: Test runs, then test plans and reports
- Connecting your tools: Jira, CI/CD, and developer context mapping
Was this page helpful?
Thanks for the feedback.