Six agents. One deterministic pipeline.
The intelligence lives in the agents; the control lives in the Orchestrator — a deterministic workflow engine, not an LLM. It sequences the agents, manages retries, timeouts and budgets, and enforces which models run for which tenant, so runs stay repeatable.
From a target to a triaged report, one pass
Each step is owned by a named agent. The Orchestrator runs them in order, retries within budget, and persists state so a run can be resumed rather than restarted.
Plan & explore
The Author agent inspects your app or API surface to decide what to test.
Author
Generates cases from a spec, URL, or story — with intent-rich locators, not brittle selectors.
Generate test data
Derives the fixtures and data each case needs to run realistically.
Execute
Runs cases against real browsers and APIs, evaluates oracles, and captures full evidence.
Heal
On a broken locator, re-authors it from observed state, re-validates intent, and patches — flagged for review.
Report
Triages flaky-vs-real, surfaces root-cause hypotheses, and computes regression deltas.
Healing is re-authoring, not retry
A retry runs the same broken locator again and hopes. The Healer does something different: it re-authors the locator from the page's observed state, re-validates that the case still checks the original intent, and patches the case with a confidence score — flagged for a human to confirm.
- Re-authors from observed DOM/state, not a hard-coded selector guess
- Re-validates the original oracle — the case still tests what it meant to
- Patches with a confidence score, never landing a low-confidence heal silently
- Flagged for review so the QA Lead owns whether a heal is trustworthy
- Every heal is measured — precision, recall, flake and false-heal rate
The Orchestrator is deterministic — not an LLM
The agents are non-deterministic by nature; the thing that runs them is not. The Orchestrator is a deterministic workflow engine. It decides the order, enforces the rules, and persists the state — which is what makes an agentic run something you can gate CI on.
- Sequences the agents in a fixed, auditable order
- Manages retries, timeouts and per-run budgets
- Enforces governance — which models run for which tenant
- Persists state so a run resumes rather than restarts
- No model call decides control flow — the pipeline stays repeatable
How the pipeline actually behaves
Is it just auto-retry with extra steps?
What if it heals wrong?
How do you keep runs repeatable?
Which models and engines does it use?
Where does the evidence come from?
Describe the flaky suite. We'll show the agents fix it.
Bring a real spec or a URL. In a short session we'll author cases, break a locator, and let it heal — live.