The Constant and the Variable: An Ontological Evolution of Human–AI Interaction

A specification is not used directly; it is read by the system and turned into usable intent. We call this decoding. Whether decoding is reliable depends on how complete the specification is: a fuller specification leaves less to guess, a sparser one more. There is a level of completeness below which the system cannot reliably recover the intended meaning. We write h_min for this level, the decoding bar, and state the admissibility condition, as

A specification meets this condition when its amplitude reaches the bar. We call such a specification admissible: structurally complete enough to be reliably decoded, which is a property of the specification, not of how much effort or execution follows it. Two features of h_min matter. First, it is strictly positive. A specification with no content cannot be reliably decoded into any particular intent, so the bar sits above zero: some minimum of completeness is always required. Second, it is constant in our analysis. Because the decoding system is held fixed (§2), the level of completeness it requires does not change as the user’s environment changes. The bar is set by the system, and the system is what we hold still. Instruction-environment quality, which varies, does not move the bar; what it moves is the cost of reaching it.

This already fixes a structural floor. Because the bar is a positive constant, every admissible specification requires the user to supply at least h_min of amplitude, whatever the environment. The environment lowers what that amplitude costs; the amplitude itself stays required. What the user must supply for an admissible specification is therefore bounded below by a fixed amount that the environment does not remove.

An admissible specification requires amplitude at least h_min, and producing amplitude costs effort. The cheapest way to be admissible is to produce exactly h_min: since cost rises with amplitude, any specification above the bar costs more than one at the bar. We write c_min (i) ≔ c(h_min, i) for the cost of producing a specification at the bar in instruction-environment quality i. It is the least a user can spend and still be admissible, so we call it the entry cost.

Because h_min is constant, instruction-environment quality enters the entry cost only through the cost of producing that fixed amplitude. Evaluating the cost assumption ∂c/∂i < 0 at a = h_min gives ∂c_min/i < 0.

The entry cost falls as instruction-environment quality rises. The bar stays exactly where it is, while the cost of clearing it goes down. This is the precise content of the claim that a better environment makes admissibility cheaper: the standard is unchanged, and what improves is the effort required to meet it.

The same fact can be read from the user’s side. Fix any cost level c̅ that the environment can realize, that is, a level in the range of c(⋅, i), and ask how much amplitude that cost buys. Because cost rises strictly with amplitude at a fixed environment, the cost function is invertible in amplitude. For each environment, a given cost corresponds to a single amplitude the user can produce, the amplitude at which cost equals c̅. Write this as a((c̅, i). The function a(c̅, i) is the inverse of c(a, i) in its first argument; we keep the letter a because its value is an amplitude, but it is not the amplitude map a(x). Raising instruction-environment quality lowers the cost of every amplitude, so the amplitude that a fixed cost can reach goes up:

The two statements are one fact seen from two sides. Holding amplitude at the bar and asking for its cost gives ∂c_min/∂i < 0: the same admissible specification becomes cheaper. Holding cost fixed at c̅ and asking for its amplitude gives ∂a(c̅, i)/∂i > 0: the same outlay produces a more complete specification. In both readings, the bar is fixed and only the cost relation shifts; what moves is never the standard, only the cost that meeting it requires.

This is what it means, in this framework, for a better environment to widen participation. Admissibility is unchanged, so the set of specifications that count as admissible is the same in a rich environment and a poor one. What changes is that clearing the fixed bar costs less, so a user spending any given cost reaches it in a wider range of environments. Participation widens not because the standard drops, but because the cost of meeting it does.

Where amplitude a(x) measures the specification, the outcome is what the system produces from an admissible specification; §5.1 separates this from the bare output. We represent the outcome as a vector R in an evaluation space ℝ^d, and write ‖⋅‖ for the Euclidean norm and ⋅,⋅ for the inner product on ℝ^d. The coordinates of the evaluation space, and the units in which they are read, are fixed in advance and held fixed throughout. Representing the outcome as a vector, rather than a single number, is what lets us read two things off it separately: the direction it points and its magnitude on a given axis. How R is produced from the specification, through decoding and execution, is set out in Appendix B.1; here we need only that the outcome is a vector in ℝ^d.

An outcome is judged against a criterion that the user fixes before execution, not against the environment that produced it. From the specification x, a normative extraction map Γ builds this ex ante criterion,

Because i does not affect the aim or which features are at stake (§2), the criterion x* is immune to i. Γ reads the specification only through the aim and the features at stake, so its output inherits their independence of i. We record this as a named assumption, criterion invariance, rather than as a derived fact. The immunity is structural: if x* moved with i, the same environment would both set the standard and meet it. What i affects is the cost of reaching admissibility, and through that cost which specification the user can afford to write; it touches neither the decoding rule nor the criterion. The criterion is the user’s, fixed in advance. The outcome is read along two axes, carried by two subspaces of ℝ^d. The directional subspace T holds the dimensions the user takes to be at stake: what the outcome should be aiming at.

The quality subspace Q holds the non-directional standards the institution applies: how well-built the outcome must be, regardless of where it points. The two are orthogonal,

so direction and quality measure different things about R and cannot stand in for each other. This orthogonality is a design requirement on how evaluation is represented, not an empirical claim about existing schemes. The two subspaces need not span ℝ^d: components of an outcome outside both are read by no gate, and evaluation is deliberately confined to the declared and the institutional axes. The prior review of §5.2 is where this requirement on declarations is enforced. Let Π_T and Π_Q be the orthogonal projections of ℝ^d onto T and onto Q.

For any outcome R, then, Π_T (R) is its directional part and Π_Q (R) is its quality part. The user’s target direction is the criterion seen along the directional axis, normalized to unit length, t ≔ Π_T (x*)/‖Π_T (x*)‖, ‖ t ‖= 1, for Π_T (x*)≠0. We assume the user’s declaration carries a direction, so that Π_T (x*)≠0 holds and the target direction is well defined. Since x* is fixed in advance and free of i, so is t: the direction the user is aiming at is set before the outcome exists. Two thresholds complete the criterion. The user sets an alignment threshold ρ ∈ (0,1], how closely the outcome’s direction must match t. We take ρ to be strictly positive, because a declaration that tolerated orthogonal or opposed outcomes would not require the outcome to point toward the target at all, and the declaration is assumed to carry a direction. When the directional subspace is one-dimensional, every positive value of the alignment threshold yields the same admissible region: the outcomes whose directional component points along the target. The threshold then reduces to an orientation check. When the directional subspace has dimension at least two, we read the threshold as a graded tolerance. The institution sets a quality bar θ_Q > 0, how much quality magnitude the outcome must carry. The triple (T, t, ρ) is the user’s; the pair (Q, θ_Q) is the institution’s. The triple fixes when an outcome counts as pointing the right way. The outcome’s direction is Π_T (R)/‖Π_T (R)‖, and it points the right way when its alignment with t reaches ρ. We call the outcomes that meet this the directionally admissible region,

Membership in A_ρ is a question of direction alone: it asks where R points, not how good it is. Quality is the other axis, read off the quality part Π_Q (R). The coordinates of Q are set up by the institution so that each quality dimension is measured on a nonnegative scale, with larger values meaning better built; deficits appear as small magnitudes, not as negative ones. We record this as a named assumption, the nonnegative quality convention. Where direction compares an angle, quality is a matter of magnitude: how much Π_Q (R) carries on the institution’s standards, with larger meaning better-built. The institution fixes a level θ_Q this magnitude must reach,

so an outcome meets the quality standard when its quality magnitude clears θ_Q. More fully, the institution may judge quality not by this aggregate alone but also by a floor on each dimension of Q that it evaluates, with safety-critical dimensions carrying higher floors. A high aggregate then cannot offset a low value on any single dimension. The main text uses the aggregate bar throughout; Appendix C.2 states the general form.

Gate 1 is the admissibility condition of §3, named. A specification clears it when its amplitude reaches the decoding bar,

Gate 1 is checked on the specification, before any outcome exists. Below the bar the system does not fall silent: it still produces an output. The two words are kept apart deliberately: an output is what the system produces, an outcome is what stands to be evaluated. What is missing is standing, not production. We write what the later gates receive as

where R is the outcome of §4.1, now licensed: with the bar cleared, the specification is reliably decoded, and what the system produces stands as the admissible outcome the later gates read. ⊥ marks the opposite state. It does not name the output, and it is not a second kind of outcome for the later gates to judge. It records that no reliable decoding stands behind the output, so there is no R for the later gates to read. This is why Gate 1 is first not only in order but in standing: the later gates judge R, and below the bar there is no R to judge, whatever the output.

Remark (the bar and the form of the output). Gate 1 places its condition on the specification, so ⊥ does not track the form the output takes. Below the bar the system may ask for clarification, it may hedge, or it may return a polished and confident product. Consider a request to improve a document that says nothing about what counts as improvement. The system may ask what kind of improvement is wanted, or it may return a fluent revision. The two outputs look nothing alike, and both episodes stand at ⊥, because in both cases the specification left no intent to be reliably decoded. The polished case deserves emphasis. A confident output looks like an admissible outcome, but there is no decoded intent for it to be faithful to, so we cannot even ask whether it is faithful. Standing comes from decoding, not from appearance.

Gate 2 is checked on the outcome R, once Gate 1 holds. It asks whether the outcome points where the user declared. The outcome clears it when its direction lies in the directionally admissible region of §4.2,

Gate 2 decides membership, not quality: an outcome outside A_ρ is not a poor result to be weighed on its merits, it is not a result of the declared kind at all. Nor is an outcome outside A_ρ the state that ⊥ records. Directional failure presupposes that Gate 1 holds and an outcome R stands to be judged; ⊥ marks the prior state, in which nothing stood. In deciding membership, Gate 2 is constitutive. It fixes what counts as an evaluable outcome, rather than rating outcomes already taken to be evaluable.

Remark (governance layer). Gate 2 takes the user’s declaration (T, t, ρ) as given and asks only whether an outcome conforms to it, not whether the declaration is itself acceptable. A declaration can be well-formed and still conflict with the institution’s substantive commitments, such as non-discrimination, patient safety, or due process. Judging the declaration itself is the task of a governance layer that reviews (T, t, ρ) before the episode enters operation, in forms such as ethics review, regulatory authorization, and institutional oversight. This layer sits above the operating gates. The framework treats it as a structural precondition and does not formalize its internal operation.

Gate 3 is checked on the outcome, once Gate 2 holds. It asks whether the outcome, being of the declared kind, is well-built on the institution’s standards. The outcome clears it when its quality magnitude reaches the bar of §4.2,

Gate 3 decides sufficiency: an outcome in A_ρ that falls short of θ_Q is of the right kind but not good enough. This is the one gate that rates an outcome rather than admitting or excluding it. Because Gate 3 is asked only within A_ρ, an outcome that fails Gate 2 is never weighed against θ_Q: the quality question does not arise for a result that is not of the declared kind. The single bar θ_Q on the aggregate magnitude is the simplest case. In safety-critical settings the institution may strengthen Gate 3, either by reshaping the bar into a risk-adjusted form or by adding floors on individual quality dimensions. Appendix C develops both and shows that each keeps Gate 3 a scalar sufficiency test in the same position and ordering. In those variants the institution fixes further parameters before the episode, the risk operator Ω with its threshold and the dimension floors F_k; the pair (Q, θ_Q) of §4.2 is its baseline standard.

An episode is jointly admissible when the three conditions hold in order:

The order is not a convenience. Gate 1 is checked before any outcome exists; Gate 2 and Gate 3 are checked on the outcome, first its direction, then its quality. The gates do not loop back: clearing a later one never reopens an earlier one. They sit at two layers, Gate 1 on the specification and Gate 2 and Gate 3 on the outcome, and are not merged into one. The user’s (T, t, ρ) and the institution’s (Q,θ_Q) are fixed before execution begins; Gate 2 applies the first, Gate 3 the second; and the orthogonality T⊥Q keeps direction and quality from standing in for each other.

Through §5 the outcome R was a single fixed result. But the system can execute the same decoded intent at different magnitudes: more compute, more parallel attempts, longer runs, under a fixed execution protocol. We capture this with a single scalar, the execution scale S > 0, and from here write the outcome as R(S) to mark that it depends on S. Larger S means more execution applied to the same specification. The three conditions of §5 are unchanged in form; what changes is that the outcome they read now moves with S. How R(S) is produced from the specification and S is set out in Appendix B.1; here we need only how each gate responds as S grows.

Take the three gates in turn and ask how each responds as S grows. Gate 1 does not move. Its condition, a(x) ≥ h_min, is about the specification, and the specification is fixed before any execution begins. Scale acts on what the system does with the decoded intent, not on the specification itself, so no amount of S changes whether the bar is cleared. Gate 1 is settled before S enters.

Gate 2 does not move either, for a different reason. Its condition, R ∈ A_ρ, is about direction: whether the outcome points where the user declared. Scale produces more of an outcome, but more of it is not a direction for it. A larger S can make the outcome bigger without aiming it at t; an outcome pointed the wrong way stays misaimed no matter how large it grows. Direction is set by the user’s declaration (T, t, ρ), and execution does not supply it. Appendix B.3 states the quantitative form of this claim. Under the regularities of B.2, the Gate 2 verdict is independent of S outside a band around ρ whose width is set by the audited error bound (B.3).

Gate 3 is the one gate scale reaches. Its condition is on quality magnitude: whether the outcome is well-built on the institution’s standards. Magnitude is what execution adds. Applying more execution to the same decoded intent raises the quality the outcome carries, so the quantity Gate 3 measures, ‖Π_Q (R(S))‖, grows with S on the operating range of Appendix B.2, up to the audited relative error. An outcome that falls short at low scale can clear the bar at higher scale. One limit remains even here: scale lifts the magnitude only if the decoded intent carries a quality component to lift. If the decoded intent carries nothing on Q, more execution scales nothing, and Gate 3 stays unmet at every S.

§7.2 found a split: of the three gates, scale moves only Gate 3, and leaves Gate 1 and Gate 2 where they were. Two limits follow.

The first is on amplitude. Gate 1 holds before execution begins, and the bar h_min is a fixed positive constant. So, however large S grows, the user must still supply a specification that reaches h_min: scale does not lower the bar. There is always a minimum specification, and it is the user who supplies it. Growing execution does not relieve the user of it.

The second is on direction. Gate 2 holds or fails on where the outcome points, and scale adds magnitude, not direction. More execution makes the outcome larger, not more aligned; an outcome aimed where the user did not ask stays misaimed at every S. The direction is the user’s declaration (T, t, ρ), fixed before any execution. No matter how much execution is added, it cannot replace the direction the user set.

The two limits land in the same place. What scale cannot reach, the user must supply: the minimum specification at Gate 1, and the direction at Gate 2. Within the operating range of Appendix B.2, scale lifts quality magnitude, and it still leaves both of these with the user. This is the sense in which amplification does not remove the user’s responsibility but isolates it: as execution grows, the gates it cannot move are exactly the ones the user is answerable for. This step from structure to responsibility rests on one normative premise, stated openly: a party is answerable for what it alone sets and what no other part of the system can supply or revise. The framework adopts this premise rather than deriving it. Under it, the user is answerable for the declaration and the minimum specification, while the governance layer of §5.2 carries the distinct responsibility of testing the declaration before operation (§8.2, §9.2.2); responsibility for the declaration does not exhaust responsibility for the deployment. The quantitative form of the binding requirement, and how it behaves as S grows, is given in Appendix B.3.

This asymmetry has a close counterpart in alignment research, where added capability does not secure the intended objective: an agent can retain competence while pursuing the wrong goal, and stronger optimization can improve a proxy objective while the intended outcome worsens (Di Langosco et al., 2022; Pan et al., 2022). Those results concern learned or supplied objectives in reinforcement-learning settings. Here, by contrast, the direction is the user’s ex ante declaration in a single episode, and scale is execution magnitude applied to the decoded intent. Relocating the asymmetry to the human-AI episode, and making it structural through the gates, is what the present treatment adds.

As execution becomes automated, the scarce skill shifts upstream. What the system does with a specification is increasingly handled by the system; what still varies, and still decides the outcome, is the specification the user supplies. The skill that matters is therefore the construction of specifications. This means stating the goal, the constraints, and the success criteria completely enough to clear the decoding bar (Gate 1). It also means declaring the direction precisely enough that the outcome lands where the user intends (Gate 2). Two users of the same system can get very different results, not because one executes better, but because one supplies a specification that is more complete and more clearly aimed. For training in educational, professional, and public-service settings, the core skill is no longer fluent text production. It is, rather, the ability to say what the work is for, what must not happen, and how success will be judged.

The same threshold logic shapes who can participate. §6 showed that a better instruction-environment quality does not lower the fixed bar but lowers the entry cost of clearing it. Inclusive design works on that cost. Guided input fields, ambiguity checks, and standardized templates lower the entry cost c_min (i), so that a user spending a given amount reaches the bar in a larger share of episodes. This lever does not touch the standard. This is what separates inclusive design from dilutive design. Inclusive design lowers the cost a user faces in clearing the fixed bar. Dilutive design, by contrast, would weaken the standard itself by lowering the decoding bar at Gate 1, so that less complete specifications are admitted.

Consider two researchers using the same generative AI system to develop a research proposal for a human-subject study. One works at an institution that provides standardized Institutional Review Board (IRB) templates tailored to different categories of research, together with examples, checklists, and procedural guidance. The other works at an institution where the relevant information is available only through fragmented, less systematically organized materials. Suppose both face broadly similar IRB expectations; the difference lies only in instruction-environment quality i. At the institution with standardized templates, the researcher receives clearer guidance on formulating research questions, describing study procedures, specifying risks and benefits, and documenting safeguards. The proposal they can write at a given cost is more complete, that is, higher in amplitude a(x); equivalently, the decoding bar is reached at a lower entry cost c_min (i). At the institution relying on fragmented materials, the researcher must spend more to identify what information is required, locate relevant guidance, and determine how it should be expressed. As a result, the same decoding bar h_min is reached only at a higher cost.

In domains where errors carry serious consequences, such as healthcare, finance, employment, or public infrastructure, the gate structure points to one place. Gate 2 takes the user’s declaration (T, t, ρ) as given and checks conformity to it. By the asymmetry of §7, growing execution scale S cannot supply or correct direction. It only enlarges whatever the declaration admits. A badly set declaration therefore scales into large harm, and the failure is not performance below a threshold. It is the declaration itself being set wrongly, so that outcomes the institution should never accept count as exactly what was asked for. And because operation checks conformity to the declaration, nothing inside operation revises the declaration itself. Responsibility sits at the moment of declaration, and correction must come before operation, not during it.

That prior position is the governance layer of §5.2, and it functions as the precondition on which Gate 2 rests. Gate 2 can take (T, t, ρ) as given only because a layer above it has already judged that this declaration may enter operation at all. For the layer to bear that weight, the declaration must be documented, auditable, and stable, and the procedures that produce and revise it must themselves bear scrutiny.

Consider a company that brings a generative AI system into a personnel management project, screening and evaluating its workforce. Seeking to push out its older staff, the company declares a direction (T, t, ρ) that places age among the scored dimensions of T and weights t so that younger employees rank higher. The declaration makes discrimination the objective. Under the declaration, outcomes that disadvantage older employees are exactly what was asked for. An outcome conforming to it clears Gate 2, and by the asymmetry of §7 no execution scale turns that direction legitimate. What stops it sits above operation. The governance layer of §5.2 reviews the declared (T, t, ρ) before any episode runs, here through the company’s compliance and legal review under age discrimination law. The review examines which dimensions T includes, what weight t places on each, and how much room ρ leaves. Finding that the declaration targets a characteristic the law protects, the layer does not permit it to enter operation and returns it for revision. The filtering happens at the declaration, before any episode runs, which is the only place it can happen.

One might object that the system itself, tuned toward safe behavior, will soften or refuse the age-based ranking the declaration asks for. Such behavior changes what is produced, not what counts. The declaration is fixed before execution, so the system can shape the outcome R, but it cannot alter T, t, or ρ. The same declaration still targets the discriminatory outcomes; a softened or refused output may simply fail Gate 2 under it, and whatever does clear Gate 2 is credited as on target. Protection that depends on which point in A_ρ the system happens to produce is unstable across models, versions, and episodes. It is recorded nowhere in the declaration and, unless separately governed, answers to no prior review; it can supplement, but cannot replace, that review. The governance layer puts the protection where it can be reviewed: in the declaration itself.

The safeguard in high-stakes deployment is therefore joint. A well-set Gate 2 without an effective governance layer is fragile, since nothing inside the operation prevents the declaration from being set wrongly to begin with. A governance layer without Gate 2’s anchored declaration has nothing structural to review. Together they form the safeguard. Either alone is insufficient. The risk diagnosis above applies where the layer is absent, weak, or has failed, and the asymmetry of §7 offers no compensation for that failure. The framework treats the layer’s operation as a structural precondition and leaves the design of its review and accountability mechanisms to future work.

A recurring concern with abstract models of human-AI interaction is whether they describe anything that exists outside theory. The present framework is built to avoid that gap: its core objects correspond to institutional structures already in operation, and each correspondence seeds an independent line of research.

First, instruction-environment quality i is not a latent psychological variable but the degree to which the surrounding materials supports the user in writing a specification. These supports include templates, guided fields, examples, ambiguity checks, and standardized vocabularies. They are already deployed in clinical documentation, regulatory compliance, procurement, and annotation pipelines. Treating i as a structured institutional variable makes these design choices objects of formal study. And since an institution’s episodes carry a distribution of i, the F of §6, institutional design becomes a question with a definite shape. The open questions are which interventions shift F upward, and how far the shift travels into entry costs and participation.

Second, the decoding bar h_min formalizes a familiar but under-theorized boundary: the minimum completeness below which a specification is not usable, whatever the system then produces. In the framework the bar belongs to the decoding system and does not move with the environment. What varies across organizations is the cost of reaching it, c_min (i), borne in practice as the effort whose required amount templates and checks either reduce or leave with the user. Two empirical objects follow. One is the bar itself, located, for a given system, at the point where specifications begin to be reliably decoded. The other is the entry cost, measured across environments as the effort a usable specification requires under different scaffolding regimes. The framework’s separation is itself testable: holding the system fixed, improvements in the instruction-environment quality should appear in measured costs, not in where the bar sits (§3, §6).

Third, the threshold form of participation yields a sharp prediction: usability should turn on clearing the bar rather than rise smoothly with better instructions. Modeling participation through a(x) ≥ h_min renders this discontinuity directly. It also invites work on scaling and on the risks that arise when execution capacity grows faster than the scaffolding that supports admissible specification. The two grow on different engines: execution capacity grows with the era, while the scaffolding grows only where an institution builds it. When the first outruns the second, the share of episodes a user can afford stands still, and a badly set declaration is carried at a larger scale (§6, §8).

Fourth, the three-gate structure of §5 corresponds to sequential evaluation practices in regulated settings. A medical diagnostic system is categorized within a condition class before its accuracy is assessed. A financial report is verified for required disclosures before substantive review. A compliance submission is checked for inclusion in the regulatory domain before its content is examined. Failure at a prior gate terminates evaluation rather than producing an unfavorable judgment within it, and each gate is verified at its natural layer, which makes each empirically tractable through existing audit and regulatory mechanisms.

Fifth, the governance layer of §5.2 corresponds to review mechanisms that already operate before deployment in regulated settings. Ethics committees vet protocols before clinical AI enters use. Regulatory bodies examine intended-use statements before market authorization. Boards, in turn, assess whether a proposed deployment’s evaluable domain aligns with the institution’s substantive commitments. Treating this prior review as a distinct meta-level on the acceptability of the declaration (T, t, ρ) opens research on several questions. These include how such review should be constituted, what standards of documentation and auditability it should enforce, and how its effectiveness can be evaluated independently of downstream system performance. The direction is salient because, by the asymmetry of §7, no operating-gate correction revises an unacceptable declaration; the corrective burden sits on prior review (§8.2).

Finally, ex ante evaluation criteria reflect existing practice rather than a theoretical ideal. In regulated environments, criteria are declared in advance as predefined acceptance criteria and scoring rubrics, and outcomes are assessed against them rather than used to redefine them. This is the independence that the criterion of §4.2 requires. The scaling regularities on which the bounds of Appendix B.3 rest are likewise auditable. On a reference sample of admissible episodes, deviations from the nominal scaling relations give institutions an empirical check on the assumed regularities. The audit quantities are stated in Appendix B.4. This opens research in AI governance, accountability, and the political economy of evaluation standards.

Because the core constructs map onto existing institutional mechanisms, researchers can extend, contest, or reinterpret specific components without adopting the entire framework. The contribution is thus not only a closed theoretical argument but the seeding of a broader research ecology around institutional decoding (how institutions make reliable decoding affordable), threshold governance, and admissible human-AI collaboration.

To anchor the three-gate structure in concrete institutional settings, we present two stylized case observations. These are not empirical validations but illustrative reconstructions, showing how the gates of §5, in their order, map onto distinctions already operative in regulated practice.

A natural first response to this paper, and one we expect many readers to share, is that its mathematical apparatus is out of proportion to the phenomena it addresses. One might argue that the essential insight, that specification quality matters more than execution capacity in AI-mediated work, is already widely appreciated in applied AI research. On this view, the insight does not require an amplitude with a decoding bar, a cost function, three gate conditions, projections onto two subspaces, and a stochastic-dominance argument. We concede at once that this objection is not without merit. The intuition itself is not novel, and the reader is entitled to ask whether the formalization adds value beyond what plain language could achieve.

Our reply rests on a distinction between intuition and structural precision. Many claims in the human-AI interaction literature remain, through no fault of their authors, at the level of heuristic observation: that prompts matter, that context shapes output, that alignment is important. These statements are directionally correct but analytically incomplete. They do not say where control is exercised, what determines participation, or how institutional conditions mediate the crossing of thresholds. We do not offer the formalism to impress; we offer it to discipline. By fixing definitions, separating what a specification is from what producing it costs, and deriving comparative statics from explicit assumptions, the framework makes its empirical claims falsifiable, which informal treatments typically do not. It is precisely because the core intuition is so widely shared that we believe its formal articulation earns its keep. Shared intuitions, left unstructured, tend to proliferate interpretations that are mutually inconsistent. We would rather be refutable than vague.

A reader working in the situated-action tradition would object that a scalar representation cannot capture how meaning is actually produced, since understanding in real interaction emerges from circumstances as they arise, from mutual interpretation, and from repair when interpretation fails. The same objection extends to the outcome side. Outcomes are not literally vectors, conformity to a goal is not literally a cosine, and a single threshold may appear too thin to carry normative judgment.

We would ask such readers to regard these objects as operational proxies rather than as cognitive models, and we hope to show that the claims carrying weight do not depend on their fine structure. The scalar a(x) captures the degree to which a specification suffices for reliable decoding, not the semantic content of an intention; direction and quality are handled separately, through the criterion x* and the two axes. On the outcome side, what the argument uses is modest. It uses only that membership and sufficiency are different questions, with (T⊥Q) keeping the two evaluated components from standing in for each other, that the criterion is fixed before the outcome (§4.2), that the gates run in order (§5), and that scale reaches only quality magnitude (§7). The separation itself depends neither on dimension counts nor on the cosine form in particular, though the graded reading of the alignment threshold turns on dimension (§4.2); A_ρ stands in for any operationalization of a declared direction that is fixed ex ante. As for the apparent arbitrariness of ρ, we would respectfully suggest that it is not a defect. The threshold ρ is declared, not derived, and that is what makes it the user’s to own and the governance layer’s to review (§5.2, §8.2). We readily grant that a richer model of pragmatics and situated meaning would enrich the framework, and we would welcome such work. In the meantime, we ask that a(x) be read as a placeholder awaiting disciplinary refinement, not as a final word on the nature of specification.

Many readers may fairly object that the model looks static where practice is iterative: real use is dialogic, users refine their specifications across turns, and an ex ante declaration may seem to misdescribe the work.

Our reply is that iteration is a sequence of episodes, and that the declaration constraint binds each episode, not the user’s learning across them. Nothing in the framework forbids revising (T, t, ρ) between episodes, and we would not wish it to. A revised declaration enters the next episode ex ante and passes through the same procedures of review and revision (§5.2, §8.2). Revision is welcome. The one thing the framework does not allow is fixing the criterion after seeing the outcome it is meant to judge. The criterion for each episode must be set before that episode’s outcome, and repeating the work across episodes does not change this (§4.2).

Many readers may object that direction and quality cannot, in practice, be cleanly separated: what counts as well-built often depends on what the work is for, so T⊥Q may strike the reader as unrealistic. We acknowledge that many existing evaluation schemes do, in fact, entangle the two.

Our reply is that the orthogonality is offered as a design requirement on evaluation, not as an empirical claim that every existing scheme satisfies it. It asks that evaluation be built so that the two questions cannot substitute for each other. Where criteria entangle, we do not deny the entanglement; rather, we ask that it be recognized as a defect.

Perhaps the most philosophically ambitious objection, and the one we have weighed most carefully, challenges the paper’s foundational commitment that the setting of ends, values, and normative constraints remains anchored in human agents. Bostrom’s orthogonality thesis holds that intelligence and final goals may vary independently across possible artificial agents, while his instrumental-convergence thesis allows sufficiently capable agents to pursue common intermediate goals in service of many different final goals (Bostrom, 2012). A critic might therefore argue that advanced AI could develop or approximate goal-setting capacities that make the human-anchoring assumption obsolete.

We do not presume to deny the theoretical possibility. We claim less: that under current and foreseeable architectures, deployed systems do not generate intrinsic ends; they optimize objectives supplied externally, and the framework is constructed for this operating regime. Our own machinery states the structural version of the point. A system can add content to the outcome, and it routinely generates subordinate goals, decomposing tasks and structuring execution. Within an episode, however, it cannot add a dimension to T, weight to t, or strictness to ρ (§8.2). So what stays with humans is not every goal-related activity, but the first step: choosing the ends. The subordinate goals an AI generates are valid only because they serve those human-set ends, and whoever sets the ends is the one answerable for them on review (§5.2).

Should the empirical landscape change in ways that confer autonomous end setting on AI systems, we would be the first to grant that the framework’s allocation of responsibility requires fundamental revision. Until then, treating the human declaration as the source of direction is a modeling choice that reflects the actual structure of deployment, not an assertion that machine end setting is impossible. A further commitment motivates the paper, though the framework does not depend on it. On this commitment, the anchoring of human responsibility should be preserved as a permanent structural principle, not treated as a temporary feature of current AI architectures. The framework’s main claims still hold under the weaker, operational reading. The stronger, normative reading we leave, respectfully, to the reader.

A sociotechnical critic might argue that treating institutional conditions as parameters abstracts away the social actors, institutional settings, and contested values that shape the system (Selbst et al., 2019). A related objection from work on automated welfare administration is that such systems fall hardest on those least able to contest them, so that questions of political economy and distribution cannot be treated as parameters at all (Eubanks, 2018). Who designs the instruction environments, whose specifications count as legitimate, and how standards are set are questions of power and distribution. On this view, the framework may depoliticize a political process.

We acknowledge the force of this concern, and we answer it by pointing to where these questions live inside the framework. Instruction-environment quality makes visible that the conditions of legibility are not a natural given but a product of organizational and governance choices. §6 makes the distributive question statable, since the distribution of i across an institution’s episodes sets the entry cost and so determines who can participate. The distinction between inclusive and dilutive design (§8.1) separates widening participation from weakening standards. The political questions proper, who exercises the governance layer, how it is constituted, and whose voices it represents, attach to that layer (§5.2). There, the acceptability of a declaration against the institution’s commitments, including non-discrimination and the protection of disadvantaged groups, is decided before operation (§8.2). The asymmetry of §7 does not insulate the user from accountability for what is declared; it locates that accountability at the prior review. We do not develop a theory of how those choices are made, or in whose interest. We name this as a real limitation, offered as an invitation to political economy and science and technology studies rather than as an oversight.

The foregoing objections are, in our estimation, among the strongest that can be raised against the paper’s central claims, and we are indebted to them. That they can be articulated precisely is itself a consequence of the formal structure, for a theory that cannot be clearly opposed says very little. Our ambition has not been to foreclose debate but to offer a structure well defined enough that debate can proceed on shared ground. We will count the paper successful if its critics find it worth refuting.