Self-healing

Overview

Automation Tasks combine deterministic Playwright code for speed and consistency with agentic steps when the page needs more flexibility. As websites change, Anchor helps your tasks stay reliable in two ways:

Layer	When it runs	What it does
AI fallback	During a run, when a segment needs agentic help	Completes the step with an AI agent so the run finishes successfully
Workflow self-healing	After a run, when a deterministic step failed	Analyzes the failure and creates a new draft version for you to review

AI fallback keeps today’s run on track. Self-healing turns what worked agentically into a stronger deterministic workflow for tomorrow.

AI fallback

When a step needs more flexibility than deterministic code alone, Anchor completes it with an AI agent. The run keeps going — you get the result, and you can see exactly where the agent stepped in.

How to spot agentic steps

On the execution. Runs that used AI fallback show an AI Fallback badge in the task execution list and on the run detail page. Look for it next to the run status. On the workflow graph. Open a run to view the Workflow Graph. Any segment that completed agentically shows an AI Fallback badge on that segment’s card — during the run and after it finishes. In the steps panel. The right-hand Steps panel lists each segment in order. Expand a segment to see its logs. When the agent completed that step, an Agent Logs section appears underneath — these are the agentic actions taken for that segment.

Segments designed to run agentically from the start (not fallback) are marked with a Bot icon on the workflow graph. AI fallback is when a normally deterministic segment completed agentically instead.

Turning AI fallback off

Some workflows must run deterministically or not at all — compliance-sensitive flows, or pipelines where a silent agent recovery masks a real regression. Set ai_fallback_enabled to false on the task to disable it. In the dashboard, open the task and toggle Allow AI in this task off under Settings. The Overview tab shows the current state. New tasks default to on, and existing tasks are unchanged. Via API:

await client.put({
  url: `/v1/task/${taskId}`,
  body: { ai_fallback_enabled: false },
});

anchor_client.put(
    f'/v1/task/{task_id}',
    body={'ai_fallback_enabled': False},
)

You can also set it at creation time with ai_fallback_enabled on POST /v2/tasks/generate. GET /v1/task/{taskId} returns the current value as aiFallbackEnabled. What changes when it’s off:

	Fallback on (default)	Fallback off
`ui` / `network` step whose deterministic code throws	An agent retries the step; run continues; tagged AI Fallback	Step fails with the underlying error; the run fails
`logic` step that throws	Run fails	Run fails (unchanged)
`agent` step	Runs with AI	Runs with AI — it was never a fallback
`ui` / `network` step authored with no deterministic code	Runs with AI	Runs with AI — it was never a fallback
Self-healing after the run	May propose a draft version	May propose a draft version — unchanged

Turning fallback off does not remove every agent from a run. Steps that are agentic by design — type agent, or a ui/network step authored with no deterministic code — still use AI, because they were never a fallback. Check the Workflow tab for Bot-icon segments before relying on a fully deterministic run.Identity authentication also runs as its own prerequisite task and is not covered by this setting. To keep login deterministic, use a cached browser profile.

Workflow self-healing

After a run where a deterministic step failed, Anchor can study the execution and propose an updated workflow. Nothing goes live automatically — self-healing creates a draft version and waits for your approval.

When it triggers automatically

Self-healing runs automatically after workflow runs that give Anchor enough signal to propose an update:

The task is a workflow task, and the run reached a terminal state other than cancelled or timed out — a run that failed still heals
A segment’s deterministic code failed — whether or not AI fallback then recovered it — or a logic segment surfaced a condition worth updating in the workflow

This often happens on runs that finished successfully: the task completed, but one or more steps relied on the agent instead of deterministic code. Self-healing learns from that run so the next execution can stay on the deterministic path. Self-healing is independent of the AI fallback setting — a task running strictly deterministically still gets healed drafts proposed after a failure. Not every failure produces one. As always, a proposal is a draft: review it and deploy it yourself before it affects production runs.

Review and approve

Open the execution

In the Tasks UI, open the task and find the run that triggered self-healing. Expand the execution to see the summary and suggested improvement.

Review the proposed changes

Click Apply fix to open a side-by-side comparison of the current workflow and the healed draft. Switch between Code and Graph views to inspect what changed.

Test the healed version

Click Test Run to execute the draft with the same inputs as the original run (or your own). Confirm the updated workflow runs deterministically before promoting it.

Deploy to production

Click Deploy to promote the healed draft to the task’s latest version. Until you do, production runs continue using the previous version.

You can also approve via API — see Code Tasks for reading draft versions and calling POST /v2/tasks/{taskId}/publish-draft.

Webhooks

Subscribe to task.healed to get notified when self-healing creates a draft version ready for review:

{
  "type": "task.healed",
  "data": {
    "task_id": "tsk_4f8w9n2b",
    "healed_task_version_id": "tv_demo_v4",
    "source_execution_id": "exr_8d2c1fda",
    "error_explanation": "Submit button moved into a new container.",
    "fix_suggestion": "Use accessible label selector instead of XPath.",
    "confidence_score": 0.82,
    "published_as_draft": true
  }
}

published_as_draft: true means the healed workflow was saved as a draft — not deployed. Use healed_task_version_id in your CI or ops pipeline to review, test, and promote the update when ready. See Webhook events for the full event catalog.

Next steps

Run a Task — execute workflows and inspect execution results
Code Tasks — read draft versions and deploy via API
Webhook events — automate on task.healed

Introduction

Platform

Integrations

Account

Overview

AI fallback

How to spot agentic steps

Turning AI fallback off

Workflow self-healing

When it triggers automatically

Review and approve

Webhooks

Next steps

​Overview

​AI fallback

​How to spot agentic steps

​Turning AI fallback off

​Workflow self-healing

​When it triggers automatically

​Review and approve

​Webhooks

​Next steps

Overview

AI fallback

How to spot agentic steps

Turning AI fallback off

Workflow self-healing

When it triggers automatically

Review and approve

Webhooks

Next steps