QuAIA – Quality Assurance with Intelligent Agents

Give your QA team the work it deserves

AI agents do the busywork. Your team makes the calls.

Your team decides what matters and why. The agents take care of the how: specialized AI agents work through your whole test process, from the first requirement to the final test report. Connected to your ticket and test management systems, without test scripts, in your own infrastructure.

  • No test scripts to maintain
  • Tests the way a human would
  • Learns from your experts
  • Stays in your infrastructure

Open source under AGPL-3.0. Features marked Prototype already work end to end, but need more testing than other features, especially in real customer environments, and may need some additional adaptation.

Example runIllustrative example, shortened.
  1. Requirement

    #214Redeem a voucher at checkout

    approved
  2. Test case“Redeem voucher”

    PreconditionA product is in the cart and the cart page is open

    passed
  3. 1Enter the voucher code

    Data:
    SOMMER10
    Expected:
    The order summary shows a 10% discount
    passed
  4. 2Complete the order

    Expected:
    The order confirmation page is shown
    Actual:
    Error message “Order could not be processed”
    failed
  5. Bug created#231

    Priority: High

    Checkout – Order with voucher aborts

    Steps to reproduce · Expected and actual result · Environment: Chrome, Windows 11

    • Screenshot
    • Video

    Linked to the test case · No duplicate found

What is QuAIA?

QuAIA (Quality Assurance with Intelligent Agents) is an open-source multi-agent system. Specialized AI agents react to what happens in your project and work hand in hand across the whole test process. An orchestrator hands out the work, each agent masters one job, and open standards (A2A and MCP) let them talk to each other and make it easy to connect your tools.

Code ships faster than ever. Testing can’t keep up.

With AI assistants, developers deliver more code in less time, and more defects come along for the ride. If testing still relies on manual clicking and fragile scripts, it becomes the bottleneck of the whole delivery pipeline.

AI writes the code. Let AI test it, too.

The whole test process in one system

Follow one requirement from the first review to the final execution report. Each stage is triggered by an event and delivers its results where your team already works, such as Jira and Zephyr.

  1. Trigger:New story #214

    Review requirements

    Review comment on #214
    • Define whether the voucher applies before or after campaign discounts
    • State the currency of the minimum order value, e.g. 50 EUR
    • Specify the error message for an expired voucher

    Result in:Jira

  2. Trigger:Story approved

    Design test cases

    Test case “Redeem voucher”
    • Precondition: product in the cart
    • Step 1: Enter code SOMMER10 → 10% discount
    • Step 2: Complete order → confirmation shown

    Result in:Zephyr

  3. Trigger:CI/CD pipeline run

    Run tests

    Run of “Redeem voucher”
    • Precondition met
    • Step 1: discount displayed
    • Step 2: error instead of confirmation

    Runs in:your application

  4. Trigger:Step failed

    Report defects

    Bug #231
    • Order with voucher cannot be completed
    • Repro steps, expected and actual result
    • Screenshot and video attached
    • No duplicate found

    Result in:Jira

  5. Trigger:Run finished

    Document results

    Test execution report
    • 1 test case executed
    • 1 step passed
    • 1 step failed (#231)
    • Screenshots and logs attached

    Result in:Zephyr · Allure

OrchestratorReacts to events, starts the right agent, and processes the results.

Not a chatbot. A team that gets things done.

A language model alone knows a lot about testing, but it can only talk. QuAIA gives AI the means to act. Each agent is a specialist with exactly the tools its job needs and runs as its own service. The orchestrator coordinates them.

  • Orchestrator

    The central coordination layer that turns individual agents into one team. It registers the agents and watches over their health, gives each of them the information it needs when an event arrives, processes their results where required, and links several agents into a single pipeline. At the end of a run, it documents the results with their evidence and creates test execution reports in the test management system, as well as in HTML format (Allure).

  • Requirements review

    Checks requirements for testability, clarity, and completeness, using the project documentation as its knowledge base, and posts concrete suggestions for improving them as a review comment, supporting a shift-left approach.

  • Test design

    Writes test cases for approved requirements, enhances those test cases in a refine-review loop, detects any existing duplicates, classifies the refined test cases, and files them in the test management system (e.g., Zephyr or Xray). Your specialist signs off.

  • UI test execution

    Operates keyboard and mouse while watching the screen—like a real user, tirelessly and around the clock. No scripts, no workarounds, independent of the UI technology. Experts supervise the initial runs and teach it new workflows through its own interface.

  • API test execution

    Tests interfaces the way a tester would with a tool like Postman, including checks against JSON Schema and the OpenAPI specification.

  • Defect reporting

    For failed tests, creates defect reports with all the information needed, including screenshots and logs, unless the same failure has already been reported.

What every agent builds on

  • Knowledge base (RAG)

    Gives every agent access to your project knowledge: tickets, Confluence pages with attachments, and SharePoint documents, all continuously synced into a database. More sources can be added via connectors.

  • Security

    Prompt injection detection, credential masking in test data, and authenticated access. The security architecture is described as code and checked in every build.

  • Open standards

    QuAIA builds on open standards instead of proprietary interfaces. With A2A (Agent2Agent), the orchestrator and the agents speak a common language. MCP (Model Context Protocol) makes it easy to connect your tools and other external services.

The framework is built so that adding a new agent is easy: a new agent only needs to know its own job; everything else is already there.

Connected tools

Supported
Jira
Confluence
Zephyr
Prototype
SharePoint
Xray
Planned
Azure DevOps

UI test execution

Change the UI. See what breaks.

The UI agent runs test cases purely from the screen, not from the page code. Here is the same checkout with the same test, before and after a redesign: the script looks for a locator in the page code; the agent looks at the screen.

Checkout

Wireless headphones
€89.00
Voucher SOMMER10
−€8.90
Total
€80.10

Script-based test

await page.click('#submit-order')

Waiting for a run

QuAIA UI agent

Step: Complete the order

Waiting for a run

One test case, any language, any format

  • Every language, no translation files

    When IDs are auto-generated, scripts rely on visible text and then need translation files for every language. The agents run on multilingual models: one test case works in every widely used language, even if the UI switches language mid-run.

    In the test case
    Complete the order
    On screen
    SubmitAbsendenEnvoyerEnviar送信
  • Any data format, one value

    Write test data once, in any form a person understands. The agent enters it the way each field expects, whatever the date, time, or number format, even after a redesign changes it. No duplicates, no reformatting.

    In the test data
    November 6, 2026
    As the field expects
    06.11.202611/06/20262026-11-066 Nov 2026

Show it once. Never explain it again.Prototype

Ordinary AI forgets everything the moment a request ends. QuAIA’s agents learn like a new colleague on your team: eager, quick on the uptake, just not yet familiar with your application. The first time a test case runs, it runs in supervised mode: wherever the agent doesn’t know a workflow yet, such as logging in or placing an order, your expert shows it once, and from then on the agent knows it by heart. Every subsequent run of that test case, supervised or unattended, goes from start to finish on its own, without any human intervention. This agent memory is one of the core ideas of QuAIA.

On top of that, the UI agent learns from its mistakes: tell it once how a failure was fixed, and it remembers the fix every time it runs that step. It also tracks which screen elements are hard to find and logs every hiccup, so you can see where your tests are fragile.

The knowledge base supplies existing project knowledge such as requirements and documentation. The agent memory adds dynamic knowledge that only emerges in practice. Typical test design tools generate test cases without it: formally correct, but often not executable.

QuAIA vs. the alternatives

Existing approaches fall into four groups. Each covers parts of what QuAIA does.

  • Script-based test automation

    How it worksTests are code or models that address elements via locators. Every UI change needs maintenance. AI add-ons generate and repair this code but keep the principle.

    What QuAIA does differentlyNo scripts and no locators, so there is nothing to maintain after UI changes.

  • AI-assisted test platforms

    How it worksGenerate tests from requirements or natural language and repair locators automatically (“self-healing”). Mostly SaaS, closed, and tied to the vendor’s models. Execution stays locator- or code-based.

    What QuAIA does differentlyRuns in your infrastructure with the model you choose, integrates with your ticketing and test management systems, and can be tailored to your specific needs.

  • Image-based agents and image recognition

    How it worksRecognize elements on screen, but cover execution only. Test cases live as scripts or files in the tool, often one per platform.

    What QuAIA does differentlyCovers the whole process, keeps test cases in your test management system, and learns from human demonstration.

  • Testing services

    How it worksLabor-intensive. Capacity grows only with more person-days.

    What QuAIA does differentlyAgents handle the routine and scale by adding instances. People focus on judgment.

Individual elements exist on the market. To my knowledge, no other solution covers the whole test process, takes test cases straight from your existing systems, executes them purely from the screen, learns from human demonstration, feeds that knowledge back into test design, and runs entirely in your infrastructure with self-hosted models.

What makes QuAIA different

Try it on GitHub

Your infrastructure, your data

QuAIA is deliberately not a SaaS product. It runs in your cloud account or on-premises and is not tied to any cloud provider. With self-hosted models, your data does not leave your environment. Remote maintenance is optional, only uses access you grant and control, and does not require moving data out.

Any model, including self-hosted

Cloud models such as Anthropic Claude, Google Gemini, OpenAI GPT, and models from other OpenAI-compatible providers, or self-hosted open-weight models on a rented GPU, your own GPU servers, or an internal AI platform. Support for self-hosted models is currently a prototype.

Plug-and-play and scalable

Agents can be added or removed without touching the rest of the system and can run as extra instances under load, for example more UI agents for a large regression run. You choose the ticket system, test management system, and model.

Learns from experience

Every demonstration and every fixed failure makes the agents better, and new test cases build on what they already know. The longer QuAIA runs, the less often your experts need to step in. Learning from demonstration is currently a prototype.

Nothing to script, nothing to fix

No test code, no locators, no upkeep after a redesign. Your test management system stays the single source of truth: whatever you change there is exactly what runs next, with no copies to keep in sync. And because the agent sees what users see, it is built to also catch the display and usability issues a script never looks at.

One test case for every screen

Web or desktop, any framework: if it appears on a screen, the agent can test it. Write a test case once and run it on every supported platform, with mobile next in line. Desktop support is currently a prototype.

One flow instead of five tools

No handoffs and no gaps between tools: from the first requirement to the final report, every result feeds straight into the next step.

Open and verifiable

The source code is open under AGPL-3.0. The architecture is described as code and checked in every build. Unit, smoke, and A/B tests catch quality drops after changes to the model, code, or prompts.

Request a demo

Tell me what you would like to see, for example, on your own application. I’ll reply by email with a proposed date.

Your details are used only to answer this request. More details in the privacy policy (German).

Questions or feedback?

Any thoughts on the project, or a question that does not need a demo? Send me an email.

Click to copy the address

More about the project