Where did the result happen?

Computing has repeatedly moved the boundary of a useful explanation. In 1960, J. C. R. Licklider distinguished close human-computer symbiosis from both mechanical extension and full automation. His proposed partnership assigned goals, hypotheses, criteria and evaluation to people, while machines handled routinable work supporting formulation and decision. The important move was not to call the computer human. It was to ask whether the partnership performed intellectual operations that neither member could perform as effectively alone.[1]

Distributed-cognition research made the unit-of-analysis question empirical. Edwin Hutchins studied ship navigation and found that the computational organisation of the bridge could not be recovered by inventorying one navigator's mental contents. Bearings, charts, speech, instruments, ranks and checking practices formed a socially distributed process. He therefore treated the navigation team as a cognitive and computational system, while still recognising that its human components could not be described exhaustively in computational terms.[2]

Clark and Chalmers pushed the philosophical boundary further. Their rotation-button example compares mental rotation, physical on-screen rotation and an imagined internal implant. When the external operation plays the same active role in the problem-solving loop, they argue that skin and skull alone do not justify withholding cognitive status. Their stronger formulation describes a two-way interaction in which all components play an active causal role and jointly govern behaviour.[3]

These positions are often compressed into a slogan: cognition is outside the head. That compression loses three different claims. First, an external component may cause better performance. Second, the coupled system may be the most economical level at which to explain a task trajectory. Third, the external component may partly constitute cognition or mind. Evidence for the first does not automatically establish the second, and neither settles the third.

Adams and Aizawa's coupling-constitution objection targets precisely this slide. A pencil is causally involved when someone calculates on paper, but causal involvement alone cannot make every coupled object a thinking part. Without a discriminating criterion, cognition threatens to expand across every dependency in the environment.[4] This paper accepts the objection as an experimental design requirement: do not infer a joint unit from mere connection.

A task-level unit, not a new person

The practical term used here is task-level cognitive unit: the smallest bounded system whose internal interactions are required to predict and reproduce a defined performance. It is an attribution rule for experiments and architecture. It does not imply that the unit has one consciousness, one welfare interest, one identity or one legal personality. Those would require different arguments and evidence.

Three tests keep the term disciplined. The replacement test asks whether one component can be replaced by a frozen output without changing performance. The intervention test changes a coupling variable while holding participant competence and raw inputs fixed. The resource test compares the dyad with alternatives given equivalent time, information, attempts and number of judgements. A wider boundary earns explanatory status only when it survives all three.

The boundary can legitimately change with the question. A neuroscientist studying fatigue may need the individual brain. An interface researcher studying interruption may need the person plus display. An operations researcher explaining a missed deadline may need the queue, policy and team. There is no contradiction in using different boundaries, provided each boundary is tied to a specific outcome and intervention. The mistake is to choose the widest, most impressive boundary first and then look for evidence that fits it.

Four signatures make the dyad boundary more plausible. Recurrent dependence means the exchange continues across several state changes rather than ending after one recommendation. Transformational reciprocity means each party can alter the kind of work the other performs, not merely its final choice. Selective relevance means only some external components enter the explanation: the evidence workspace may be constitutive for this task while the network cable remains enabling infrastructure. Counterfactual necessity means replacing the relation with a simpler channel changes the trajectory in a predictable direction.

Reliable availability helps, but availability by itself is insufficient. A calculator may be permanently at hand and still function as a detachable operation. Conversely, a short-lived crisis team can become the right unit for one mission if its tightly organised interactions generate the relevant competence. Duration, proximity and anthropomorphic interface cues are poor substitutes for causal evidence.

flowchart TD
  A["The route that neither side<br/>could choose alone"] --> B["Where did the result happen?"]
  B --> C["Complementarity is potential,<br/>coupling is mechanism"]
  C --> D["An experiment that can reject<br/>the dyad"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#5B5CF6,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

Complementarity is potential, coupling is mechanism

Human and machine competence is rarely distributed as “judgement versus calculation” in the abstract. It is jagged. A model may be strong on repeated visual patterns, exhaustive search or statistical regularities, yet weak when evidence is missing, labels have shifted or a local convention changes the meaning of a field. A person may notice contextual exceptions and normative conflict, yet miss low-salience correlations or tire across thousands of cases. Complementarity exists when these competence surfaces differ in a usable way.

Different strengths are not enough. Two specialists can still form a poor team if they cannot tell who should lead, exchange decision-sufficient evidence, reveal uncertainty, challenge each other or maintain a common view of the task. Klein and colleagues described effective human-agent teamwork in terms including mutual predictability, directability, goal negotiation, common ground and continuing investment in coordination. They also warned that coordination has a cost and can break down even when each participant is locally reasonable.[5]

A compact causal model is useful:

Here G is the task-level gain over the strongest matched alternative. D is useful diversity in where human and machine errors occur, rather than demographic or stylistic diversity. F is coupling fidelity: the probability that relevant evidence reaches the right participant in time and changes the next step appropriately. K is coordination cost, including delay, attention, translation, duplicated work and new failure modes. The expression is a design heuristic, not an empirical law. Raising diversity does nothing when the interface cannot route cases, and perfect communication cannot create complementarity when both parties fail on the same instances.

Error diversity must be measured at the level at which roles can be assigned. It is not useful to know that humans and machines have different average accuracies if the system cannot recognise, before the answer is known, which competence region a case occupies. A routing feature may be case type, evidence quality, novelty, consequence or a detected disagreement. If that feature is unavailable or unstable, apparent complementarity in retrospective analysis cannot be converted into prospective performance.

The shared task state is the hinge of reciprocal work. A chat transcript is only a history of utterances. A decision-sufficient state also records the current hypothesis, authoritative evidence, unresolved conflicts, constraints, ownership and what would falsify the proposal. When the human corrects an entity or adds a constraint, the machine should reason over the changed state rather than merely acknowledge the message. When the machine finds a contradiction, the human should see which premise changed and what alternatives remain.

Reciprocity does not require equal capability or equal conversational turns. It requires bidirectional causal influence. A machine may perform thousands of calculations for each human intervention, while one human challenge redirects the entire search. A person may retain final judgement while the machine decides which missing evidence to request. Symmetry of status is unnecessary; sensitivity to each other's evolving state is essential.

Thought experiment one: the frozen oracle and the live cartographer

Give two coordinators the same machine-generated route recommendation. The first receives a signed report containing routes, confidence and cited evidence. The report is frozen. The second works with a live system that can answer challenges, update the road graph and expose the consequences of a newly asserted constraint. At time zero both coordinators see identical content.

Now introduce one change: the bridge inspection notice. If the frozen report plus human correction performs as well as the live exchange, then the machine's contribution may be informational rather than interactively constitutive. If the live pair performs better because the human's challenge changes machine search, whose new conflicts change human judgement, the reciprocal loop has causal force. Only one feature varied: whether the partner can update in response.

Thought experiment two: scramble the relation, keep the members

Suppose a review system routes context-heavy cases to a human and pattern-heavy cases to a model. Keep every human answer, model answer, confidence score and case exactly the same, but scramble the domain tag used for routing on half the cases. No participant becomes less capable. Only the relation between competence and task state is damaged.

If performance does not move, the routing story was decorative. The same gain could be attributed to confidence selection, averaging or the dominant member. If performance falls in proportion to the scramble, the coupling variable has explanatory value. This intervention avoids the common mistake of removing the machine entirely, which changes both competence and coordination at once.

A minimal worked example

Consider eight synthetic binary cases. The human is usually right on context-sensitive cases; the machine is usually right on pattern cases. A live protocol assigns a default owner by domain and permits a challenge when the non-owner has materially stronger evidence. The example is deliberately small enough to inspect.

The human is correct on four cases, the machine on five and the live role map on seven. That is not yet proof of a human-machine unit. The role map may have been chosen after inspecting the truth, and the dyad received two judgements where the solo conditions received one. The example reveals the mechanism, while the next section supplies the controls.

An experiment that can reject the dyad

A defensible experiment begins with a task distribution, a utility function and a declared resource budget. Accuracy may be suitable for reversible binary classification. A clinical, financial or operational task may instead require a vector containing calibrated loss, delay, review burden, unequal harm and recovery cost. Whatever utility is chosen, the same definition must be applied across conditions.

Run at least seven conditions. Human-only and machine-only establish component performance. A two-human pair and two-machine pair control for an extra judgement or extra sampling. A static human-machine hand-off tests whether independent outputs and confidence are sufficient. The interactive dyad uses the proposed reciprocal protocol. Finally, a coupling-perturbed dyad keeps participants and outputs available but corrupts one predeclared coordination signal, such as case routing, evidence freshness or turn order.

Three quantities, one claim

Let U(x) be the predeclared utility of condition x. Higher values are better. Define:

HH and MM are resource-matched human-human and machine-machine pairs. HMlive is the interactive dyad, HMstatic the frozen hand-off and HMperturbed the targeted intervention. Before collecting results, choose a practically meaningful margin δ. Attribute task performance to the dyad only when the lower uncertainty bound for S, C and P exceeds its declared margin, and when cost, safety and distributional harm remain acceptable. A positive point estimate is not enough.

Pre-register the relation, not just the score

Define the competence map and coupling protocol on a calibration set, then lock them before evaluation. Otherwise the experiment can assign every observed success to whichever member happened to be right. Pre-registration should specify the unit of randomisation, exclusion rules, stopping rule, practical margins, perturbation strength and how disagreements are resolved. It should also name observations that would weaken the thesis, including a static hand-off matching the live condition or a perturbation leaving performance unchanged.

Match resources that can plausibly explain the result. Equal wall-clock time may be unfair when one condition receives unlimited machine sampling; equal numbers of answers may be unfair when one condition has richer evidence. Report at least attempts, tokens or compute, human minutes, information access and number of independent judgements. If the live dyad receives more of any resource, estimate the marginal value of that resource in a control condition.

Uncertainty must respect the data-generating process. Repeated cases from the same participant are not independent people, and multiple outputs from the same model configuration are not independent systems. Analyse at the appropriate participant, case and session levels, and report variation across task regions rather than only one pooled mean. A useful result should survive new participants, fresh cases and at least one alternate model or interface implementation.

Outcome utility is not the only dependent variable. Record calibration, disagreement resolution, review time, evidence inspected, correction direction, recovery after error and post-task unaided performance. These measures reveal whether apparent synergy comes from genuine error correction, blind acceptance, added labour or temporary transfer of skill. They also expose a dyad that improves today's answer while degrading tomorrow's human capability.

This conjunction is intentionally demanding. S prevents a second judgement from masquerading as mixed intelligence. C prevents offline averaging from masquerading as interaction. P prevents a persuasive process story from surviving when its supposed causal variable does nothing. A real dyad claim must be able to fail while both members remain individually competent.

The executable dyad experiment

The accompanying Python program uses public synthetic data and the standard library only. Cases belong to one of two domains. In the positive scenario, the human is strong on contextual cases and the machine on pattern cases. Same-type errors are correlated, confidence is imperfect and the live role map can be challenged. The perturbation flips the domain signal on half the cases while preserving the people, model, raw predictions and confidence scores.

In the negative control, the machine dominates both domains. A sensible role map therefore routes both to the machine. There is no useful relation for the perturbation to damage. This matters because a test that always “discovers” joint intelligence is not a test.

#!/usr/bin/env python3
"""Synthetic dyad experiment for Paper 193.

The experiment distinguishes three claims:
1. augmentation: a human using a machine beats the human alone;
2. resource-matched synergy: an interactive human-machine dyad beats both
   a two-human and a two-machine alternative given the same number of judgements;
3. interaction dependence: the live dyad beats a frozen hand-off and loses its
   advantage when a task-routing signal in the coupling is perturbed.

No external packages or private data are required.
"""

from __future__ import annotations

from dataclasses import dataclass
from random import Random
from statistics import mean
from typing import Dict, Iterable, List, Literal, Mapping, Tuple

Label = Literal[0, 1]
Domain = Literal["context", "pattern"]
Member = Literal["human", "machine"]


@dataclass(frozen=True)
class AgentProfile:
    """Accuracy, confidence behaviour and same-type error dependence."""

    context_accuracy: float
    pattern_accuracy: float
    confidence_when_correct: float
    confidence_when_wrong: float
    same_type_dependence: float

    def accuracy(self, domain: Domain) -> float:
        return self.context_accuracy if domain == "context" else self.pattern_accuracy


@dataclass(frozen=True)
class Trial:
    truth: Label
    domain: Domain
    human_1: Label
    human_2: Label
    machine_1: Label
    machine_2: Label
    human_1_confidence: float
    human_2_confidence: float
    machine_1_confidence: float
    machine_2_confidence: float


def confidence(rng: Random, correct: bool, profile: AgentProfile) -> float:
    """Return a deliberately imperfect confidence score in [0.5, 0.99]."""
    centre = profile.confidence_when_correct if correct else profile.confidence_when_wrong
    return min(0.99, max(0.50, centre + rng.uniform(-0.12, 0.12)))


def draw_pair(
    rng: Random,
    truth: Label,
    domain: Domain,
    profile: AgentProfile,
) -> Tuple[Label, Label, float, float]:
    """Draw two same-type judgements while preserving marginal accuracy.

    The second member copies the first member's correctness state with probability
    `same_type_dependence`; otherwise it receives an independent draw. This creates
    correlated errors without reducing either member's specified marginal accuracy.
    """
    accuracy = profile.accuracy(domain)
    first_correct = rng.random() < accuracy
    second_correct = (
        first_correct
        if rng.random() < profile.same_type_dependence
        else rng.random() < accuracy
    )

    first = truth if first_correct else 1 - truth
    second = truth if second_correct else 1 - truth
    return (
        first,
        second,
        confidence(rng, first_correct, profile),
        confidence(rng, second_correct, profile),
    )


def generate_trials(
    *,
    seed: int,
    n: int,
    human: AgentProfile,
    machine: AgentProfile,
) -> List[Trial]:
    rng = Random(seed)
    trials: List[Trial] = []

    for _ in range(n):
        truth: Label = 1 if rng.random() < 0.5 else 0
        domain: Domain = "context" if rng.random() < 0.5 else "pattern"
        h1, h2, hc1, hc2 = draw_pair(rng, truth, domain, human)
        m1, m2, mc1, mc2 = draw_pair(rng, truth, domain, machine)
        trials.append(
            Trial(
                truth=truth,
                domain=domain,
                human_1=h1,
                human_2=h2,
                machine_1=m1,
                machine_2=m2,
                human_1_confidence=hc1,
                human_2_confidence=hc2,
                machine_1_confidence=mc1,
                machine_2_confidence=mc2,
            )
        )
    return trials


def choose_by_confidence(
    first: Label,
    first_confidence: float,
    second: Label,
    second_confidence: float,
) -> Label:
    """Resolve two completed judgements without any further interaction."""
    return first if first_confidence >= second_confidence else second


def static_handoff(t: Trial) -> Label:
    """A one-way human-machine hand-off using completed answers and confidence."""
    return choose_by_confidence(
        t.human_1,
        t.human_1_confidence,
        t.machine_1,
        t.machine_1_confidence,
    )


def interactive_dyad(
    t: Trial,
    observed_domain: Domain,
    role_map: Mapping[Domain, Member],
) -> Label:
    """A live role map plus a confidence-based challenge rule.

    The predeclared role map names the default owner for each task domain. The
    non-owner can overturn the owner only when they disagree and are materially
    more confident. This represents a minimal reciprocal protocol, not a claim
    that confidence is reliable enough for real deployment.
    """
    owner = role_map[observed_domain]
    if owner == "human":
        owner_prediction, owner_confidence = t.human_1, t.human_1_confidence
        challenger_prediction, challenger_confidence = t.machine_1, t.machine_1_confidence
    else:
        owner_prediction, owner_confidence = t.machine_1, t.machine_1_confidence
        challenger_prediction, challenger_confidence = t.human_1, t.human_1_confidence

    if (
        challenger_prediction != owner_prediction
        and challenger_confidence > owner_confidence + 0.12
    ):
        return challenger_prediction
    return owner_prediction


def evaluate(
    trials: Iterable[Trial],
    *,
    role_map: Mapping[Domain, Member],
    perturb_probability: float,
    seed: int,
) -> Dict[str, float]:
    rng = Random(seed)
    results: Dict[str, List[int]] = {
        "human": [],
        "machine": [],
        "human_pair": [],
        "machine_pair": [],
        "static_hm": [],
        "interactive_hm": [],
        "broken_coupling": [],
    }

    for t in trials:
        human_pair = choose_by_confidence(
            t.human_1,
            t.human_1_confidence,
            t.human_2,
            t.human_2_confidence,
        )
        machine_pair = choose_by_confidence(
            t.machine_1,
            t.machine_1_confidence,
            t.machine_2,
            t.machine_2_confidence,
        )
        live = interactive_dyad(t, t.domain, role_map)

        observed_domain = t.domain
        if rng.random() < perturb_probability:
            observed_domain = "pattern" if t.domain == "context" else "context"
        broken = interactive_dyad(t, observed_domain, role_map)

        predictions = {
            "human": t.human_1,
            "machine": t.machine_1,
            "human_pair": human_pair,
            "machine_pair": machine_pair,
            "static_hm": static_handoff(t),
            "interactive_hm": live,
            "broken_coupling": broken,
        }
        for name, prediction in predictions.items():
            results[name].append(int(prediction == t.truth))

    return {name: mean(values) for name, values in results.items()}


def metrics(scores: Mapping[str, float]) -> Dict[str, float]:
    best_homogeneous = max(scores["human_pair"], scores["machine_pair"])
    return {
        "resource_matched_synergy": scores["interactive_hm"] - best_homogeneous,
        "interaction_gain": scores["interactive_hm"] - scores["static_hm"],
        "coupling_perturbation_loss": scores["interactive_hm"] - scores["broken_coupling"],
    }


def run_scenario(
    name: str,
    human: AgentProfile,
    machine: AgentProfile,
    role_map: Mapping[Domain, Member],
) -> Tuple[Dict[str, float], Dict[str, float]]:
    trials = generate_trials(seed=193, n=20_000, human=human, machine=machine)
    scores = evaluate(
        trials,
        role_map=role_map,
        perturb_probability=0.50,
        seed=1_931,
    )
    deltas = metrics(scores)

    print(f"\n{name}")
    print("-" * len(name))
    for key in (
        "human",
        "machine",
        "human_pair",
        "machine_pair",
        "static_hm",
        "interactive_hm",
        "broken_coupling",
    ):
        print(f"{key:27s} {scores[key]:.4f}")
    print(f"{'resource-matched synergy':27s} {deltas['resource_matched_synergy']:+.4f}")
    print(f"{'interaction gain':27s} {deltas['interaction_gain']:+.4f}")
    print(f"{'coupling perturbation loss':27s} {deltas['coupling_perturbation_loss']:+.4f}")
    return scores, deltas


def main() -> None:
    # Positive case: competence is genuinely complementary across two domains.
    positive_human = AgentProfile(0.91, 0.63, 0.74, 0.70, 0.55)
    positive_machine = AgentProfile(0.64, 0.92, 0.76, 0.71, 0.70)

    # Negative control: the machine dominates both domains. A sensible role map
    # therefore routes both domains to it, so perturbing the domain tag cannot help.
    negative_human = AgentProfile(0.72, 0.72, 0.74, 0.70, 0.55)
    negative_machine = AgentProfile(0.91, 0.91, 0.76, 0.71, 0.70)

    _, positive = run_scenario(
        "Positive case: complementary competence plus valid coupling",
        positive_human,
        positive_machine,
        {"context": "human", "pattern": "machine"},
    )
    _, negative = run_scenario(
        "Negative control: machine dominance without useful coupling",
        negative_human,
        negative_machine,
        {"context": "machine", "pattern": "machine"},
    )

    assert positive["resource_matched_synergy"] > 0.08
    assert positive["interaction_gain"] > 0.04
    assert positive["coupling_perturbation_loss"] > 0.07
    assert negative["resource_matched_synergy"] <= 0.01
    assert abs(negative["coupling_perturbation_loss"]) < 0.005
    print("\nAssertions passed: the positive case depends on coupling; the negative control does not.")


if __name__ == "__main__":
    main()

Positive case: complementary competence plus valid coupling
-----------------------------------------------------------
human                       0.7698
machine                     0.7776
human_pair                  0.7890
machine_pair                0.7963
static_hm                   0.8418
interactive_hm              0.9112
broken_coupling             0.8115
resource-matched synergy    +0.1149
interaction gain            +0.0694
coupling perturbation loss  +0.0997

Negative control: machine dominance without useful coupling
-----------------------------------------------------------
human                       0.7179
machine                     0.9080
human_pair                  0.7452
machine_pair                0.9180
static_hm                   0.8782
interactive_hm              0.9147
broken_coupling             0.9147
resource-matched synergy    -0.0033
interaction gain            +0.0364
coupling perturbation loss  +0.0000

Assertions passed: the positive case depends on coupling; the negative control does not.

What published evidence does and does not establish

The current evidence base makes a strict test necessary. A preregistered meta-analysis by Vaccaro, Almaatouq and Malone included 106 experiments and 370 effect sizes. Human-AI combinations substantially outperformed humans alone on average, yet performed worse than the better of human or AI alone. Decision tasks showed average losses, while creation tasks were more favourable.[6] “AI helped” is therefore a weak baseline, not evidence of strong synergy.

The result also warns against treating all collaboration as one intervention. Some studies show a recommendation before independent thought; others reveal it after an initial answer, permit dialogue, route cases, aggregate independent votes or ask AI to synthesise a disagreement. These mechanisms change error correlation, anchoring, effort and information flow in different ways. A pooled label such as “human-AI” can therefore conceal the very causal structure that an architecture decision needs.

• Published evidenceSteyvers and colleagues modelled human-machine classification and showed that hybrid performance depends on component accuracy, confidence and the correlation structure of errors. Different errors can create a complementarity window even when component accuracies differ.[7]
• Published limitationBansal and colleagues observed complementary improvements in several decision tasks, but adding explanations did not increase them. Explanations increased acceptance of AI recommendations whether those recommendations were right or wrong.[8]
• Published interventionBuçinca and colleagues found that cognitive-forcing interfaces reduced overreliance compared with simpler explanation designs in an experiment with 199 participants, while attracting worse subjective ratings. A coordination mechanism can improve error correction and still impose a usability cost.[9]
• Published counterexampleZöller and colleagues combined 40,762 physician differential diagnoses with outputs from five language models over 2,133 vignettes. Hybrid collectives outperformed individual and homogeneous collectives.[10] This is strong evidence for mixed-ensemble complementarity, but the independent outputs were pooled. It does not require a live dyadic loop.
• Published workflow resultA randomised trial with 70 clinicians used independent clinician and AI assessments followed by AI synthesis. Both AI-first and AI-second workflows improved accuracy over conventional resources.[11] The design demonstrates workflow augmentation; a claim of interaction-dependent cognition would still require static and perturbed controls.
• Published field boundaryA field experiment assigned 2,234 participants to human-human or human-AI advertising teams. Human-AI teams produced 50% more ads per worker and stronger text, while human-human teams produced stronger images and AI-assisted outputs were more homogeneous. The study did not include a human-alone condition, so it cannot isolate the machine's marginal contribution against that baseline.[12]

Methods that learn to complement or defer to humans are promising because they optimise team reward rather than isolated model accuracy. Wilder, Horvitz and Kamar trained models to target instances that were hard for humans, while Gao, Saar-Tsechansky and De-Arteaga learned robust deferral policies from divergent behaviour.[13][14] Yet routing is only one form of coupling. The attribution test still asks whether live reciprocal work adds value beyond learned allocation.

stateDiagram-v2
  [*] --> Claim
  state "A task-level unit, not a new<br/>person" as Claim
  state "Thought experiment one: the<br/>frozen oracle and the live<br/>cartographer" as Test
  state "Frozen oracle" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

Carry the right boundary into production

Imagine a commercial credit renewal. The system reconstructs financial history, calculates covenant headroom, retrieves policy clauses and proposes unresolved questions. The relationship manager knows that a one-off revenue drop follows a plant relocation and notices that the system has joined two similarly named legal entities. The model corrects the entity graph, recalculates exposure and points out that the manager's preferred concession conflicts with a recently effective policy limit. A reviewer then approves, rejects or requests evidence.

This worked scenario has the structure of a cognitive dyad: each participant's next reasoning state depends on the other's intervention. It does not follow that authority is shared. The model proposes and recalculates; the authorised person decides within policy; a deterministic service validates permissions and executes any downstream effect. Cognitive boundaries describe where task performance is generated. Authority boundaries describe who may commit the organisation.

Map the whole system without calling everything memory

The production unit should be described through ten separable concerns. This prevents a language model, protocol or shared workspace from silently inheriting roles it does not possess.

The shared case state is not a generic “memory”. It may contain current world state, episodic interaction history, enterprise knowledge, workflow state and an evidence ledger. These stores have different owners, temporal semantics and failure modes. Collapsing them conceals whether the human and machine are reasoning over the same reality or merely over compatible narratives.

The coupling attribution card

Use the following instrument before describing a system as a human-machine team, centaur, copilot partnership or extended intelligence. It is a release gate rather than a maturity score. A “no” on the causal gates means the dyad claim has not been earned; a “no” on the control gates means the design is not ready for consequential action.

Where the mechanism stops helping

The dyad is the wrong architecture when one component dominates across the relevant task distribution; errors are highly correlated; the task cannot be decomposed into observable competence regions; or feedback arrives too late to affect the next step. It also fails when the interface hides provenance, collapses uncertainty into one answer or overwhelms the human until “review” becomes ritual acceptance.

Irreversibility tightens the boundary. A fast reciprocal loop may improve diagnosis or planning yet remain unsuitable for direct execution when an incorrect effect cannot be recovered. In those settings, the cognitive unit may propose a decision while a separate authority kernel checks identity, purpose, permission, freshness, limits and confirmation. An effect receipt and independent readback then establish outcome. Protocol connection is not authorisation.

Release the relation in stages

Start in shadow mode. Record what the human and machine would have done independently, then replay the proposed coupling without changing live outcomes. This reveals error diversity and coordination cost before anchoring alters the human baseline. Next, run an assisted stage with explicit disagreement capture and no machine execution. Only after the causal gates and control gates hold should the system receive bounded, reversible actions.

Operate the coupling as a versioned component. Changes to the model, prompt, retrieval policy, interface, staffing, case mix or response-time target can alter D, F or K even when standalone model accuracy is stable. Monitor interaction-specific indicators: how often each member changes the other's proposal, whether corrections flow in both directions, unresolved-disagreement rate, evidence freshness at challenge time, and performance after the partner is unavailable.

A service-level objective for joint work should include more than latency. It may bound stale-state exposure, require acknowledgements for material challenges, cap the number of unresolved hand-offs and specify a fallback when shared state diverges. The fallback should reconstruct from authoritative evidence, not continue an accumulated narrative whose premises can no longer be verified.

Finally, performance can belong to the dyad while learning and liability remain asymmetric. The model may be replaced tomorrow; the person and organisation live with the result, preserve duties and face the downstream consequences. Periodic unaided cases, adversarial challenges and recovery drills test whether the person can still recognise a bad route and rebuild the decision when the machine disappears. Task-level extended intelligence is compatible with human dignity only when coupling increases judgement without making contestability or recovery dependent on unquestioned machine fluency.

Compact glossary

Augmentation

A human-machine condition beats the human alone, without necessarily beating the machine or a matched alternative.

Complementarity

Different competence or error structures create the possibility of a combined gain.

Coupling

A relation through which one participant's evolving state can change the other's next operation.

Dyad

The bounded human-machine pair plus the interaction channel and shared task state relevant to the experiment.

Resource-matched synergy

Performance above both homogeneous alternatives given comparable information, time, attempts and judgements.

Task-level cognitive unit

The smallest bounded system whose internal interactions are required to reproduce a defined performance.

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: The route that neither side could choose alone
  M->>E: A task-level unit, not a new person
  E-->>M: compare rival explanations
  E->>D: Measure the relation before naming the unit
  D-->>Q: revise scope or act

Measure the relation before naming the unit

The useful question is not whether a person used AI. Tools have always altered what people can perceive, remember, calculate and coordinate. The sharper question is whether the result depends on an organised relation that cannot be reduced to either member, an extra attempt or an offline merge of outputs.

Attribute performance to the human-machine unit only when resource-matched synergy, interaction gain and coupling sensitivity all clear predeclared thresholds. That decision changes experimental practice: include homogeneous pairs, freeze the hand-off and perturb the proposed mechanism. It changes architecture: build shared state, reciprocal challenge and role allocation only where they earn more than their coordination cost. It changes governance: keep identity, authority, action and outcome evidence outside the metaphor of a shared mind.

The result is deliberately modest. It does not prove that current machines understand as humans do, possess experience or become persons through use. It does establish a defensible operational boundary. That boundary can be revisited as tasks, participants and interfaces change; it is a tested model of one performance, not a permanent essence.

When the live relation carries causal weight, evaluate and engineer the relation. Treat state alignment, reciprocal challenge and recovery as first-class components. When it does not, choose the strongest simpler system and do not decorate assistance with the language of partnership. Scientific restraint and architectural simplicity point to the same decision.