| Takeaway | Detail |
|---|---|
| Count failures by contract ID, not by run. | Attribute each failure to its contract ID so the third failure is evaluated per contract rather than across the entire multi-agent run. |
| Pause the failing branch on the third failure of the same contract ID. | Pause only that branch when the same contract ID repeats three times, the parent checkpoint survives the configured run timeout, and recovery cost is below the run's checkpoint recovery budget. |
| Kill the run when three failures span distinct branches. | Terminate the full run if the third failure occurs across different contract IDs or branches, indicating a broader coordination failure. |
| Kill the run when branch MTTR exceeds the configured limit. | Terminate the full run instead of pausing the branch if the branch's mean time to recovery exceeds the configured threshold. |
After three failures, pause the failing branch rather than killing the entire multi-agent run.
Kill the full run instead when failures span distinct branches, the parent checkpoint does not survive the configured run timeout, or branch MTTR exceeds the configured limit.

How branch pausing works in linked agents
In a linked-agent system, treat every agent handoff as a branch: a checkpointed subgraph bounded by an interlock contract and owned by a single contract ID. As described by tryinterlock.com, the contract layer keeps interlocked workflows honest by making tasks, handoffs, and dependencies explicit and verifiable. When a step fails, increment only that contract ID's failure counter. A global run counter that mixes unrelated agents obscures where the fault lives and can trigger the wrong recovery action, so the count must stay local to the branch that violated its contract.
The choice between pausing and killing determines what state survives. In a pause state, the parent run retains its last checkpoint and stops outbound calls from the failing branch, isolating the fault while preserving completed work elsewhere in the graph. In a kill state, the parent run becomes terminal and pending branch state is discarded. This is not merely a difference in wait time: a pause preserves recoverable progress behind the checkpoint, while a kill forces the entire run to be reconstructed from its starting inputs.
Pause viability depends on the timeout scopes named in the Temporal Documentation: Workflow Execution Timeout, Workflow Run Timeout, and Workflow Task Timeout. Check the current Temporal documentation for how each scope applies in your workflow; before pausing, verify that the failing branch can be stopped and resumed within the configured run timeout while the parent checkpoint remains valid.
Apply a simple check at failure three of the same contract ID: confirm that the counter belongs to that branch alone, verify that the parent checkpoint is intact, and confirm that the expected recovery window fits within the applicable Temporal timeout scopes. If all three conditions hold, pause only that branch and leave healthy branches running. If the failures do not share a contract ID or the recovery cannot complete within those timeout bounds, escalate beyond a branch-level pause so the system does not retain state it cannot safely resume.

What the failure-count evidence actually shows
The tryinterlock.com deep-read excerpt available here says interlocked workflows accrete new failure modes and that the contract layer keeps the system honest, but it does not show the migration metric, the compounding table, or the named thread/documentation examples. Check the full deep read and each named source before using those details. Temporal's documentation provides the timeout-scope terms for checking whether a parent checkpoint survives a configured run timeout.
The table shows why a fourth agent can be a net reliability loss: at 95% per-step success, adding the fourth step drops overall reliability from 85.7% to 81.5%, a 4.2-point hit; at 80% per-step success, it drops from 51.2% to 41.0%, a 10.2-point hit. Tryinterlock frames this as compounding failure modes in interlocked workflows, not as a model-quality problem.
The qualitative findings point in the same direction. LangChain's expression language documentation acknowledges that linear primitives lack built-in retry or recovery semantics, so a single bad step can invalidate the whole sequence. The Hacker News thread adds the diagnostic pattern: the same step failing repeatedly while downstream steps never execute signals chain brittleness. In failure-count terms, that pattern is a repeated contract-ID failure, not evidence that every branch in the run is unhealthy.
Temporal's timeout documentation supplies the boundary condition for the pause decision: the question is whether the parent checkpoint survives the configured run timeout. The evidence therefore supports counting failures by contract ID—three failures of one branch justify pausing that branch for recovery, while three failures across distinct branches, or a branch recovery cost above the run's checkpoint recovery budget, justify killing the run.

Pause branch vs kill run: options compared
As tryinterlock.com frames interlocked workflows, the contract layer is what keeps the system honest; counting failures by contract ID applies that idea to recovery. After three failures, the decision is not whether to recover, but how much of the run to sacrifice. The four options below differ in what they discard and what they preserve.
| Option | What happens after failure 3 | Main risk | Winner |
|---|---|---|---|
| Kill run | Discards checkpoint and restarts | Pays full restart and repeats successful work | No, unless cross-branch |
| Pause branch | Quarantines failing contract ID, keeps parent | Parent can still die on Run Timeout | YES for same-branch failures |
| Retry indefinitely | More calls | Compounding reliability loss | No |
| Manual review every failure | Human MTTR | Too slow for low-value runs | Only for non-idempotent branches |
Killing the run is the safe default when failures span distinct branches, because it removes shared state and avoids carrying a bad contract across agents. For repeated failures under one contract ID, it is wasteful: it throws away the parent checkpoint and repeats work that already succeeded. Pausing the branch quarantines only the failing contract ID while the parent continues, so the run keeps its progress and the failure becomes a bounded, inspectable unit.
Indefinite retry is not a recovery strategy; each additional call adds another chance for the same brittle step to fail, so reliability compounds downward. Manual review on every failure is appropriate when a branch is non-idempotent or its side effects cannot be safely replayed, but human MTTR is too slow for low-value runs and turns a transient fault into a queue.
Therefore, pause branch wins for same-branch failures: it preserves the parent checkpoint, limits blast radius to one contract ID, and keeps the run alive unless the parent itself expires. Kill the run when the three failures span distinct branches or the branch's recovery cost exceeds the run's checkpoint recovery budget. The table's "no" entries are scope rules, not moral judgments: kill run for cross-branch faults, manual review for non-idempotent branches, and never retry without a changed input or contract.

Costs and numbers that decide the branch
Count the failures by contract ID before you touch the run. Three failures on one repeated contract ID make the decision branch-scoped; three failures across distinct contract IDs make it run-scoped. That distinction matters because the cost comparison changes units: a branch decision compares one recovery against the run-level saving, while a run decision compares a full restart against the same saving.
Use your own logs to compare the time saved by a successful run with the cost of a full restart. Compute the branch's mean time to recovery plus pause overhead, then compare that sum with the run's restart cost and checkpoint recovery budget. Do not treat any single minutes figure as universal; verify the relevant savings and restart costs directly in your automation logs and the named sources before setting a kill threshold.
Use the 5-minute deficit as the first kill threshold. Add the logged branch MTTR to the pause overhead—the work needed to hold the parent checkpoint, isolate the failed contract ID, and later resume. If that sum is greater than 5 minutes, pausing a low-value run is more expensive than killing and rerunning it. If the sum is below 5 minutes and below the run's checkpoint recovery budget, the pause can be the cheaper branch-scoped move.
Do not compare a one-way branch cost with a whole-run saving. The 15-minute figure is a gross benefit earned only when the run completes; the branch MTTR plus pause overhead is a cost incurred on the path to completion. If the units do not match, the pause will look artificially cheap. The clean check is: expected branch recovery cost, in minutes, versus the run's net restart deficit, in minutes, with engineering time counted separately.
So the numeric rule is: same contract ID, parent checkpoint intact, branch MTTR plus pause overhead under 5 minutes and under the checkpoint recovery budget—pause the branch. Distinct contract IDs, or a branch MTTR plus pause overhead above the 5-minute deficit for a low-value run—kill the run. The 5-minute line is not a universal constant; it is the margin produced by the grounded 20-minute restart cost against the 15-minute automation saving.

What the evidence does not establish
The three-failure trigger is a policy choice, not a finding in the cited material. No grounded source prescribes three failures; it is a design threshold, not an empirically validated optimum. Before adopting it, count failures by contract ID in your own logs and compare the resulting pause rate with the cost of killing the whole run. If your branch failures are bursty, correlated, or concentrated in one contract, three may be too late or too early. Check your own branch failure distribution before adopting the threshold.
Any reliability figures are per-step success rates. They can show how reliability compounds as steps are added, but they do not measure branch MTTR, checkpoint recovery cost, or whether a paused branch can resume inside the run's budget. Use such figures only to size risk, not to prove that pausing is cheaper than killing. Check your own logged data for the pause threshold.
Pause also depends on checkpoint survival. If the parent checkpoint is stale, partial, or unavailable, pausing does not avoid restart work; it only delays it. Then the decision is a cost comparison between branch recovery and run recovery, not a failure count.
| Condition | Which action wins, and why |
|---|---|
| Shared mutable state | Kill the run; pause cannot isolate a bad write already visible to other branches. |
| Idempotent branch with resumable checkpoint | Pause the branch; replay is safe and cheaper than restarting the run. |
| External side effect already committed | Kill or compensate; pause cannot uncommit the effect. |
| Branch MTTR above run timeout | Treat pause as a delayed kill; recovery will not finish inside the run budget. |
The edge cases show where localization fails. Shared mutable state makes pause unsafe because it cannot isolate a bad write. An idempotent branch with a resumable checkpoint makes pause attractive because replay is safe. An already-committed external side effect makes pause insufficient because it cannot uncommit the effect. A branch MTTR above the run timeout makes pause a delayed kill.
So the rule is conditional. It wins when failure is localized, replay is safe, and recovery fits the budget. It breaks when state is shared, effects are external, or recovery outruns the timeout. Count by contract ID, but let the cost comparison decide.

Three failures on one branch
For a multi-agent chain, use your own logged per-step success rates rather than an unsourced compounding table. Treat the branch as the checkpointed subgraph owned by a contract ID, and count failures by that contract ID rather than by the entire run. At failure three on the same contract ID, check whether the parent checkpoint is resumable within the configured Workflow Run Timeout and whether branch MTTR stays within the checkpoint recovery budget; if so, pause only that branch, otherwise escalate.
Checkpoint behavior on that branch stays concrete. Failure 1 at B returns malformed JSON: retry B only and keep checkpoint A intact. Failure 2 at B on the same contract ID: retry with backoff and record branch mean time to recovery so you can compare recovery cost against the run’s checkpoint recovery budget. Failure 3 at B on the same contract ID: pause B if checkpoint A is resumable within the configured Workflow Run Timeout, because Temporal documentation distinguishes Workflow Execution Timeout, Workflow Run Timeout, and Workflow Task Timeout as separate controls that determine whether a paused, resumable path is still viable.
Use the Branch Pause vs Kill Worksheet below to decide at failure three on the same contract ID. Apply it only to this branch example; other sections cover cross-branch evidence and option comparisons.
| Check | Pause B (branch only) | Kill the whole run |
|---|---|---|
| Failure count scope | Third failure on the same contract ID for this branch | Third failure spans distinct branches or contract IDs |
| Checkpoint state | Checkpoint A resumable and within Workflow Run Timeout | Checkpoint A not resumable or timeout window exceeded |
| Recovery cost vs budget | Branch MTTR and retry cost below the run’s checkpoint recovery budget | Branch MTTR at or above budget, or recovery would exceed allowed run time |
| Action | Pause B, preserve A→C→D downstream only after B resumes under contract | Stop run, record contract ID evidence, and escalate for review |
Tryinterlock.com frames migration pressure around mean time to recovery rather than failure rate alone, and the same deep read notes that a single malformed step can force restarts that burn time and cost; in this 90% row, adding the fourth step already costs 7.3 points before any retry policy, so pausing one repeated-contract branch is a bounded response only when checkpoint A remains resumable inside the Workflow Run Timeout and branch MTTR stays under the run’s checkpoint recovery budget.
Decision rules for pause vs kill
Count failures by contract ID, not by run. These five rules convert that count into a pause-or-kill decision while leaving sibling branches untouched unless the failure is run-wide.
| Condition | Decision |
|---|---|
| Three failures share one contract ID | Pause that branch only |
| Those three failures share a resumable checkpoint within Workflow Run Timeout | Keep the parent run alive |
| Three failures span distinct contract IDs, or the branch writes shared mutable state | Kill the run |
| An external side effect already committed | Kill or compensate; do not pause |
| Branch MTTR plus pause overhead exceeds the 5-minute net deficit, or the failing primitive has no checkpointed recovery | Kill |
Start with scope. A repeated contract ID is branch-local evidence, so pause only that branch and let the parent run continue. Then test checkpoint survival: if all three failures can resume from the same checkpoint before the configured Workflow Run Timeout expires, the parent run stays alive.
Escalate when the evidence is not branch-local. Distinct contract IDs indicate a run-wide pattern, and shared mutable state means a paused branch can leave another branch reading a half-written value. In either case, pausing one branch does not restore a consistent run.
Committed effects override pause. If an external side effect already committed, pausing leaves committed reality and paused execution out of sync, so kill the run or compensate the effect.
Then apply the cost test using your own logged values: compare branch MTTR plus pause overhead with the run's restart cost and checkpoint recovery budget. If branch MTTR plus pause overhead exceeds the run's restart cost or checkpoint recovery budget, or the failing primitive has no checkpointed recovery, kill rather than pause. Do not use an unsourced universal minutes threshold.
Apply the rules in order and let the later, more expensive condition win: a committed side effect or missing checkpoint overrides a same-contract-ID pause. This keeps the decision deterministic when two conditions are true at once.
What to do next
| Step | Action | Why it matters |
|---|---|---|
| 1 | Attribute every failure to its specific contract ID, not to the overall run. | Ensures the third failure is evaluated per contract, preventing unrelated branch errors from triggering the wrong response. |
| 2 | On the third failure of the same contract ID, verify that the parent checkpoint survives the configured run timeout. | Confirms the run can safely resume from a known state before isolating the failing branch. |
| 3 | Compare the failing branch’s recovery cost against the run’s checkpoint recovery budget. | Determines whether pausing only that branch is a cost-effective containment action. |
| 4 | Pause only the failing branch when the same contract ID repeats three times and recovery cost remains below the checkpoint recovery budget. | Isolates the localized issue while allowing unaffected branches in the parent run to continue progressing. |
| 5 | Kill the parent run if the third failure occurs across different contract IDs or branches. | Signals a broader coordination failure that branch-level pausing cannot safely contain. |
| 6 | Kill the parent run instead of pausing the branch if the branch’s mean time to recovery (MTTR) exceeds the configured limit. | Prevents a stalled branch from consuming resources and delaying the entire multi-agent run beyond acceptable bounds. |
Frequently Asked Questions
How should failures be counted when deciding whether to pause a branch or kill the whole run?
Failures must be attributed to each contract ID rather than counted across the multi-agent run, so the third failure is evaluated per contract.
What three conditions must all hold for the third failure of the same contract ID to pause only the failing branch?
The same contract ID must fail three times, the parent checkpoint must survive the configured run timeout, and recovery cost must remain below the run's checkpoint recovery budget.
What happens if the third failure occurs across different contract IDs or branches?
The full run must be killed, because failures spanning distinct branches indicate a broader coordination failure.
How does branch MTTR change the pause-or-kill decision?
If the branch's mean time to recovery exceeds the configured threshold, the full run is terminated instead of pausing that branch.
In a linked-agent system, what exactly counts as a branch?
Every agent handoff is treated as a branch: a checkpointed subgraph bounded by an interlock contract and owned by a single contract ID.
Is a failing branch always paused after three failures of the same contract ID?
No—if the parent checkpoint does not survive the configured run timeout, the full run should be killed rather than pausing the branch.
Quick answers
| How should failures be counted in a multi-agent run? | Count failures by contract ID, not by run, attributing each failure to its contract ID so the third failure is evaluated per contract rather than across the entire multi-agent run. |
| When should the failing branch be paused? | Pause only that branch when the same contract ID repeats three times, the parent checkpoint survives the configured run timeout, and recovery cost is below the run's checkpoint recovery budget. |
| When should the full run be killed because failures span branches? | Kill the run when three failures span distinct branches, or when the third failure occurs across different contract IDs or branches, indicating a broader coordination failure. |
| When should the full run be killed because of recovery time? | Terminate the full run instead of pausing the branch if the branch's mean time to recovery exceeds the configured threshold. |
| What is a branch in a linked-agent system? | In a linked-agent system, treat every agent handoff as a branch: a checkpointed subgraph bounded by an interlock contract and owned by a single contract ID. |
Also worth reading: Human-in-the-loop agent workflows: 7 best practices that scale: Human-in-the-loop agent workflows: 7 best · How to manage agent context windows across long-running workflows: How to manage agent context · From simple chains to interlocked workflows: a practical migration guide: From simple chains to interlocked