agent-qa

Runs reviewable web and mobile tests in plain English, stores evidence in your repo, and reuses validated steps across runs.

This QA agent helps teams write and run tests as descriptions of product behavior rather than collections of selector code. It executes natural-language checks across web, Android, and iOS through the CLI or MCP, allowing engineers, QA teams, and coding agents to work from the same test files.

Its key differentiator is the memory created from real test runs. Successful steps, timings, resolved elements, and other execution evidence are written back into the repository as reviewable files. Future runs can reuse that knowledge when the application still matches, while keeping the accumulated context visible and tied to the project rather than hidden inside model state.

Key Features

Plain-English Tests

Describe actions and assertions in the same language you would use when explaining product behavior to a teammate.

This makes tests easier for humans and coding agents to write, read, and review without requiring every test to be expressed as selector-driven scripts.

Evidence-Backed Memory

Successful execution produces reusable knowledge that is stored as files under the repository.

The recorded information can include:

Successful steps
Execution timings
Resolved elements
Other run evidence

Because the memory lives in the repository, it can be reviewed alongside the rest of the project.

Cross-Platform Test Coverage

Use the same natural-language approach across multiple application environments.

Web
Android
iOS

This provides a common testing workflow instead of requiring separate test authoring approaches for each platform.

Self-Healing Execution

When a test step fails, the agent can re-observe the current screen and attempt another route.

Rather than immediately stopping because an expected element or interaction has changed, the execution process can use the newly observed state to find another way to complete the step.

Sandboxed Hooks

Run external hooks within a sandbox and pass structured results back into the test.

Supported environments include:

Node
Bun
Python
Bash

This allows tests to incorporate additional project-specific logic while keeping the results available to the test workflow.

Flexible Model Support

Configure the agent to work with different model providers rather than locking the QA workflow to a single model.

Supported configurations include:

OpenAI-compatible models
Anthropic-compatible models
Gemini
Local models

Built For Engineering & QA Teams

The agent is designed for teams that want testing artifacts to remain visible, reviewable, and connected to the codebase.

It is particularly suited to:

QA engineers
Software engineers
Development teams
Coding-agent workflows
Teams sharing tests across engineering and QA
Organizations that want version-controlled QA knowledge

Common Use Cases

Writing Behavioral Tests

Create tests around what a product should do using natural-language actions and assertions instead of manually constructing selector-based scripts.

Keep tests, configuration, memory, and knowledge in version control so changes can be reviewed alongside application code.

Cross-Platform QA

Build and maintain behavioral flows that can be executed across web, Android, and iOS.

Reusing Knowledge From Previous Runs

Use evidence from successful executions to give future runs access to previously resolved elements, timings, and working steps.

Agent-Assisted QA

Give coding agents access to the same test files and repository-based knowledge used by human engineers and QA teams.

Repository-Based Workflow

Tests, configuration, memory, and knowledge remain version-controlled rather than being stored exclusively in an external model state.

The setup can also work with:

Saved browser state
Environment values
Repository-based context
CLI workflows
MCP integrations

This allows the QA system to fit into existing development workflows without requiring teams to rewrite their behavioral tests as traditional scripts.

Why It Matters

Automated tests can become difficult to maintain when the useful knowledge behind them is hidden in selectors, browser recordings, or model state. When the application changes, teams may have to rediscover how the test was intended to work.

This QA agent takes a different approach by keeping behavioral tests and the knowledge learned from their execution inside the repository. Successful runs leave behind reviewable evidence, while failed steps can trigger fresh observation and alternative execution paths.

The result is a QA workflow where tests describe product behavior, execution builds reusable knowledge, and that knowledge remains visible to the team.