Skip to content
Docs
Arcus
Popular questions
↑↓ to navigate↵ to selectesc to close
Book a demo

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.

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.

AgentWhat it does
Sprint Planner AgentBuilds the Generation Plan for a sprint when you click Generate, from the sprint’s stories and their linked context
Test Authoring AgentWrites test cases from the context you attach, mapped to your modules
Explorer AgentCrawls your app in a browser and maps its screens, so test cases follow paths that exist
Coverage AgentTracks coverage per module, flags gaps, and scores release readiness
Test Plan AgentBuilds test plans for generated test cases by reading your test case library
CopilotWalks through a test case’s manual steps in your app and writes the automated steps, records steps you perform, and runs them
Healer AgentCorrects element locators that fail during a run
Analyzer AgentExplains why a step failed, and reads run results for recurring failures and risk signals
Bug Reporter AgentRaises a failed run as a defect in your issue tracker, written up from the run

Arcus has 2 layers.

LayerHolds
Core test managementTest cases, step groups, datasets, test plans, test runs, reports
QI HomeContext, 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.

The Arcus left navigation. Callouts mark (1) QI Home and (2) the core test management pages: Test Cases, Step Groups, Test Assets, Test Runs, Test Plans, and Reports.

Generation is the default route. There are 2 ways to start it, and everything after generation is identical for both.

AdhocSprints
Generation starts whenYou write a prompt, attach context, and click SendYou click Generate on a sprint synced from your project management tool
Context comes fromSources you attach yourselfThe stories linked to the sprint
Reach for it whenYou are covering a feature outside a sprint cycle, or want to control exactly what the Test Authoring Agent readsYour team works in sprints and you want coverage to start with the sprint

QI Home with the Sprints and Adhoc tabs outlined, above the project management tools and dev tools you can connect.

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.

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.

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.

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.

Context Management before anything is connected. Callouts mark (1) Connect GitHub for pull requests and (2) the plugins for Claude Code, GitHub Copilot, Codex, and Cursor.

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.

  1. Go to Settings > Integrations and connect Jira.

    Settings > Integrations with the Jira row outlined.

  2. Open QI Home and describe what to test in the prompt box.

  3. Under the prompt box, click Jira Requirements, select the project and a story, and click Save.

  4. Click Send. The new session appears on the Adhoc tab.

  5. When generation finishes, open the session and click Review test cases. Click Save to Library on each test case that is accurate.

Was this page helpful?