Self-healing that tells a moved locator from a real bug

Locator breakage is the single largest maintenance cost in UI automation. A developer renames a field, a component update reshuffles the markup, and a test that passed yesterday fails today without any behavior changing. Self-healing promises to absorb that churn. Done carelessly it just hides problems, including real bugs. Done safely it escalates through a fixed order of tiers, and it can tell an app that changed apart from an app that is broken.

Four tiers, cheapest and most certain first

AxonQA heals in four escalating tiers, and each one runs only when the tiers before it could not resolve the failure, so the fast, deterministic work happens first and the expensive reasoning is a last resort.

• Tier 0 repairs structural problems that stop a test running at all, like a broken import or malformed code.
• Tier 1 is a deterministic locator healer that instantly tries known-good alternative ways to find the same element. No AI, no cost.
• Tier 2 applies rule-based fixes for timing and flakiness: waiting for an element, scrolling it into view, adjusting a timeout.
• Tier 3 is where AI reasoning steps in, only when the cheaper tiers cannot resolve the failure.

Why the deterministic tiers come first

Tiers 0 through 2 are cheap, fast, explainable, and repeatable. The Tier 1 healer draws on several known-good ways to identify each element, tried in a priority order that reflects stability: dedicated test ids first, then element ids, then names, then visible text checked for uniqueness on the page. If a button's test id is unchanged and only its text moved, Tier 1 fixes the test in milliseconds with zero ambiguity. Most breakage never needs to escalate any further than this.

Tier 3: Axon reads the whole page and decides

Only when the cheaper tiers cannot resolve it does Axon, the AI assistant, step in, and it is given a view of the entire live page to reason about. Axon decides whether the element simply moved or was renamed, which is a locator problem it can safely heal, or whether the application itself is behaving wrong, which is a genuine bug it must not paper over. It will never fake a pass by rewriting what your test expects. That single distinction, the app changed versus the app is broken, is the whole point: a real regression surfaces as a failure instead of being quietly healed away.

Every fix is reviewable and reversible

The difference between healing and hiding is the audit trail. For every fix you can see what the original locator was and why it failed, which tier resolved it and which candidates were tried on the way, what the replacement is and whether it came from a deterministic tier or from Axon's reasoning, and a one-click way to accept the fix into the test or revert it if it targeted the wrong element.

Guardrails that keep healing honest

Healing never silently changes what a test means. A run that only passed because of healing says so on the run page, in amber, so a green result never hides a fix you did not approve. Healing frequency feeds your health metrics: a test that heals on every run has not been healed, it is unstable, and its locator or the app markup needs real attention. And healing touches locators, structure, and timing only, never the assertions. When the product legitimately changed and an expectation should move, Axon can propose the update, but only a person accepts it, because deciding what the product should do is your call.

That is what makes self-healing safe to trust: it always shows its work, escalates from deterministic fixes to careful review, and never fakes a pass. A moved locator gets healed in milliseconds; a real bug gets surfaced as the failure it is.