New Theory Quantifies How Much Repair AI Handoffs Push Back to Users

A coding assistant helping a user fix duplicate payment retries can lose the single most important fact in an entire long conversation without appearing to lose anything at all. The conversation is then compressed and routed to a cheaper model. The successor remembers the repository, the branch, the coding style and the proposed patch, answers in the familiar tone, and correctly explains the bug. But it acts on a stale summary that still treats production deployment as permitted.

Was that a successful handoff? A broad memory assessment might say yes, because almost all of the topic, style and task state survived. The paper argues the practical answer is no: the successor lost the one constraint governing what it was authorized to do, and its fluency makes the failure harder to notice, not less serious. By contrast, a terser successor that preserves the permission boundary and acceptance criterion while asking the user to restate a stylistic preference may provide the better continuation. That contrast motivates the paper’s central question: under a specified continuity standard and system boundary, which losses after a handoff cannot be repaired without an external contribution?

The answer takes the form of a mathematical lower bound. The framework begins with a continuity inventory built from records available in ordinary evaluation: transcripts, system instructions, durable memories, retrieved items, summaries, task artifacts, tool state, explicit corrections and model-switch metadata. A selection step then identifies identity-relevant items for a core-invariant register, using three tests: re-identification, meaning losing the item would make the later contribution hard to interpret as continuing the same exchange; role-definition, meaning the item constrains what the assistant is authorized to do rather than how it phrases an answer; and repair cost, meaning recovery would require explicit reconstruction rather than ordinary rewording. An item joins the register when it passes at least two of the three tests.

Each register item carries a weight, a provenance-bearing status marking whether it is active, superseded, revoked, disputed or uncertain, and a hard flag reserved for constraints whose omission or reversal cannot be compensated by remembering unrelated material, such as revoked tool permissions or prohibitions on modifying production state. Preservation is scored on a three-value scale: one for preserved and usable, one half for partly or inconsistently usable, and zero for omitted, unusable or reversed. Crucially, a preserved item must govern action where relevant; merely repeating the correct sentence while behaving incompatibly does not count. The weighted sum yields the pre-repair invariant fidelity, a quantity the author stresses is a weighted audit over typed items, not an embedding similarity.

The main result, the Bounded-Recovery Theorem, combines two shortfall terms. The graded shortfall is the amount by which fidelity plus an upper bound on system-side recovery falls below the continuity threshold; the hard-invariant shortfall sums the weighted residuals of hard constraints the system cannot fully restore. Every adequate continuation requires user repair of at least the maximum of the two. If fidelity plus recoverable mass sits below the threshold, or if some hard invariant cannot be restored by the system, strictly positive external repair is necessary. The bound requires valid recovery ceilings and need not be achievable by any actual policy; it lower-bounds repair without predicting how many user turns it will take.

A companion joint-feasibility formulation addresses a subtle gap. Summing itemwise recovery ceilings can overstate what the system can actually recover, because ceilings attained by different policies may not be attainable simultaneously. A simple constructed example shows two omitted hard items of equal weight where a one-call budget recovers either but not both: both itemwise ceilings equal one, yet the jointly achievable recovery is only one half, and the minimum required user repair is one half rather than the zero suggested by the naive sum. A cumulative extension sums the per-checkpoint bounds along a trajectory, so that if the total demanded repair exceeds the available user budget, no trajectory realizing those deficits can remain adequate at every checkpoint.

To illustrate, the paper stipulates a coding-assistant handoff in which a surface-rich packet preserves tone, vocabulary and diagnosis but omits the later permission revocation, while a terser core packet carries all five registered items with provenance. The surface-rich successor answers eleven of twelve broad recall probes correctly, scoring 0.92 on broad quality, but reverses the hard permission invariant, yielding a fidelity of 0.625. The terse successor answers only seven probes, scoring 0.58, yet preserves every core item perfectly. With a threshold of 0.80, repository retrieval can restore at most 0.075 of the first successor’s missing mass, leaving a graded shortfall of 0.10 and an unrecoverable hard residual of 0.30. The combined bound therefore requires at least 0.30 of user repair, directed specifically at reasserting the revoked permission.

A synthetic sensitivity analysis sweeps all 3,876 strictly positive five-item weight vectors on a 0.05 simplex grid, five thresholds, two hard-status choices and two recovery levels, giving 77,520 constructed parameter combinations. With the permission marked hard, all 38,760 corresponding combinations show a positive combined repair bound, because a hard failure cannot be removed by unrelated preservation. With the permission marked soft, positive bounds occur in 12,656 of 19,380 combinations without patch recovery and 8,666 of 19,380 with it. These counts describe the chosen grid only and are not estimated failure rates. If permission usability is left unresolved over an interval, the bound becomes an interval too, so unavoidable positive repair is no longer certified. The analysis establishes conditional robustness within the example, not classification accuracy on real conversations.

The formal machinery is deliberately algebraically simple, and the paper says so. Its value is diagnostic: it reveals when a declared architecture necessarily externalizes continuity work to the user or another external source, and it supplies an optimization target once registers, thresholds and recovery ceilings are operationally fixed. A finite-action formulation handles discrete, complementary recovery actions such as an index lookup and a record fetch that recover nothing alone but everything together, while smooth marginal allocation applies only to graded deficits after hard constraints are satisfied. Raw context length emerges as no master variable: additional window tokens reduce the repair bound only when they make missing registered constraints usable, and a compact status-aware register can outperform a much larger transcript fragment.

The evidential scope is carefully limited. No independent rater study, model benchmark or human-participant evaluation is reported; the coding example is stipulated by construction, not an observed interaction, and its broad-recall score is an illustrative comparator rather than a result from an existing memory benchmark. Supplementary materials provide calculation code, a coding manual, a weight-elicitation instrument and a prospective validation protocol proposing 800 model trials across four packet conditions, with blinded output coding and inter-rater reliability measures. The paper frames its contribution as a testable account of how continuity work can be quietly handed back to the person ostensibly being supported, with practical validity depending on reliable coding and defensible recovery bounds. As model routing and bounded memory become ordinary features of AI products, the author argues, continuity should be judged not only by how seamlessly systems hand off, but by how much of the burden of remaining one interlocutor they shift onto the user.

Subject of Research: A theoretical framework bounding the user-side repair required when AI conversation handoffs lose permissions, commitments or goals

Article Title: Bounds on user repair after context loss in AI handoffs

Article References: Rönnbäck, L. (2026). Bounds on user repair after context loss in AI handoffs. Discover Informatics, 1(1), Article 32. https://doi.org/10.1007/s44564-026-00035-w

Image Credits: AI Generated

DOI: 10.1007/s44564-026-00035-w

Keywords: AI handoffs, context loss, dialogic continuity, memory benchmarks, model routing, repair bounds, conversation state, theoretical framework, LLM agents, user repair, context compression, hard constraints