QuAIA: An open-source team of AI agents that handles the whole test process

Give your QA team the work it deserves

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.

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 nowCoding assistants and coding agents have become standard equipment. Teams deliver more features, more often, and in parallel.

• More speed, more riskAI accelerates delivery and defects alike: generated code tends to bring extra logic errors and security gaps that someone has to catch. Sources: CodeRabbit (2025) ·Veracode (2026)

• QA is left behindDevelopment has gone agentic; quality assurance mostly hasn’t. Automating a step here and there won’t close the gap: testing needs agents of its own.

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 requirementsResult in:Jira
2. Trigger:Story approved ### Design test casesResult in:Zephyr
3. Trigger:CI/CD pipeline run ### Run testsRuns in:your application
4. Trigger:Step failed ### Report defectsResult in:Jira
5. Trigger:Run finished ### Document resultsResult in:Zephyr · Allure

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.

• OrchestratorThe 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 reviewChecks 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 designWrites 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 executionOperates 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 executionTests interfaces the way a tester would with a tool like Postman, including checks against JSON Schema and the OpenAPI specification.

• Defect reportingFor 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.

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

• Open standardsQuAIA 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 filesWhen 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 valueWrite 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.

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

source & further reading

quaia.dev — original article