One definition per term, what OpenQA does about it, and whether you can use it today. Status is read from the same table as the rest of the site.
Also: AI-SDLC, AI-driven software delivery
Agentic SDLC (AI-SDLC) is a software delivery process in which AI agents carry requirements analysis, design, coding, testing and release. OpenQA is the verification part of it: every step leaves evidence, and a change that fails a quality gate goes back to coding with its root cause.
Also: AI-assisted development
AI software engineering puts AI to work the way an engineering team works: distinct roles, a defined process and accountability for the result. OpenQA Desktop staffs AI requirements analysts, architects, engineers, testers, reviewers and defect analysts, and every delivery carries evidence.
Also: software development lifecycle, software delivery process
The SDLC (software development lifecycle) is the sequence of requirements, design, coding, testing, release and operations. OpenQA does not replace it; it adds verification at the requirements, coding and testing steps so each step stays traceable once AI takes part.
Also: test shift-left
Shift-left testing moves testing into requirements and design: acceptance criteria, risks and test cases are settled before code is written. The OpenQA requirement analysis and test case generation skills find gaps in a requirement and produce reviewable test cases before coding starts.
Also: CI/CD, continuous integration, continuous delivery, merge gate
CI/CD (continuous integration and continuous delivery) merges code often and builds, tests and releases it automatically; a quality gate decides whether a change moves on. OpenQA gives AI-written changes a merge, review or block verdict, with the evidence behind it.
Also: AI software testing, AI testing platform
AI testing (AI software testing) uses large language models for test analysis, test design, execution and defect judgement. OpenQA packages those steps as testing skills that run locally in Cursor, Claude Code and Codex, with evidence for every verdict.
Also: smart testing platform
Intelligent testing brings AI into the whole quality process: change impact analysis, test and data generation, automated execution, defect detection and coverage. In OpenQA it is delivered by open-source skills, the desktop app and the platform modules.
Also: change impact analysis, precise regression testing
Test impact analysis selects and adds tests according to what a code change actually affects, instead of rerunning everything. OpenQA traces the interfaces, methods and call chains a change reaches, recalls the related tests and flags the paths no existing test covers.
Also: open-source testing solution, open-source AI testing tools
OpenQA Skills (repository: CodexQA) is an open-source AI testing toolkit: 11 testing skills under Apache-2.0 / MIT covering requirement analysis, change impact, test and data generation, defect scanning, browser execution and root-cause analysis, run locally with no account.
Also: AI testing skill, Claude Code testing skill
A testing skill is a package an AI coding agent installs to carry out one kind of testing task by a fixed method and write a report. OpenQA Skills installs with one npx command and works in Cursor, Claude Code, Codex and OpenClaw.
Also: code graph, architecture wiki
A code knowledge graph models modules, classes, functions, interfaces and their calls as a graph, used to understand architecture, trace call chains and analyse change impact. The OpenQA architecture wiki skill maps a repository’s layers and hubs; the code graph platform module analyses impact at call-chain level.
Also: UI page graph
A page graph models an application’s pages, elements and navigation as a graph, so UI automation knows how to reach a page and which pages a change affects. OpenQA uses it for path planning and impact analysis in UI automation.
Also: AI-generated test cases
AI test case generation designs normal, boundary, error, permission and state-transition cases from requirements and code changes. The OpenQA test case skill produces reviewable cases for web, server and app, and does not invent behaviour the requirement leaves unstated.
Also: AI API test generation
API test case generation has AI write requests, parameter combinations and assertions from OpenAPI definitions and code changes. The OpenQA test case skill generates the cases; the API automation platform runs them at scale and checks the contract.
Also: test data construction, AI test data
Test data generation has AI build the data a test needs from field constraints, boundary values and business state. The OpenQA test data skill checks that a case’s preconditions can really be created in the backend, rather than pasting a fake ID no real API accepts.
Also: UI automation, self-healing UI tests
AI UI test automation has AI understand the page, generate and run the interactions, and repair element locators when the page changes. The OpenQA browser skill passes a flow only on evidence visible on the page; the UI automation platform adds scale and self-healing scripts.
Also: graphical UI testing
GUI test automation drives clicks, typing and swipes on a graphical interface to verify behaviour across web, desktop and mobile apps. OpenQA identifies elements by both visual and structural cues, so a redesign breaks fewer scripts.
Also: cloud device testing, mobile device cloud
Cloud real devices are physical iOS and Android phones hosted remotely for mobile app testing, with logs and performance data collected. OpenQA cloud devices let an agent install the app, operate the screen and keep screen recordings and device logs.
Also: hosted browser
A cloud browser is a browser instance started on demand in the cloud, used to run web automation in parallel, isolate test environments and keep execution records in one place. The OpenQA cloud browser takes browser execution from the local machine to parallel runs in the cloud.
Also: API automation, contract testing
AI API test automation generates cases, assertions and mocks from interface definitions, runs them and detects contract drift. The OpenQA API automation platform covers case generation, mocking, data construction and contract checks.
Also: API management
An API management system keeps interface definitions, documentation and versions in one place, as the basis for API tests, mocks and frontend–backend work. OpenQA connects API management to API automation, so each change to a definition triggers the tests it affects.
Also: incremental code coverage, intelligent code coverage
Code coverage measures how much code tests exercise, usually as line and branch coverage. Intelligent coverage asks the sharper question — was this change tested? — and OpenQA reports incremental coverage per change and points to changed code no test reached.
Also: non-functional testing
Specialised testing targets non-functional quality: performance, stability, compatibility and poor networks. OpenQA specialised testing has AI design the scenarios, collect metrics on real devices and browsers, and locate the anomaly.
Also: performance testing
Performance testing measures response time, throughput and resource use under load; the AI variant designs the load model and locates bottlenecks. OpenQA has no separate performance testing product; cloud devices record CPU and memory while tests run.
Also: defect detection, AI code review
AI defect detection combines rule-based scanning with LLM semantic analysis to find business-logic defects and security issues in code. The OpenQA defect skill covers 10 languages and found 7/7 seeded defects with 0 false positives in a public blind test (one recorded run; the sample is public).
Also: problem diagnosis, fault localisation
Root-cause analysis finds what actually caused a failing test or a production error: which change, which data or which environment factor. The OpenQA root-cause skill lines stack traces and logs up with the repository to find the layer where it really breaks — the throwing line is often not the cause.
Also: high-quality defect dataset, defect benchmark
A defect dataset is a set of real or seeded defects with an answer key, used to measure the recall and false-positive rate of defect tools and AI agents. OpenQA has published the inventory-service blind-test sample and its answer key; the dataset builds on it.
Also: evidence-based QA, verifiable QA
Trustworthy quality assurance means every quality verdict carries evidence anyone can check: what changed, what was tested, what was found and why it may ship. It is OpenQA’s core position — AI writes it, OpenQA proves it.
Also: AI software quality assurance, AI QA
AI quality assurance means two things: using AI to make QA more effective, and assuring the quality of AI-written code and AI applications themselves. The OpenQA AI software QA service wires AI testing, code review and defect analysis into delivery, so each release has results, evidence and a clear verdict.
Also: agent QA
AI agent quality assurance makes sure an agent answers correctly, behaves consistently and stays within its permissions on real tasks, through evaluation sets, release gates and continuous regression. OpenQA builds this with companies through its agent evaluation service, so a new model or prompt can be re-checked quickly.
Also: agent evaluation, agent benchmarking
AI agent evaluation measures how accurately, consistently and safely an agent completes tasks, against an evaluation set and a scoring rubric. The OpenQA service covers designing the set and rubric, accuracy, stability and safety evaluation, and release gates with continuous regression.
Also: LLM application evaluation, RAG evaluation
LLM evaluation measures the output quality of large language models and the applications built on them — Q&A, RAG, agents — for accuracy, factual consistency, safety and stability. OpenQA LLM application evaluation adds a regression-ready quality gate to LLM features.