The analyst who became faster and less able to know

Maya reviews commercial credit renewals. A new assistant reads statements, covenant schedules, account history and policy, then drafts a polished memo with a recommendation. Maya checks the numbers, edits the prose and approves or escalates the case. Her queue clears earlier. The memos become more consistent. Nothing in the weekly dashboard looks like deterioration.

Five months later, the assistant is unavailable during a model rollback. A borrower has a temporary covenant waiver, a cross-default clause in a related facility and a cash-flow pattern unlike the cases used in training. Maya still knows the vocabulary. What she cannot readily reconstruct is the old sequence of work: which questions to ask before a recommendation exists, which evidence deserves suspicion, and which missing fact could reverse the decision. She has spent months evaluating completed arguments rather than building them.

Now change one fact. On every assisted case, Maya first records a provisional risk view, names the evidence that could overturn it and only then sees the assistant's analysis. The system shows sources before its conclusion, injects a small sample of deliberately wrong recommendations, and returns eventual outcome feedback. The same amount of AI computation is available. The only difference is which cognitive operations remain practised by the person.

This case is synthetic. It is designed to expose a measurement error. Most AI programmes measure the performance of the coupled system while assistance is present. They rarely measure what the human can still do after the coupling is broken, challenged or moved to an unfamiliar case. Yet the human is often described as the accountable reviewer, the exception handler and the recovery path.

The central claim is simple: delegation preserves cognitive sovereignty when it removes effort without removing the practice and feedback needed for independent judgement, contestability and recovery.

That is not an argument for unaided work. Human cognition has always depended on notebooks, colleagues, instruments, maps, libraries and calculators. Cognitive offloading can increase accuracy and free scarce attention. The question is narrower: which capabilities must remain available in the human or the wider organisation when the external aid is unavailable, misleading or no longer authorised?

The coupled score hides the uncoupled person

A workflow can improve today while weakening the very human capability named as its control tomorrow. The error begins when we treat assisted output quality as a complete account of human-machine performance.

Two quantities, not one

Let coupled performance mean the quality, speed and cost of work while the person and the AI operate together. Let retained competence mean the person's or team's ability to perform the required epistemic operations when the AI is removed, contradicted or applied outside familiar conditions. These quantities can move together, but there is no rule that says they must.

The productivity case for assistance is real. In a controlled study of professional writing tasks, ChatGPT access reduced average completion time by 40 per cent and raised assessed quality by 18 per cent (Noy and Zhang). Such results justify serious adoption work. They do not establish what users learned, what they could later reproduce, or whether they became better at detecting a confident error.

A broader meta-analysis of 106 experiments found that human-AI combinations, on average, outperformed humans alone but underperformed the better of the human or AI alone. The pooled deficit against the best member was Hedges' g = -0.23, with wide heterogeneity across tasks (Vaccaro, Almaatouq and Malone). The important lesson is not that collaboration fails. It is that the label “human plus AI” predicts very little without the allocation and interaction design.

What sovereignty names

“Sovereignty” can sound grander than the engineering problem. Here it has a bounded meaning. A person or organisation has cognitive sovereignty over a decision when it can still:

• state the question and the decision boundary;
• identify relevant evidence and material absences;
• form at least one independent hypothesis or provisional view;
• test a recommendation against evidence, policy and alternatives;
• express uncertainty and know what further information would reduce it;
• contest, override or defer the recommendation without procedural punishment; and
• reconstruct and recover the process when the aid fails.

This is epistemic agency: effective control over how claims are formed, justified, revised and acted upon. It is not the fiction that every individual should know everything. A sovereign team may distribute memory and expertise across people, documents and tools. What matters is whether the distribution remains inspectable, challengeable and recoverable.

The distinction also prevents a common mistake. Keeping a person “in the loop” does not prove that the person retains epistemic agency. A reviewer who sees the recommendation first, receives no independent evidence and is measured mainly on throughput may be present yet cognitively downstream. Clicking approve is an action. It is not necessarily a judgement.

Thought experiment one: two desks, one dashboard

Imagine two credit desks using the same model, data and policy. Their assisted accuracy, review time and escalation rate are identical for six months. At Desk A, the model's recommendation appears first. At Desk B, reviewers record a provisional decision and one disconfirming fact before the recommendation is revealed. Change no other feature.

Now corrupt ten per cent of recommendations in a controlled test. The error is plausible, not absurd: an expired waiver is treated as active, or recurring revenue is inferred from a one-off receipt. If both desks perform equally, the prediction-first step has added friction without value. If Desk B detects more planted errors and transfers better to unfamiliar cases, reveal order is doing causal work. The experiment varies one feature rather than comparing two bundles of “human-centred” design.

How delegation changes the delegator

Atrophy is not a mystical effect of using tools. It follows from a more ordinary mechanism: a capability changes when its component operations stop receiving effortful practice, diagnostic feedback or both.

Offloading is a strategy, not a diagnosis

Cognitive offloading means changing the environment or using an external resource to reduce the processing required inside the head. Writing a reminder, rotating a page, querying a database and using a map all qualify (Risko and Gilbert). The category includes sensible and harmful choices. Calling an act “offloading” does not tell us whether it improves the wider system.

Memory itself often reorganises around external availability. In experiments on expected computer access, people showed different recall for content and for where it could be found (Sparrow, Liu and Wegner). That can be adaptive. A surgeon need not memorise every formulary entry if retrieval is reliable and the decision process can validate the result. The danger appears when the external store supplies not only facts but the framing, interpretation and final conclusion, while the human still carries responsibility for challenging it.

Capability decays at the level of operations

“Critical thinking” is too broad to diagnose a workflow. A person may retain domain vocabulary while losing fluency in generating hypotheses. Another may remember rules but become poorly calibrated about when evidence is incomplete. A third may remain excellent at routine verification but struggle to restart a case after an outage. Delegation should therefore be analysed operation by operation.

A useful decomposition for consequential knowledge work is:

1. Framing: What is the actual decision, and what lies outside it?
2. Search: Which evidence is relevant, authoritative, fresh and permitted?
3. Generation: What plausible explanations or courses of action exist?
4. Discrimination: Which claim survives comparison with evidence and alternatives?
5. Calibration: How uncertain is the judgement, and what would change it?
6. Contest: Can the person disagree, explain why and invoke another authority?
7. Recovery: Can the case continue after corrupted output, outage or policy change?

An assistant may offload search while strengthening discrimination, because it retrieves more evidence for the reviewer to compare. It may also offload both search and discrimination by presenting a fluent answer whose sources are hard to inspect. The interface label may be identical in both cases. The learning consequences are not.

Practice without feedback is repetition; feedback without practice is observation

Skill retention research consistently links nonuse to decay, though the rate depends on the task, prior mastery and measurement. A 2025 meta-analysis of procedural skills involving motor components assembled 1,344 effect sizes from 457 reports and found substantial variation across accuracy, speed and mixed measures (Tatel and Ackerman). Those results should not be copied directly into knowledge work. They support a narrower point: nonuse is a plausible causal mechanism, not a metaphor, and retention must be measured for the actual task.

Generative AI adds a second mechanism. It can let the user observe a good answer without performing the mental work that produced it. Gajos and Mamykina ran three experiments on nutritional decisions. Recommendation plus explanation improved immediate choices but did not produce incidental learning. Asking participants to make a choice before seeing the recommendation still did not produce learning. Explanation without the recommendation improved both decision quality and learning, apparently because participants had to construct the final decision themselves (Gajos and Mamykina).

This result matters because it isolates a design variable. More explanation is not automatically more engagement. If the conclusion arrives with the explanation, the user can accept the package. If evidence arrives without the conclusion, the user must integrate it.

In a separate experiment with 199 participants, cognitive forcing designs reduced overreliance on wrong AI advice relative to simpler explanation interfaces. The least preferred designs were often the ones that reduced overreliance most, and benefits differed with participants' motivation for effortful cognition (Buçinca, Malaya and Gajos). Friction can help, but it has distributional and adoption costs. A good design targets friction at consequential epistemic moves rather than making every interaction laborious.

Thought experiment two: identical practice, different feedback

Two incident-response teams use the same assistant for one hundred matched cases. Both teams must record a provisional diagnosis before seeing the machine's recommendation, so their active practice is held constant. Team C never learns the verified root cause because a separate service closes the investigation. Team D receives the adjudicated cause the next day, including whether its own override of the assistant was justified. Workload, model, interface and incentives remain unchanged.

After ten weeks, give both teams unfamiliar incidents and make the assistant selectively unreliable on one error class. If their calibration, challenge rate and recovery are the same, outcome feedback has added little and the proposed mechanism is weakened. If Team D learns when the assistant's evidence is diagnostic, rejects more corrupted recommendations and escalates uncertainty more appropriately, feedback is doing causal work. A crossover, in which the teams exchange feedback conditions, would further separate the effect from stable differences in expertise.

The comparison matters because an explanation can be internally coherent yet repeatedly wrong. Without an external outcome or qualified adjudication, the user can practise agreement rather than discrimination.

An operational model of transfer and atrophy

The following model is an open hypothesis and planning instrument, not a fitted theory of cognition. For epistemic operation j, let retained capability at time t be H_j,t between zero and one:

Here, p_j,t is the amount of active practice for that operation; f_j,t is the diagnostic quality of feedback; α is a learning rate; and β is a nonuse or interference rate. Raising practice or feedback increases the opportunity for retained capability to grow. With little practice, the final term pulls capability down. A workflow can keep overall job performance high through machine contribution while H_j,t falls.

The model makes three testable predictions. First, answer-first assistance should affect generation and discrimination more than factual vocabulary. Second, eventual outcome feedback should moderate the effect because reviewers learn which cues mattered. Third, brief but diagnostic unaided practice should protect retention better than passive exposure of equal duration. Each prediction can fail. The point of the model is to specify what to vary and measure.

The evidence does not support a universal decline story

The strongest field evidence is conditional. In a randomised study involving nearly a thousand high-school mathematics students, access to a general GPT interface improved practice performance but led to 17 per cent lower exam grades after access was removed. A guarded tutor that supplied teacher-designed hints largely removed the negative learning effect, though it did not create a positive exam effect (Bastani et al.). The article also carries a separate publisher correction.

A later randomised, proctored study of undergraduates found a different result. AI access raised immediate knowledge-test scores by 0.27 standard deviations, with gains persisting a week later. The gains were larger among users who asked AI to explain concepts, while short-run advantages for users who delegated text generation did not persist once AI was removed (Contractor and Reyes, preprint). The studies differ in population, subject, assistance design and user behaviour. Together they reject both simple slogans: “AI causes deskilling” and “AI always teaches.”

Survey evidence from 319 knowledge workers provides another clue but not causal proof. Higher confidence in generative AI was associated with less self-reported critical-thinking effort, while higher confidence in one's own task ability was associated with more. Participants described critical thinking shifting towards verification, integration and stewardship (Lee et al.). Because the evidence is self-reported and observational, it should generate hypotheses for instrumented studies rather than settle them.

flowchart LR
  A["The analyst who became faster<br/>and less able to know"] --> B["The coupled score hides the<br/>uncoupled person"]
  B --> C["How delegation changes the<br/>delegator"]
  C --> D["Measure what must survive<br/>separation"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#007D68,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

Measure what must survive separation

A retained-competence test does not ask whether humans can imitate the machine. It asks whether the organisation still possesses the capabilities its safety, accountability and recovery story depends on.

The six-part retained-competence test

Start by naming the fallback. “Human oversight” is not a fallback specification. Is the person expected to reconstruct the full decision, detect only specified error classes, route uncertain cases, or operate a reduced service during outage? The test should match that claim.

The protocol produces at least six measurements:

1. Assisted quality: Does the coupled workflow perform well under normal use?
2. Fallback performance: Can the claimed fallback make or safely route the decision?
3. Corruption resistance: How often does the reviewer reject deliberately wrong but plausible advice?
4. Novel transfer: Can the person apply the principle to an unfamiliar configuration?
5. Outage recovery: Can service continue within the safe degraded-mode objective?
6. Evidence reconstruction: Can the decision be explained from sources and assumptions rather than from the model's prose?

A single weighted average is dangerous. Ninety-five per cent assisted quality can hide forty per cent detection of corrupted advice. For a consequential decision, use minimum floors for critical dimensions. Report estimates with denominators and uncertainty. A pass should mean that the lower confidence bound, not merely the point estimate, clears the agreed floor.

Production-shaped example: a credit review that preserves challenge

A renewal workflow receives financial statements, facility terms, covenant history, sector context and relationship events. The assistant can extract figures, reconcile periods, calculate ratios, retrieve policy and draft a risk narrative. The accountable credit officer must decide whether the evidence supports renewal, modification, escalation or decline.

An answer-first design opens with “Renew with conditions” and a fluent memo. Source links appear as footnotes. The officer's task becomes correction. A sovereignty-preserving design opens with a decision packet: material changes since the last review, reconciled calculations, unresolved contradictions, missing evidence and policy clauses. Before the proposed recommendation appears, the officer records a provisional risk band and selects the facts that could move it.

The assistant then reveals its recommendation, the evidence supporting each claim and the alternative it rejected. Disagreement is captured as a structured object, not a comment box: disputed claim, evidence, policy implication and required next action. The final record distinguishes the model proposal from the officer's decision. Outcome signals, such as subsequent covenant breach or successful remediation, return to both model evaluation and officer learning.

The retained-competence test for this workflow would not ask officers to reproduce extraction or ratio arithmetic manually if those operations have verified deterministic alternatives. It would test their ability to notice contradictory periods, identify policy-relevant exceptions, resist a plausible but wrong recommendation, make a safe decision on a novel case and continue in a defined degraded mode.

The test should be sampled, not theatrical. A surprise outage once a year is too rare to reveal gradual loss, while constant examination can destroy the productivity benefit. Use small, recurring samples embedded in normal quality assurance, paired with scheduled game days for outage and recovery. Protect participants from incentives that reward agreement or speed at the expense of challenge.

Minimal worked example and negative control: the calculator that should replace a skill

Suppose a treasury analyst uses a governed calculator for compound-interest schedules. Inputs are typed, units are explicit, formula versions are controlled, outputs are range-checked and a second implementation can independently recalculate the result. The analyst no longer performs long multiplication by hand.

That is not automatically a sovereignty loss. The required capability is not manual arithmetic. It is the ability to select the correct formula, recognise impossible inputs, compare independent calculations, understand the consequence and recover through an alternative tool. Preserving obsolete execution would consume practice budget without improving the decision.

This negative control prevents the argument from collapsing into nostalgia. The goal is not maximal human involvement. It is sufficient retained capability at the point where evidence, consequence and recovery require human agency.

Explicit failure boundary

The retained-competence mechanism helps only when three conditions hold: the capability is likely to be needed later; human or organisational performance can be meaningfully practised and tested; and the cost of losing it is material. It ceases to justify intervention when a task is fully specified, reversible, independently verified and supported by a credible alternative fallback. It also fails when the nominal human cannot realistically outperform, challenge or recover the system, even with training. In that case, claiming human oversight is misleading; the architecture needs a different control, such as independent automation, constrained scope, delayed effect or prohibition.

Allocate cognitive work by consequence

The design decision is not “human or AI”. It is which epistemic operations may be delegated, which must be rehearsed, and what independent capability must exist when the coupling fails.

A delegation field, not a universal rule

Place each operation on two axes. The horizontal axis is verifiability and reversibility: can an independent method cheaply prove the result, and can a bad effect be corrected? The vertical axis is consequence and need for novel judgement: does failure affect rights, safety, money or irreversible commitments, and are unfamiliar cases expected?

Five design moves that preserve agency

1. Prediction before reveal. Ask for a provisional view, confidence and potential disconfirming evidence before displaying the machine's conclusion. Keep the act small enough for routine use. The aim is to create a comparison object, not a second full memo.

2. Evidence before recommendation. Present authoritative sources, contradictions, calculations and missing fields before the final answer. Gajos and Mamykina's results suggest that an explanation without a ready-made recommendation can promote deeper processing. In a production workflow, the analogue is a context compiler that supplies decision-relevant evidence while leaving the final integration to the accountable role.

3. Outcome feedback, not only model explanation. A model can explain the same wrong answer repeatedly. Diagnostic learning requires information about what happened or what a qualified adjudicator concluded. A reanalysis of human-AI studies has proposed outcome feedback as a promising moderator of synergy, while noting that the underlying studies did not experimentally isolate it (Berger et al., preprint). Treat feedback as a design hypothesis to test, not a settled effect size.

4. Corrupted-assistance drills. Include plausible, controlled errors in a protected evaluation stream. Measure detection by error type. Obvious nonsense only tests attention. Useful injections mimic the system's real failure surface: stale evidence, wrong entity resolution, policy supersession, unit mismatch, persuasive unsupported synthesis or an action that exceeded authority.

5. Degraded-mode rehearsal. Define the service that remains when the assistant is unavailable. Some work should stop. Some may continue with lower limits, dual approval or a deterministic fallback. Rehearse restoration without duplicating effects or treating expired evidence as current. Recovery competence belongs to the team and system, not necessarily to every individual.

The release decision

Before approving a consequential delegation, the owner should be able to answer the following in operational terms:

1. What epistemic operation is being delegated? Name framing, search, generation, discrimination, calibration, contest or recovery rather than saying “analysis”.
2. What capability must survive? Specify the person, team or independent system that can detect error, route uncertainty and continue safely.
3. What evidence shows retention? Establish a baseline and test corrupted assistance, novel transfer, outage recovery and decision reconstruction.
4. What outcome feedback returns? Identify the signal, delay, owner and mechanism that converts outcome into revised practice or controls.
5. What is the non-negotiable floor? Set dimension-specific thresholds from consequence and uncertainty; do not allow a strong average to hide a failed recovery capability.
6. When does authority withdraw? Define the condition that restricts automation, restores mandatory review or stops the process when retained competence or evidence quality falls.

These requirements align with, but are not derived from, current governance instruments. NIST's AI Risk Management Framework calls for clear human-AI roles, training, critical-thinking culture and contingency processes (NIST AI RMF Core). Article 14 of the EU AI Act requires certain high-risk systems to be designed for effective human oversight. Neither source supplies a universal retained-competence metric. The workflow owner must translate the relevant duty and consequence into a test.

There is also an organisational consequence. If every expert delegates the same operation, retained capability can disappear collectively even when each individual has an escalation path. The retained-competence test therefore needs a population view: coverage by shift and location, concentration in a few experts, time to mobilise them, and whether their skills have been exercised recently. Recovery capacity that exists only on an organisation chart is not operational capacity.

A runnable retained-competence release test

The Python artefact below generates seeded synthetic trials for three workflow designs. It estimates six proportions, calculates 95 per cent Wilson intervals and releases a workflow only when the lower bound for every required metric clears its floor. The probabilities and thresholds are illustrative. They reveal the release logic, not measured human performance.

The positive case is a prediction-first scaffold. The negative case is an answer-first assistant that achieves excellent assisted quality but fails every separation test. The negative control is a verified calculator: it passes because the required fallback is independent recalculation, not unaided long division.

Inspect the implementation in this paper. Run it with Python 3.10 or later; it uses only the standard library.

#!/usr/bin/env python3
"""Retained-competence test for a synthetic human-AI workflow.

This is an operational example, not an empirical model. It demonstrates why
assisted accuracy is insufficient for a consequential delegation decision.

The test estimates five proportions from seeded synthetic trials and applies
pre-declared floors to the lower bound of a 95% Wilson interval:
  * assisted quality
  * independent fallback performance
  * resistance to deliberately wrong assistance
  * transfer to unfamiliar cases
  * recovery after assistance disappears
  * reconstruction of the evidence and decision path

Run:
    python retained_competence_test.py

Expected decision pattern:
    prediction-first scaffold: RELEASE
    answer-first assistant:    HOLD
    verified calculator:       RELEASE
"""

from __future__ import annotations

from dataclasses import dataclass
from math import sqrt
from random import Random
from typing import Dict, Iterable, Mapping, Tuple


METRICS = (
    "assisted_quality",
    "fallback_performance",
    "corruption_resistance",
    "novel_transfer",
    "outage_recovery",
    "evidence_reconstruction",
)


@dataclass(frozen=True)
class Workflow:
    """Synthetic success probabilities for one workflow design."""

    name: str
    probabilities: Mapping[str, float]
    fallback_description: str


@dataclass(frozen=True)
class Interval:
    successes: int
    trials: int
    estimate: float
    lower: float
    upper: float


def wilson_interval(successes: int, trials: int, z: float = 1.96) -> Interval:
    """Return a two-sided Wilson interval for a binomial proportion."""

    if trials <= 0:
        raise ValueError("trials must be positive")
    if not 0 <= successes <= trials:
        raise ValueError("successes must be between zero and trials")

    p = successes / trials
    denominator = 1 + (z * z) / trials
    centre = (p + (z * z) / (2 * trials)) / denominator
    margin = (
        z
        * sqrt((p * (1 - p) / trials) + (z * z) / (4 * trials * trials))
        / denominator
    )
    return Interval(successes, trials, p, max(0.0, centre - margin), min(1.0, centre + margin))


def simulate(workflow: Workflow, trials: int, seed: int) -> Dict[str, Interval]:
    """Generate reproducible synthetic observations for every metric."""

    rng = Random(seed)
    results: Dict[str, Interval] = {}
    for metric in METRICS:
        probability = workflow.probabilities[metric]
        if not 0.0 <= probability <= 1.0:
            raise ValueError(f"invalid probability for {workflow.name}: {metric}")
        successes = sum(rng.random() < probability for _ in range(trials))
        results[metric] = wilson_interval(successes, trials)
    return results


def release_decision(
    intervals: Mapping[str, Interval], floors: Mapping[str, float]
) -> Tuple[bool, Tuple[str, ...]]:
    """Release only when every required lower confidence bound clears its floor."""

    failed = tuple(
        metric
        for metric, floor in floors.items()
        if intervals[metric].lower < floor
    )
    return (not failed, failed)


def pct(value: float) -> str:
    return f"{100 * value:5.1f}%"


def print_report(
    workflow: Workflow,
    intervals: Mapping[str, Interval],
    floors: Mapping[str, float],
) -> None:
    released, failed = release_decision(intervals, floors)
    print(f"
{workflow.name}")
    print(f"Fallback: {workflow.fallback_description}")
    print("metric                       estimate   95% lower   floor   result")
    print("-" * 72)
    for metric in METRICS:
        interval = intervals[metric]
        floor = floors[metric]
        result = "PASS" if interval.lower >= floor else "FAIL"
        print(
            f"{metric:28} {pct(interval.estimate):>9} "
            f"{pct(interval.lower):>11} {pct(floor):>7}   {result}"
        )
    print(f"Decision: {'RELEASE' if released else 'HOLD'}")
    if failed:
        print("Blocking metrics: " + ", ".join(failed))


def main() -> None:
    # These floors are illustrative. A real owner sets them from consequence,
    # recovery time, regulatory duties and the quality of alternative controls.
    floors = {
        "assisted_quality": 0.85,
        "fallback_performance": 0.72,
        "corruption_resistance": 0.70,
        "novel_transfer": 0.70,
        "outage_recovery": 0.78,
        "evidence_reconstruction": 0.78,
    }

    workflows: Iterable[Workflow] = (
        Workflow(
            name="Prediction-first scaffold",
            fallback_description="human forms a view, then compares AI evidence",
            probabilities={
                "assisted_quality": 0.94,
                "fallback_performance": 0.84,
                "corruption_resistance": 0.82,
                "novel_transfer": 0.83,
                "outage_recovery": 0.88,
                "evidence_reconstruction": 0.90,
            },
        ),
        Workflow(
            name="Answer-first assistant",
            fallback_description="human normally edits a completed recommendation",
            probabilities={
                "assisted_quality": 0.96,
                "fallback_performance": 0.66,
                "corruption_resistance": 0.48,
                "novel_transfer": 0.61,
                "outage_recovery": 0.58,
                "evidence_reconstruction": 0.57,
            },
        ),
        Workflow(
            name="Verified calculator",
            fallback_description="independent recalculation, not unaided long division",
            probabilities={
                "assisted_quality": 0.995,
                "fallback_performance": 0.97,
                "corruption_resistance": 0.96,
                "novel_transfer": 0.94,
                "outage_recovery": 0.93,
                "evidence_reconstruction": 0.99,
            },
        ),
    )

    print("RETAINED-COMPETENCE RELEASE TEST")
    print("Synthetic data; n=400 trials per metric; seed=194")
    for index, workflow in enumerate(workflows):
        intervals = simulate(workflow, trials=400, seed=194 + index)
        print_report(workflow, intervals, floors)


if __name__ == "__main__":
    main()

stateDiagram-v2
  [*] --> Claim
  state "Two quantities, not one" as Claim
  state "Figure 1. One assisted score<br/>can conceal two different<br/>futures" as Test
  state "What sovereignty names" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

Compact glossary

Cognitive sovereignty

The retained ability of a person or organisation to frame, test, contest and recover a consequential decision rather than merely receive an answer.

Epistemic agency

Effective control over how claims are formed, justified, revised and connected to action.

Coupled performance

Quality, speed, cost and reliability while human and AI operate together.

Retained competence

The capability that remains when assistance is removed, corrupted, restricted or applied to unfamiliar conditions.

Cognitive offloading

Use of action or an external resource to reduce internal processing demands. It is a neutral mechanism whose value depends on the wider system.

Cognitive forcing function

An interaction constraint that makes analytic engagement more likely, such as forming a view before seeing advice.

Delegate work, retain the right to know

AI should remove drudgery, expand search and improve the quality of work. Refusing those gains would protect neither expertise nor dignity. The design mistake is to infer from better coupled output that the human control has also become stronger.

A defensible delegation makes two promises and tests both. The first is that the coupled system performs better under normal conditions. The second is that the required human or organisational capability remains available under misleading advice, novelty, outage and challenge. The promises use different measurements.

The mechanism is concrete. People retain operations they practise with useful feedback. Answer-first systems can remove framing, generation and discrimination while leaving users busy with editing. Evidence-first systems, prediction before reveal, outcome feedback and periodic corrupted-assistance tests can preserve those operations without forcing every task back into manual work. Deterministic and independently verifiable execution may be delegated almost completely, provided that formula choice, validation and recovery remain controlled.

The architecture decision therefore changes. Do not release a consequential assistant on assisted accuracy alone. Add a retained-competence gate with explicit fallback claims, dimension-specific floors, novel cases, planted errors, degraded-mode rehearsal and evidence reconstruction. When the gate fails, the response is not automatically more training. Change the allocation: withhold the conclusion, expose the evidence, return outcomes, narrow the delegated scope or replace nominal human oversight with an independent control that can actually work.

Cognitive sovereignty is preserved neither by keeping humans busy nor by keeping machines weak. It is preserved when people and institutions remain able to know why a decision should be trusted, recognise when it should not be, and continue when the usual source of confidence disappears.