Self-healing, low-maintenance mobile tests
Semaloop's self-healing works because a test is a description of intent rather than a script: when a button moves or a screen is redesigned, the agent finds the new route to the same goal instead of failing on a missing selector.
What you get
- Tests state intent, so a moved button, renamed label or redesigned screen usually needs no edit
- The agent reads the rendered screen, not selectors or the accessibility tree
- Routines learned from successful runs are reused while the UI stays the same
- When a learned routine stops working, the agent falls back to recovery and finds a new path
- Real behaviour changes still fail the test, so self-healing never hides a regression
- The trace labels each routine, so you can see where the agent had to adapt
Why scripted tests break
Most mobile test tools find an element by an identifier, a path or a position, tap it and assert on another element. That is fast, and it works until someone redesigns a screen. Then every test built on those selectors fails, even though the app still does what it should. The fix is a person, editing the script.
How self-healing works in Semaloop
There is no stored list of selectors to repair. The mechanism has four parts, and it helps to be specific about each.
- The spec states the goal and what should be true afterwards, not the path. A redesign changes the path, not the goal.
- The agent works from what is rendered on screen. A restyled, moved or renamed control is just a screen that looks different, and the agent reads it again.
- Skills are repeatable routines the agent learns from successful runs, such as how to complete onboarding or perform a search. While the UI stays roughly the same, later runs reuse them, which is faster. The trace marks them New Skill Learned or Existing Skill.
- If the UI has shifted or a skill hits a hiccup, the agent falls back to recovery mode and finds a new way to the goal. If it cannot, the trace says Existing Skill Failed.
What self-healing does not do
It does not make a test pass. If the behaviour your spec describes is broken, such as a checkout that no longer shows the right total, the test fails, because the judging step checks the outcome against your description. That is the point: the agent adapts to how the app looks, not to what it does.
It does not rewrite your spec, and it does not discover flows nobody described. A spec needs editing when the product behaviour it describes genuinely changes. Editing a spec also invalidates its learned skills, so expect the next run to take longer while they are relearned.
Keeping maintenance low in practice
Self-healing does most of its work when specs are written as outcomes. Describe the goal rather than the taps, keep the data, check something that stays on screen, and keep each test to one workflow. Give the agent the state it needs with secrets and custom tools rather than assuming it.
If the agent keeps getting stuck on one part of a test, give a thumbs down to the skill in the trace. That invalidates it, and the agent relearns that part on the next run.
For UK teams
Semaloop is a London company and publishes its data processing agreement at /dpa, which is useful to have to hand when a UK security or procurement review asks how test runs are handled.
Frequently asked questions
Last reviewed: 26 October 2026
What is self-healing mobile test automation?
It is test automation that keeps working when the app's interface changes, instead of failing on a selector that no longer matches. Tools do this in different ways. In Semaloop there is no selector to repair, because the test is a description of intent and the agent finds the route to the goal on each run.
Does Semaloop rewrite my test when the UI changes?
No. The spec stays exactly as you wrote it. The agent adapts at run time, and the routines it has learned are refreshed when they stop working. You edit a spec when the product behaviour it describes changes.
What happens to my tests when a screen is redesigned?
Usually nothing needs updating. The spec describes an outcome, so a moved button or renamed label leaves it valid. The first run after a redesign may be slower while the agent finds the new route and relearns its routines.
Can self-healing hide a real bug?
It should not. The agent adapts to how the app looks, but a judging step checks the result against your description. If the behaviour is wrong, for example a wrong total or a missing confirmation, the test fails.
How do I see when the agent had to adapt?
Open the run's trace. Steps are labelled New Skill Learned, Existing Skill or Existing Skill Failed, and each step shows the agent's reasoning, alongside the video.
How much maintenance do Semaloop tests still need?
Far less than a scripted suite, but not none. You revise a spec when the behaviour it describes changes, add tests for new flows, and keep credentials and setup tools current.