Skip to main content

Hybrid Cognition:A Framework for Human-Machine Judgment Under Inductive Uncertainty

About

This document presents a Critical Discourse Analysis focused on AI literacy, specifically targeting the role of metaphor and anthropomorphism in shaping public and professional understanding of generative AI. The analysis is guided by a prompt that draws from cognitive linguistics (metaphor structure-mapping), the philosophy of social science (Robert Brown's typology of explanation), and accountability analysis.

All findings and summaries below were generated from detailed system instructions provided to a large language model and should be read critically as interpretive outputs—not guarantees of factual accuracy or authorial intent.

Source Reading​

Genre: Preprint or technical report · Author position: Developer of the system discussed

Argument: The text introduces "Hybrid Cognition" as a formal design architecture to mitigate AI deployment failures in organizational decision-making. The central claim is that human and machine cognitive failures are complementary, requiring a principled separation of roles: machines should handle "orientation" (evidence accumulation, pattern recognition, and causal hypothesis generation via deterministic models preceding LLM interpretation), while humans must retain exclusive authority over "decision" (belief commitment, consequence evaluation, and irreversible action). The architecture, operationalized in a system called PRIMMS, aims to bound LLM indeterminacy through deterministic governing equations.

Responsibility claims: The text explicitly holds human actors (project managers, sponsors, and commanders) entirely responsible for all irreversible outcomes, belief commitments, and the evaluation of consequences. It argues that machine systems cannot be held accountable and cannot self-regulate from within (the "Godel-Turing constraint"). The text firmly asserts that delegating action to an AI agent does not dissolve human accountability; the human remains responsible for the delegation, the bounds given, and monitoring execution fidelity. It acknowledges the limits of AI agency, framing the machine's role as purely preparatory and explicitly stating that an agent without human-authorized correspondence triggers is a "liability."

Task 1: Metaphor and Anthropomorphism Audit​

About this task

For each of the major metaphorical patterns identified, this audit examines the specific language used, the frame through which the AI is being conceptualized, what human qualities are being projected onto the system, whether the metaphor is explicitly acknowledged or presented as direct description, and—most critically—what implications this framing has for trust, understanding, and policy perception.

1. Machine as Inquiring Subject​

Quote: "This is why the regime stationarity check is the most important single falsification check in the IUVO architecture: it is the system asking whether it still belongs to the world it was trained on."

  • Frame: Statistical test as existential inquiry
  • Projection: The text projects the conscious capability of self-reflection, doubt, and epistemic inquiry onto a statistical function. By framing the Kolmogorov–Smirnov (KS) test as the system "asking" a question about its "belonging," it attributes epistemic/conscious states (wondering, assessing its own relevance) to mathematical anomaly detection. The underlying mechanism, documented in the source as the KS stationarity check, is a deterministic algorithm that calculates the statistical distance between the probability distribution of recent input data and the distribution of the training dataset. If the distance exceeds a threshold, a flag is raised. There is no conscious questioning or self-awareness involved, merely the execution of a comparative mathematical formula.
  • Agency Level: Epistemic/conscious state
  • Acknowledgment: Direct (Unacknowledged) (The phrase "it is the system asking" is presented directly without hedging in this sentence. While the text explicitly acknowledges other biological mappings as "functional" elsewhere, this specific attribution of inquiry is literalized. I considered 'Hedged/Qualified' due to the surrounding technical context, but the specific verb "asking" stands unqualified.)
  • Implications: Framing a statistical distribution check as the system "asking" about its belonging inflates the perceived cognitive sophistication of the software. It encourages users to trust the system's self-monitoring capabilities by suggesting the AI possesses an internal, conscious capacity for self-doubt and epistemic vigilance. This can lead to unwarranted trust in the system's ability to catch all edge cases, as users may mistakenly believe the machine actively reflects on its operational context rather than blindly executing a rigid mathematical threshold. If the anomaly falls outside the parameters of the specific KS test, the system will not "ask" anything, potentially leading to silent failures.

Accountability Analysis:

  • Actor Visibility: Hidden (agency obscured)
  • Analysis: The text positions "the system" as the active inquirer ("the system asking"), obscuring the engineers at Milestone Planning and Research who designed the KS test, selected the significance thresholds, and programmed the exact conditions under which the alert fires. The decision of what constitutes "belonging" (the threshold for statistical drift) is a human design choice that could differ significantly based on risk tolerance. This wording has the effect of making the system appear as a self-monitoring entity, masking the developers' regulatory choices. I considered 'Named' because the text extensively discusses the human role in the broader architecture, but in this specific operational instance, the algorithmic agency displaces the programmer.
Show more...

2. Biological Mapping of Prompt Chains​

Quote: "PRIMMS operationalizes an analogous process using organizational artifacts as sensory analogs... The architecture converts these observations into machine-readable features... activates higher-order pattern representations... and ultimately activates candidate executive representations"

  • Frame: Software architecture as cortical network
  • Projection: This metaphor projects the biological functioning of the human cerebral cortex (specifically Fuster's network theory of 'cognits') onto a multi-layer software pipeline. It maps sensory processing and neurological activation onto the mechanistic processes of data ingestion, feature extraction, and sequential LLM prompt generation. The text explicitly links this to "computational activity" but uses the vocabulary of biological cognition ("sensory analogs," "activates higher-order pattern representations"). The underlying mechanism, documented in the source, involves deterministic MATLAB scripts parsing text documents, calculating Bayesian weights, and feeding those locked metrics into a sequential series of language model prompts (the "Cognitive Hierarchy") which generate text responses based on statistical token prediction. There is no biological activation or subjective perception occurring.
  • Agency Level: Computational activity
  • Acknowledgment: Explicitly Acknowledged (The text explicitly acknowledges this as a mapping, using the term "sensory analogs" and noting elsewhere that "The mapping is functional rather than anatomical." I considered 'Hedged/Qualified', but the explicit use of the word "analogs" and meta-commentary on the mapping itself makes it an explicit recognition of metaphor.)
  • Implications: While explicitly acknowledged as an analogy, repeatedly utilizing neurobiological terminology to describe a sequential software pipeline subtly borrows the legitimacy, adaptability, and perceived intelligence of the human brain. It risks convincing non-expert audiences (such as project sponsors or clients) that the software processes information with the holistic comprehension characteristic of organic life, rather than through rigid, fragile string-matching and statistical likelihoods. This inflates the perceived sophistication of the tool, potentially masking the brittleness inherent in transferring outputs from a MATLAB script into an LLM prompt.

Accountability Analysis:

  • Actor Visibility: Partial (some attribution)
  • Analysis: The text describes the "architecture" doing the converting and activating, but mentions "PRIMMS operationalizes" and later "PRIMMS engineers these principles." This partially attributes the process to the developers at Milestone Planning and Research who built the system, though the passive/agentless phrasing ("activates higher-order pattern representations") still obscures the specific programming choices. The human decision to structure the prompts in this exact five-layer sequence is framed as a natural mirroring of biology rather than a subjective engineering choice. I considered 'Hidden', but the explicit reference to how the system "operationalizes" a theory implies a designer's hand, making 'Partial' more accurate.

3. AI as Causal Reasoner​

Quote: "The LLM is asked to construct and rank competing causal pathways using the project's own evidence corpus... The result is a reasoning map that moves the system from 'what is happening?' toward 'what could plausibly be producing it?'"

  • Frame: Language model as epistemic investigator
  • Projection: The text projects the epistemic capability of causal reasoning and hypothesis generation onto the statistical generation of a Large Language Model. It frames the LLM as moving from observation to abductive explanation. This locates the system at the level of "Epistemic/conscious state" (constructing pathways, reasoning). The actual underlying mechanism, generic to systems of this type, is conditional probability: given a prompt containing the project's evidence corpus and instructions to output explanations, the LLM predicts a sequence of tokens that statistically resembles causal explanations found in its training data. It does not possess a causal model of the world, does not "know" what is producing the project state, and cannot distinguish between true causation and statistical correlation. It merely generates highly probable text.
  • Agency Level: Epistemic/conscious state
  • Acknowledgment: Direct (Unacknowledged) (The claim that the LLM produces a "reasoning map" and "causal pathways" is stated directly. There is no hedging in this immediate passage about the nature of the LLM's output. I considered 'Hedged/Qualified' because the text notes elsewhere that the LLM is constrained by deterministic layers, but the attribution of "causal" and "reasoning" capabilities to the LLM itself remains unqualified here.)
  • Implications: Attributing causal reasoning to an LLM is a significant epistemic risk. When project managers believe a system is "ranking competing causal pathways," they may assume the system possesses a logical understanding of cause and effect in the physical/organizational world. In reality, the LLM is producing plausible-sounding narratives. This consciousness framing dramatically inflates trust in the LLM's diagnostic capabilities, potentially leading teams to overlook actual root causes that were not well-represented in the LLM's training data or the immediate textual context, because the machine's "reasoning map" looks highly persuasive.

Accountability Analysis:

  • Actor Visibility: Hidden (agency obscured)
  • Analysis: The passive construction "The LLM is asked to construct" obscures both the user who submits the prompt and the engineers at Milestone Planning and Research who designed the prompt template. Furthermore, stating "The result is a reasoning map" obscures the generative, ungrounded nature of the LLM built by providers like OpenAI or Anthropic. The framing makes the text generation appear as an objective "map" rather than a statistical output shaped by the LLM provider's opaque training data and the developer's specific prompting strategies. I considered 'Partial' because the system's human constraint is a major theme of the paper, but this specific generative action lacks human attribution.

4. Introspection as Mechanism​

Quote: "The system detects its own approach toward Zero and names it, which is the one thing Zero itself could not do. This self-monitoring property represents a qualitatively different function..."

  • Frame: Algorithm as self-aware entity
  • Projection: This metaphor projects conscious self-awareness, introspection, and metacognition onto a deterministic software rule. It claims the system "detects its own approach" and possesses a "self-monitoring property," placing it at the level of "Epistemic/conscious state" (awareness of one's own limitations). The documented underlying mechanism is entirely mechanical: a hardcoded governing equation counts the number of stale issues; if the count reaches ten, a conditional logic statement (an if-then rule) fires, forcing the subsequent LLM prompt to focus on issue volume control. There is no "self" being monitored, nor does the system experience an "approach toward Zero"; it merely executes a predefined threshold check.
  • Agency Level: Epistemic/conscious state
  • Acknowledgment: Direct (Unacknowledged) (The assertion that the system "detects its own approach" and "names it" is presented as literal, functional fact. There are no scare quotes or qualifying words like "functional" in this sentence. I considered 'Explicitly Acknowledged' because "Zero" references a sci-fi movie mentioned earlier, but the claim of "self-monitoring" is treated as a literal architectural feature.)
  • Implications: Describing a simple threshold trigger as "self-monitoring" and self-detection implies that the system possesses a holistic understanding of its own cognitive capacity and operational limits. This creates a dangerous illusion for users, who might assume the system will automatically recognize and alert them to any form of overload or confusion. In reality, the system only flags the specific, hardcoded metric (e.g., ten open issues). Framing this as generalized self-awareness obscures the fragility of the rule and creates unwarranted reliance on the machine to announce its own failures.

Accountability Analysis:

  • Actor Visibility: Hidden (agency obscured)
  • Analysis: The text states "The system detects" and "names it," completely erasing the human programmers at Milestone Planning and Research who explicitly defined the metric (stale issues), set the threshold (ten), and wrote the code that outputs the alert flag. This wording has the effect of transferring the developer's foresight and design choices into an innate, autonomous property of the software. Naming the developer would reveal that the "self-monitoring" is actually just the developers monitoring the user's project through a proxy metric. I considered 'Named' since the earlier text mentions the governing equations, but the grammatical subject here gives sole agency to "the system."

5. Machine as Active Interpreter​

Quote: "The LLM receives a pre-classified state and is directed to interpret a named archetype and identify a single dominant recovery action."

  • Frame: Text generation as semantic comprehension
  • Projection: The text projects the human cognitive act of semantic comprehension and contextual judgment onto the statistical process of text generation. By stating the LLM is directed to "interpret," the language sits at the "Intentional-state attribution" or "Epistemic/conscious state" level. The underlying mechanism, generic to LLMs, involves taking the deterministic outputs (the pre-classified state and named archetype) as input tokens and predicting the most statistically likely following tokens that describe a recovery action based on the model's training weights. The LLM does not "interpret" meaning in a hermeneutic or conscious sense; it correlates the input text with patterns in its high-dimensional vector space to generate a response.
  • Agency Level: Epistemic/conscious state
  • Acknowledgment: Direct (Unacknowledged) (The verb "interpret" is used directly and prescriptively to describe the machine's assigned task. No hedging or qualification suggests this is meant metaphorically. I considered 'Hedged/Qualified' because the text emphasizes the LLM is constrained by the pre-classified state, but the verb describing the LLM's own internal action remains unhedged.)
  • Implications: Using verbs like "interpret" obscures the mechanical, probabilistic nature of the LLM. It suggests to human decision-makers that the machine possesses a genuine understanding of the "archetype" and the organizational context surrounding it. This can lead project managers to defer to the machine's generated "dominant recovery action" because they believe it is the result of deep contextual comprehension, rather than recognizing it as the most statistically average response to the given keywords, which may lack crucial real-world nuance.

Accountability Analysis:

  • Actor Visibility: Hidden (agency obscured)
  • Analysis: While the text mentions the LLM "is directed," which implies a director, it obscures exactly whose logic is doing the directing and who built the interpretive model. The prompt is generated by the MATLAB layer designed by Milestone Planning and Research, and the LLM interpreting it is built by a third-party corporate provider (e.g., OpenAI, Anthropic) whose training data and alignment tuning fundamentally shape how the "archetype" is processed. The wording isolates the action to the interaction between the data and the LLM, hiding the corporate developers who constrain and bias the "interpretation." I considered 'Partial' because the passive voice implies a director, but the actual actors remain unnamed.

6. The Machine that 'Orients'​

Quote: "The machine orients; the human decides. Causal inference and COA generation can be delegated as orientation functions, but consequence evaluation, belief commitment, and irreversible choice remain human."

  • Frame: Machine as autonomous tactical partner
  • Projection: This central framing projects goal-directed behavior and epistemic navigation onto the software system. By adopting Boyd's OODA loop and assigning "Orient" to the machine, the text places the AI at the "Goal-directed behavior" and "Epistemic/conscious state" level (since orientation is defined as causal inference and hypothesis generation). The actual mechanism, documented in the source, is a pipeline of deterministic mathematical aggregations combined with LLM text generation prompts. The machine does not possess a sense of direction, goals, or situational awareness; it computes values and generates statistically correlated text based on those values.
  • Agency Level: Epistemic/conscious state
  • Acknowledgment: Direct (Unacknowledged) (This is stated as the core, literal maxim of the framework. "The machine orients; the human decides" is an unhedged, direct assignment of cognitive roles. I considered 'Explicitly Acknowledged' because the author heavily theorizes Boyd's framework, but within the text's own logic, the machine literally performs the orientation function.)
  • Implications: This metaphor is the load-bearing pillar of the text. While explicitly designed to bound machine authority by reserving "Decide" for humans, assigning "Orient" to the machine still grants it massive epistemic power. It frames the machine as an objective, aware navigator. If human users believe the machine has successfully "oriented" them (including providing causal inference), their subsequent "decision" is heavily anchored. The framing risks reducing the human to a rubber stamp for the machine's statistically generated worldview, despite the author's stated intention to preserve human judgment.

Accountability Analysis:

  • Actor Visibility: Hidden (agency obscured)
  • Analysis: This sharp binary ("machine orients; human decides") erases the humans who actually engineered the orientation process. It is not "the machine" that orients; it is the developers at Milestone Planning and Research whose algorithms, thresholds, and prompt structures determine exactly what evidence is aggregated and how it is framed. By positioning the machine as an independent orienting agent, the text obscures the reality that the human decision-maker is actually relying on the pre-packaged judgments and categorizations of the software's designers. I considered 'Partial' due to the explicit naming of the human decider, but the agency of the machine's creators is entirely displaced.

7. Agentic Action and Situational Awareness​

Quote: "An agent acts into a changed situation; the gestalt gap between authorization context and execution context produces irreversible errors"

  • Frame: Software as independent actor in the world
  • Projection: The text projects autonomous volition and worldly interaction onto "agentic AI." It frames the software as an entity that "acts into a changed situation," locating it squarely at the "Delegated action" level, but bleeding into "Goal-directed behavior" and "Intentional-state attribution" through the implication that the agent should (but fails to) recognize context. The underlying mechanism involves a software script executing API calls, sending emails, or triggering database updates based on a prior trigger condition. The software does not perceive a "situation" or experience "context"; it merely executes code loops until stopped or until parameters are met.
  • Agency Level: Delegated action
  • Acknowledgment: Direct (Unacknowledged) (The description of the agent acting into a situation is stated as a literal operational failure mode. No metaphorical hedging is present. I considered 'Hedged/Qualified' because the text notes this is a failure of the agent to understand context, but the attribution of the action itself to the agent is direct.)
  • Implications: By discussing software execution as an "agent acting," the text inadvertently attributes a level of situational presence to the system. Even while criticizing the agent's inability to recognize a "gestalt gap," the language reinforces the idea that the software is a distinct actor operating in the physical or organizational world. This framing shapes policy by focusing governance on "agentic AI" as if regulating a new class of synthetic employees, rather than recognizing it as the automated execution of human-initiated digital workflows.

Accountability Analysis:

  • Actor Visibility: Partial (some attribution)
  • Analysis: The text explicitly notes the "authorization context" and elsewhere insists the human "authorizing human specified" the bounds, thus directly implicating human delegators in the action. The text argues fiercely that the delegating human retains accountability. However, referring to the system as "an agent [that] acts" still linguistically separates the execution from the developer who built the automated system and the enterprise that deployed it without sufficient contextual safeguards. I considered 'Named' because the text argues for human accountability, but the specific grammatical construction still centers the "agent" as the primary actor producing the errors.

8. Machine Checking Itself​

Quote: "In both systems, the machine is, in a limited sense, checking itself."

  • Frame: Software pipeline as self-regulating organism
  • Projection: The text projects the cognitive capacity of self-regulation and reflexive review onto a hierarchical software architecture. It locates the system at the "Goal-directed behavior" and "Epistemic/conscious state" level. The documented mechanism is that higher-level statistical outputs (or LLM prompts) are mathematically constrained by lower-level deterministic outputs (e.g., contradiction audits in IUVO or MATLAB signals in PRIMMS). There is no single entity "checking itself"; rather, there are distinct, hardcoded algorithms (designed by humans) passing data between sequential stages and blocking progression if mathematical conditions are not met.
  • Agency Level: Computational activity
  • Acknowledgment: Hedged/Qualified (The phrase "in a limited sense" acts as a direct hedge on the framing of the machine checking itself, recognizing the metaphorical nature of the claim. I considered 'Explicitly Acknowledged', but it lacks the direct meta-commentary seen in the "sensory analogs" quote.)
  • Implications: Even with the hedge, framing structural algorithms as the machine "checking itself" implies a level of internal autonomy and reliability that mimics biological homeostasis. It suggests the system has an internal drive toward accuracy and self-correction. This masks the reality that the system only checks exactly what the human programmers told it to check, using the exact thresholds they defined. If an error falls outside those pre-programmed bounds, the machine will not "check" it. It risks fostering over-reliance on the software's internal error-handling.

Accountability Analysis:

  • Actor Visibility: Hidden (agency obscured)
  • Analysis: By stating "the machine... checking itself," the wording entirely obscures the developers at Milestone Planning and Research who actually built the "contradiction audit" and the "deterministic MATLAB signal layer." The "checking" is an effect of human-written code, not a spontaneous property of "the machine." This framing structurally benefits the software developer by making their explicit, subjective choices about what constitutes an error appear as an objective, innate capability of the technology itself. I considered 'Partial' since the text references the architecture, but the grammatical subject here assigns the regulatory action entirely to the machine.

Task 2: Source-Target Mapping​

About this task

For each key metaphor identified in Task 1, this section provides a detailed structure-mapping analysis. The goal is to examine how the relational structure of a familiar "source domain" (the concrete concept we understand) is projected onto a less familiar "target domain" (the AI system). By restating each quote and analyzing the mapping carefully, we can see precisely what assumptions the metaphor invites and what it conceals.

Mapping 1: A conscious individual experiencing self-doubt and seeking to verify their context. → A Kolmogorov–Smirnov (KS) statistical test applied at the model level to detect data distribution shift.​

Quote: "it is the system asking whether it still belongs to the world it was trained on."

  • Source Domain: A conscious individual experiencing self-doubt and seeking to verify their context.
  • Target Domain: A Kolmogorov–Smirnov (KS) statistical test applied at the model level to detect data distribution shift.
  • Mapping: The human act of existential and epistemic questioning maps onto a mathematical comparison of probability distributions. The threshold breach (where current data statistically diverges from training data) maps to the system 'realizing' it no longer belongs. This mapping invites the assumption that the system possesses an active, vigilant awareness of its own limitations and environment, much like a human continuously evaluating their surroundings.
  • What Is Concealed: This mapping conceals the rigid, blind, and purely mathematical nature of the KS test. It hides the fact that the system does not "know" anything about the world; it only knows arrays of numbers. Furthermore, it obscures the human developer's role in choosing the specific features to track and the exact P-value threshold required to trigger the alert. If the world changes in a way not captured by the tracked metrics, the system will emphatically not "ask" anything.
Show more...

Mapping 2: The biological human cerebral cortex, sensory perception, and neurological activation (Fuster's 'cognits'). → An organizational application architecture processing text documents via deterministic scripts and LLM prompts.​

Quote: "PRIMMS operationalizes an analogous process using organizational artifacts as sensory analogs... activates higher-order pattern representations"

  • Source Domain: The biological human cerebral cortex, sensory perception, and neurological activation (Fuster's 'cognits').
  • Target Domain: An organizational application architecture processing text documents via deterministic scripts and LLM prompts.
  • Mapping: Text documents (status reports, schedules) are mapped to raw sensory input (sight, sound). Deterministic parsing algorithms are mapped to lower-level neurological feature detection. Sequential LLM prompts are mapped to higher-order, abstract cognitive representation. This mapping invites the assumption that the software processes information with the organic, deeply integrated, and fluid comprehension of a biological brain.
  • What Is Concealed: The biological mapping conceals the fundamental brittleness and discrete nature of software pipelines. Biological brains do not pass locked text strings (prompts) between isolated modules; they have massive, continuous parallel integration. The metaphor hides the reliance on statistical token prediction (in the LLM layer) and explicit rule-based parsing (in the MATLAB layer), obscuring the fragility of relying on exact string matches and statistical weights rather than actual semantic understanding.

Mapping 3: A human expert investigator evaluating evidence to infer true causality in the physical/organizational world. → An LLM generating text at the application level based on a prompt containing project metrics.​

Quote: "The LLM is asked to construct and rank competing causal pathways... The result is a reasoning map"

  • Source Domain: A human expert investigator evaluating evidence to infer true causality in the physical/organizational world.
  • Target Domain: An LLM generating text at the application level based on a prompt containing project metrics.
  • Mapping: The statistical prediction of words that commonly co-occur with project failure metrics in the training data maps onto the human cognitive process of abductive reasoning. The generated text output maps onto a "reasoning map." This invites the assumption that the LLM understands the causal relationships between project events, rather than just recognizing linguistic patterns describing those events.
  • What Is Concealed: This framing conceals the total absence of a causal model within the LLM. It hides the model's reliance on its opaque, proprietary training corpus (e.g., from OpenAI or Anthropic) which determines what narratives it finds "plausible." It obscures the fact that the model is performing correlation-based generation, not structural inference, hiding the risk that the model will confidently hallucinate a "causal pathway" that sounds fluent but has no basis in physical reality.

Mapping 4: A self-aware entity recognizing its cognitive limitations and verbally communicating its distress. → A deterministic if-then statement in the application code triggering when a specific variable (issue count) exceeds a hardcoded integer (ten).​

Quote: "The system detects its own approach toward Zero and names it"

  • Source Domain: A self-aware entity recognizing its cognitive limitations and verbally communicating its distress.
  • Target Domain: A deterministic if-then statement in the application code triggering when a specific variable (issue count) exceeds a hardcoded integer (ten).
  • Mapping: The mathematical crossing of an integer threshold maps onto introspective self-detection. The automated generation of a specific prompt instruction maps onto the system "naming" its problem. This invites the assumption that the system possesses meta-cognition and can autonomously monitor its own operational health across all dimensions.
  • What Is Concealed: The mapping conceals the extreme narrowness of the trigger. It hides the fact that the system is entirely blind to any approach toward "Zero" (complexity collapse) that does not manifest exactly in the single tracked metric (issue volume). It also completely conceals the human programmer who actually did the "detecting" and "naming" in advance by writing the conditional logic into the codebase.

Mapping 5: A human analyst receiving instructions and applying hermeneutic comprehension to extract meaning from an abstract concept. → An LLM processing a prompt string at the application level to generate subsequent text.​

Quote: "The LLM receives a pre-classified state and is directed to interpret a named archetype"

  • Source Domain: A human analyst receiving instructions and applying hermeneutic comprehension to extract meaning from an abstract concept.
  • Target Domain: An LLM processing a prompt string at the application level to generate subsequent text.
  • Mapping: The process of inputting text tokens (the prompt containing the archetype) into a neural network and executing matrix multiplications to output new tokens maps onto the human cognitive act of "interpretation." This invites the assumption that the LLM possesses semantic grasp and contextual judgment regarding the archetype.
  • What Is Concealed: This language conceals the mechanistic, probabilistic nature of token generation. It obscures the fact that the LLM has no grounded understanding of the organizational "archetype" beyond the statistical distribution of related words in its training data. It also hides the massive compute infrastructure and the proprietary alignment tuning (RLHF) required by the LLM provider to make the output appear as a coherent "interpretation."

Mapping 6: A tactical human partner (like a navigator or intelligence officer) providing situational awareness to a commander. → The combined computational processes of the PRIMMS application (deterministic aggregation and LLM text generation).​

Quote: "The machine orients; the human decides."

  • Source Domain: A tactical human partner (like a navigator or intelligence officer) providing situational awareness to a commander.
  • Target Domain: The combined computational processes of the PRIMMS application (deterministic aggregation and LLM text generation).
  • Mapping: The mathematical calculation of metrics and the generation of text options map onto the cognitive process of "orientation" (understanding what observations mean). The human's interaction with the UI maps onto "decision." This invites the assumption that the machine has an objective, aware perspective on the organizational environment, capable of true situational synthesis.
  • What Is Concealed: This mapping conceals the fact that the machine has no perspective or awareness to orient with. It hides how the "orientation" is entirely pre-structured by the human developers who decided which signals to aggregate and how to prompt the LLM. It obscures the risk that by controlling the "orientation" (the menu of options and causal narratives), the software heavily determines the "decision," complicating the author's claim that human authority remains intact.

Mapping 7: A human subordinate executing orders but failing to use common sense when circumstances change. → An automated workflow script at the deployment environment level triggering API actions based on prior authorization parameters.​

Quote: "An agent acts into a changed situation; the gestalt gap between authorization context and execution context produces irreversible errors"

  • Source Domain: A human subordinate executing orders but failing to use common sense when circumstances change.
  • Target Domain: An automated workflow script at the deployment environment level triggering API actions based on prior authorization parameters.
  • Mapping: The mindless execution of code loops maps onto a subordinate "acting" blindly. The divergence between the data parameters at T1 and T2 maps onto a "gestalt gap" in context. This invites the assumption that the software is a quasi-independent entity operating within a physical or organizational "situation."
  • What Is Concealed: This conceals that the software possesses zero situational awareness to begin with; it cannot experience a "gestalt gap" because it never grasped the "gestalt" at authorization either. It merely checked a set of true/false flags. It hides the human deployer's failure to program necessary revocation triggers, displacing the blame for the irreversible error onto the "agent" acting into the situation.

Mapping 8: An organism maintaining homeostasis or a human performing reflexive quality control on their own work. → Sequential algorithmic layers at the application level where the outputs of Layer A constrain or block the inputs to Layer B.​

Quote: "In both systems, the machine is, in a limited sense, checking itself."

  • Source Domain: An organism maintaining homeostasis or a human performing reflexive quality control on their own work.
  • Target Domain: Sequential algorithmic layers at the application level where the outputs of Layer A constrain or block the inputs to Layer B.
  • Mapping: The hardcoded validation logic written by programmers maps onto the system actively "checking itself." This invites the assumption that the software possesses an internal drive toward accuracy, coherence, and self-preservation.
  • What Is Concealed: This conceals the external origin of the constraints. The machine is not checking itself; one piece of code written by a human is checking the data produced by another piece of code. It obscures the fact that the system is entirely passive and will happily fail silently if the human-designed "checks" are misspecified, missing, or miscalibrated.

Task 3: Explanation Audit (The Rhetorical Framing of "Why" vs. "How")​

About this task

This section audits the text's explanatory strategy, focusing on a critical distinction: the slippage between "how" and "why." Based on Robert Brown's typology of explanation, this analysis identifies whether the text explains AI mechanistically (a functional "how it works") or agentially (an intentional "why it wants something"). The core of this task is to expose how this "illusion of mind" is constructed by the rhetorical framing of the explanation itself, and what impact this has on the audience's perception of AI agency.

Explanation 1​

Quote: "The contradiction audit in IUVO is one operational instantiation; the deterministic MATLAB signal layer in PRIMMS is another. In both systems, the machine is, in a limited sense, checking itself."

  • Explanation Types:

    • Functional (Primary): Explains behavior by role in self-regulating system with feedback
    • Intentional (Secondary): Refers to goals/purposes, presupposes deliberate design

  • Analysis (Why vs. How Slippage): This passage operates primarily through a Functional register, describing how specific architectural components (the contradiction audit, the MATLAB signal layer) serve a specific regulatory role within the larger system structure. It explains how the system works to maintain stability. However, by summarizing this function as "the machine is... checking itself," the explanation slips into an Intentional register, framing the system's behavior as an agential, purposeful action directed at its own operations. This choice emphasizes the self-contained, automated nature of the architecture, which supports the author's argument about bounding LLM indeterminacy. However, it obscures the mechanistic reality that "checking itself" is merely the execution of rigid, human-authored validation scripts acting upon other data outputs within the system.

  • Consciousness Claims Analysis: The passage uses the mechanistic verb "checking" (in the sense of validation) but applies it reflexively ("checking itself"), pushing the agency level toward Goal-directed behavior. The text explicitly hedges this claim ("in a limited sense"), showing self-awareness, but still frames processing as a form of self-monitoring. This reflects a curse of knowledge dynamic: the author, knowing the system is designed to catch internal contradictions, describes the system as possessing the vigilance that the author actually programmed into it. Mechanistically, as documented in the source, this process involves deterministic algorithms (the MATLAB layer) that lock specific data values or compare mathematical outputs against predefined bounds before allowing an LLM prompt to proceed. The system has no awareness of "itself"; it simply runs sequential code blocks where one block acts as a gatekeeper for the next.

  • Rhetorical Impact: This framing shapes the audience's perception by constructing the AI system as a highly robust, self-regulating entity akin to a biological organism. While the hedge mitigates some risk, the "self-checking" narrative fosters performance-based trust by reassuring users that the system has internal safeguards against error. If audiences believe the machine actively "checks itself" rather than merely executing rigid if-then validations, they may become complacent, assuming the software possesses generalized error-detection capabilities and failing to realize it only checks for the exact conditions explicitly defined by its programmers.

Show more...

Explanation 2​

Quote: "A language model is optimized for coherence: it produces text that is locally plausible, globally consistent, and stylistically fluent, and it has no internal mechanism for registering when that fluency is disproportionate to the available evidence."

  • Explanation Types:

    • Genetic (Primary): Traces origin through dated sequence of events or stages
    • Dispositional (Secondary): Attributes tendencies or habits

  • Analysis (Why vs. How Slippage): This is a remarkably precise, mechanistic explanation that resists anthropomorphism. It uses a Genetic explanation (referring to the training process: "optimized for coherence") to explain the model's current behavior, coupled with a Dispositional explanation describing its tendency to produce fluent text. By explaining the behavior mechanistically (how it was optimized, how it produces text), the passage emphasizes the structural limitations of the LLM and the gap between statistical fluency and epistemic truth. It brilliantly obscures nothing, explicitly pointing out the absence of a "mechanism for registering" truth, thereby stripping the LLM of projected consciousness.

  • Consciousness Claims Analysis: The passage actively works to deny epistemic claims. It uses mechanistic verbs ("optimized," "produces") and explicitly states the system "has no internal mechanism for registering" truth. This locates the system correctly at the level of Computational activity. The author actively resists the curse of knowledge by refusing to project human understanding onto fluent output. The actual mechanistic process, generic to systems of this type, is described perfectly: the model generates text via statistical token prediction based on weights shaped during training on massive corpora; because training minimizes prediction error on coherent text, the model inherently defaults to producing highly probable (fluent) sequences regardless of factual grounding. There is no subjective knowing involved, only statistical processing.

  • Rhetorical Impact: This framing violently disrupts the "illusion of mind." By explicitly divorcing fluency from evidence and framing coherence as an optimization parameter rather than a marker of intelligence, it severely undercuts relation-based trust in the LLM. It forces the audience to view the AI as an artifact (a text generator) rather than an oracle. If audiences absorb this mechanistic truth, they are far more likely to demand the external validation architectures (like PRIMMS) that the paper advocates for, because they recognize that the LLM cannot be trusted to know what it is saying.

Explanation 3​

Quote: "The LLM receives a pre-classified state and is directed to interpret a named archetype and identify a single dominant recovery action."

  • Explanation Types:

    • Functional (Primary): Explains behavior by role in self-regulating system with feedback
    • Intentional (Secondary): Refers to goals/purposes, presupposes deliberate design

  • Analysis (Why vs. How Slippage): This passage primarily utilizes a Functional explanation, describing the specific operational role the LLM plays within the multi-stage PRIMMS architecture (receiving data, processing it). However, it leans heavily on an Intentional register through verbs like "interpret" and "identify." This choice emphasizes the utility of the LLM as a semantic processor that bridges the gap between raw data and actionable advice. However, it obscures the actual computational reality by describing statistical text generation as a deliberate, cognitive act of comprehension and selection.

  • Consciousness Claims Analysis: The passage attributes epistemic states to the machine through the consciousness verbs "interpret" and "identify." It climbs the agency gradient to Intentional-state attribution. While the author understands the system is merely receiving a string and outputting a string (curse of knowledge), the vocabulary projects human-like analytic capabilities onto the process. Mechanistically, generic to systems of this type, the LLM receives a text prompt generated by the MATLAB layer (which includes the classified state and archetype string) and generates an output sequence by predicting tokens that statistically align with the prompt's context and instructions. The LLM does not "interpret" meaning or actively "identify" solutions in a cognitive sense; it correlates patterns to produce a probable textual response.

  • Rhetorical Impact: This framing shapes audience perception by elevating the LLM from a text generator to an intelligent analyst. If project managers believe the system "interprets" archetypes and "identifies" solutions, they are likely to grant those solutions unwarranted authority, assuming they are the product of genuine understanding rather than statistical matching. This increases the risk of users adopting the system's recommendations without critical scrutiny, despite the paper's overarching warnings about human accountability.

Explanation 4​

Quote: "If open issues reach ten or more, a Zero constraint flag fires... The system detects its own approach toward Zero and names it, which is the one thing Zero itself could not do."

  • Explanation Types:

    • Functional (Primary): Explains behavior by role in self-regulating system with feedback
    • Intentional (Secondary): Refers to goals/purposes, presupposes deliberate design

  • Analysis (Why vs. How Slippage): The explanation begins functionally and mechanistically ("If open issues reach ten... a flag fires"), explaining exactly how the rule operates. However, it immediately shifts into an Intentional explanation, personifying the system as an entity that "detects its own approach" and "names it." This emphasizes the value of the architectural safeguard, contrasting it favorably with a fictional failing supercomputer. By dramatizing a simple if-then statement as an act of self-awareness, the explanation obscures the trivial simplicity of the underlying mechanism (a hardcoded integer threshold).

  • Consciousness Claims Analysis: The passage explicitly attributes consciousness and self-awareness to the software, using verbs like "detects" and "names" applied to "its own approach." This is a massive leap up the agency gradient to Epistemic/conscious state. The author, knowing exactly how the deterministic rule works, uses dramatic shorthand to summarize its effect, projecting metacognition onto code. Mechanistically, documented in the source, this is a simple threshold check in the MATLAB layer: if the integer count of stale issues is >= 10, a boolean flag changes state, causing the subsequent prompt template to include a specific string instructing the LLM to focus on issue volume. The system experiences no self-awareness.

  • Rhetorical Impact: This framing creates a powerful, heroic narrative around the software, portraying it as uniquely self-aware and capable of avoiding catastrophic failure through introspection. This profoundly shapes risk perception, potentially causing users to overestimate the system's resilience. If audiences believe the AI "detects its own approach" to failure, they may falsely assume the system can anticipate and warn them about any type of collapse, not just the single variable explicitly hardcoded by the developers.

Explanation 5​

Quote: "The LLM is asked to construct and rank competing causal pathways using the project's own evidence corpus... The result is a reasoning map that moves the system from 'what is happening?' toward 'what could plausibly be producing it?'"

  • Explanation Types:

    • Reason-Based (Primary): Gives agent's rationale, entails intentionality and justification
    • Intentional (Secondary): Refers to goals/purposes, presupposes deliberate design

  • Analysis (Why vs. How Slippage): This explanation utilizes a Reason-Based register, describing the LLM's task as a formal cognitive exercise (constructing and ranking causal pathways, producing a reasoning map). It frames the AI agentially, as an investigator moving from observation to abductive logic. This emphasizes the system's utility in expanding human perspective. However, it entirely obscures the mechanistic reality that the LLM is incapable of causal reasoning and is merely performing complex pattern-matching on text strings.

  • Consciousness Claims Analysis: The passage attributes high-level epistemic states to the LLM. Using verbs like "construct," "rank," and producing a "reasoning map" locates the system at the absolute peak of the agency gradient: Epistemic/conscious state. The author projects their own human understanding of causality onto the machine's statistical output. Mechanistically, generic to systems of this type, the LLM processes a prompt containing project data and instructions to generate hypotheses. It produces text by sampling from a probability distribution of tokens that frequently co-occur with the input concepts in its training data. It does not "reason," it does not possess a causal model, and it has no concept of what is "plausibly producing" the physical world events described in the text.

  • Rhetorical Impact: This is perhaps the most dangerous framing in the text regarding trust. By describing the LLM's output as a "reasoning map" built on "causal pathways," it lends immense unearned epistemic authority to statistical text generation. Audiences reading this will believe the AI possesses diagnostic reasoning capabilities akin to a human expert. This fundamentally alters reliance: if a project manager believes the AI "reasons" rather than "processes," they may abdicate their own responsibility to perform causal analysis, directly contradicting the text's own stated goal of maintaining human authority.

Task 4: AI Literacy in Practice - Reframing Anthropomorphic Language​

About this task

This section proposes alternative language for key anthropomorphic phrases, offering more mechanistic and precise framings that better reflect the actual computational processes involved. Each reframing attempts to strip away the projections of intention, consciousness, or agency that are embedded in the original language.

Original Anthropomorphic FrameMechanistic ReframingTechnical Reality CheckHuman Agency Restoration
it is the system asking whether it still belongs to the world it was trained on.The software executes a Kolmogorov-Smirnov statistical test to compare the distribution of incoming data against the distribution of the original training dataset, flagging instances where the statistical variance exceeds a predefined threshold.The system does not "ask" questions or possess a concept of "belonging." Documented in the source, it runs a deterministic KS statistical test that computes the difference between current data distributions and baseline data distributions.

Basis: Documented in source		The developers at Milestone Planning and Research implemented a Kolmogorov-Smirnov test to flag when the statistical properties of the input data diverge from the baseline data they selected.
The LLM is asked to construct and rank competing causal pathways... The result is a reasoning mapThe prompt template directs the LLM to generate text describing potential causal relationships based on the provided project data. The resulting output is a statistically generated text document that surfaces plausible narratives.The LLM does not "reason" or understand causality. Generic to systems of this type, it receives a prompt string and generates text by predicting subsequent tokens that statistically resemble explanations found in its training corpus.

Basis: Generic to system type		Users input project data into prompt templates engineered by Milestone Planning and Research; the LLM (built by a third-party developer) then generates text that mimics causal reasoning based on patterns in its training data.
The system detects its own approach toward Zero and names itWhen a deterministic script calculates that the open issue count has reached ten, it triggers a conditional rule that automatically appends an instruction about issue volume control to the subsequent LLM prompt.The system possesses no self-awareness or ability to "detect" its approach to failure. Documented in the source, a hardcoded governing equation simply counts a variable and triggers an if-then rule when an integer threshold is met.

Basis: Documented in source		Programmers at Milestone Planning and Research established a hardcoded rule that triggers a specific text output when the open issue count exceeds ten.
The LLM receives a pre-classified state and is directed to interpret a named archetypeThe LLM processes a prompt containing the pre-classified data and the named archetype, generating a text response that statistically correlates with those terms.The LLM does not "interpret" meaning. Generic to systems of this type, it takes the prompt string as input and predicts the most probable following tokens based on the high-dimensional weights established during its training phase.

Basis: Generic to system type		The application feeds deterministic data into the LLM, and the LLM produces outputs shaped by the training data and optimization objectives established by its corporate developer.
The machine orients; the human decides.The computational system aggregates statistical indicators and generates text-based options; the human operator evaluates these processed outputs and commits to a specific course of action.The machine does not "orient" in a cognitive or spatial sense. Documented in the source, it executes deterministic mathematical aggregations (MATLAB) and statistical text generation (LLM) to organize information into predefined templates.

Basis: Documented in source		The developers designed the architecture to aggregate data and generate options, bounding the choices presented to the human decision-maker.
An agent acts into a changed situation; the gestalt gap between authorization context and execution context produces irreversible errorsAn automated script executes API commands despite changes in the underlying data parameters; the discrepancy between the conditions at authorization and the conditions at execution results in unintended outcomes.The software does not perceive a "situation" or experience a "gestalt gap." Generic to systems of this type, it blindly executes programmed instructions until stopped or until explicit, hardcoded parameters are met.

Basis: Generic to system type		The human deployer authorized an automated script without programming sufficient revocation triggers to halt execution when data parameters changed.
In both systems, the machine is, in a limited sense, checking itself.In both architectures, specific deterministic algorithms are programmed to validate the mathematical consistency of data outputs before allowing that data to pass to the next stage of processing.The machine does not reflexively "check itself." Documented in the source, human-authored validation scripts (like the contradiction audit) parse data outputs and block progression if the numbers violate predefined mathematical rules.

Basis: Documented in source		Engineers at Milestone Planning and Research programmed validation scripts that block the system from proceeding if the data violates the mathematical rules they defined.
A causal hypothesis can therefore direct renewed attention downward into the documentary corpusThe text generated by the LLM can be used to define search parameters for retrieving additional specific documents from the database.Hypotheses do not "direct attention." Generic to systems involving multi-step retrieval (like RAG), the initial text output is programmatically used as a query string to retrieve further documents from the vector database.

Basis: Reasonable inference		The application architecture is designed by developers so that initial LLM outputs trigger automated database queries to retrieve further documents.

Task 5: Critical Observations - Structural Patterns​

Agency Slippage​

The text exhibits a fascinating pattern of agency slippage precisely because its explicit argument fights against it. The author explicitly aims to restrict machine agency, declaring that "human authority over all irreversible decisions" is paramount and warning that "inductive systems cannot self-regulate from within." Yet, when describing the system's "Orient" function (data aggregation and LLM generation), the vocabulary repeatedly slips up the agency gradient, converting computational processing into epistemic action.

The slippage is most dramatic in the technical sections describing the LLM (Layer 2-5 of the Cognitive Hierarchy). The text transitions abruptly from describing the MATLAB layer in mechanical terms (it "computes," "converts," "extracts") to describing the LLM in highly agential, conscious terms: the LLM "interprets" archetypes, "constructs and ranks competing causal pathways," and produces a "reasoning map." This movement from mechanical (computation) to agential (reasoning) constitutes a severe climb on the agency gradient without any new computational evidence to support epistemic attribution. The text establishes the deterministic layer as a rigid mechanism to contain the LLM, but then allows the LLM to masquerade as an intelligent, causal investigator.

This slippage is heavily driven by the curse of knowledge and the author's adoption of the biological/cognitive metaphors (Fuster and Friston). By framing the software architecture as a "Cognitive Hierarchy" dealing in "sensory analogs" and "higher-order pattern representations," the author projects their own deep understanding of cognitive science and project management onto the token-prediction mechanisms of the LLM.

Agentless constructions further facilitate this slippage. Phrases like "The LLM is asked to construct" or "the system detects its own approach" obscure the human developers at Milestone Planning and Research who actually designed the prompt structures and coded the thresholds. By describing the author's vocabulary by its effects, this wording can have the effect of making the LLM appear to possess intrinsic analytical volition. The phrase "the machine orients" functions as a convenient shorthand for a complex pipeline of data routing and text generation, but it has the effect of treating the software as an autonomous tactical partner. What becomes sayable under this framing is that the AI "reasons" about project failure; what becomes unsayable is that the system merely correlates text patterns without any underlying causal understanding.

Metaphor-Driven Trust Inflation​

The text constructs authority and trust through a complex interplay of biological mapping and rigorous mathematical bounding. By mapping the PRIMMS architecture onto Fuster's "cognits" and Friston's "Free Energy Principle," the text borrows the immense evolutionary legitimacy of the human brain. Framing software layers as "Cortical Hierarchy" and data as "sensory analogs" signals to the reader that the system is not merely processing data, but perceiving reality with organic sophistication. This constructs a dangerous form of relation-based trust: the implication that the system possesses a holistic, integrative "mind" capable of nuanced comprehension.

However, the text actively attempts to subvert uncritical relation-based trust by heavily emphasizing performance-based trust. It dedicates significant space to outlining the "Godel-Turing constraints" and the "Zero constraint," explicitly telling the audience that language models suffer from "coherence overconfidence" and cannot be trusted to self-regulate. The author correctly identifies that relation-based trust toward statistical systems is dangerous.

Yet, the text undermines its own warnings through its reliance on "reason-based" explanation types when describing the LLM's outputs. By claiming the LLM produces a "reasoning map" and "causal pathways," the text signals to users that the machine's outputs are logically justified rather than merely statistically probable. This encourages users to apply human-trust frameworks to the machine's outputs: if the system provides a "causal" explanation, the user assumes the system has logically deduced cause and effect.

The text manages system failure by dividing it into "micro" (mechanical) and "gestalt" (human) reliability. This is a brilliant structural defense, assigning the failure mode of "vocabulary-world gap" strictly to the human. However, the vocabulary used to describe the machine's "Orientation" phase—claiming it "interprets" and "constructs causal hypotheses"—so effectively constructs the machine as a competent investigator that it risks causing human users to abdicate their "gestalt" vigilance. If audiences believe the AI "knows" why a project is failing, they are far more likely to accept its orientation as objective truth, transferring unwarranted trust to a system incapable of actual causal comprehension.

Obscured Mechanics​

While the text is unusually transparent about its deterministic architecture (the MATLAB layer), its anthropomorphic framing of the LLM layer profoundly obscures the mechanistic realities of large language models. This framework holds that commercial incentives, data annotation and human feedback labor, environmental and compute costs, and developers' limited disclosure of training data, objectives, and feedback processes are standing conditions of the technology.

When the text claims the LLM "interprets a named archetype" or "constructs causal pathways," it completely hides the computational dependencies required for those actions. Specifically, it obscures the fact that the LLM (built by undisclosed corporate developers like OpenAI or Anthropic) relies entirely on opaque training corpora. The LLM does not "reason"; it predicts tokens based on high-dimensional vector similarities derived from human labor (data scrapers, annotators, RLHF workers). By focusing on the system's "causal hypotheses," the text hides the absence of a causal model, obscuring the statistical nature of the text generation.

Applying the "name the corporation" test reveals significant obfuscation. The text states "The LLM receives a pre-classified state," hiding the decisions of both Milestone Planning and Research (who wrote the prompt that feeds the state) and the corporate LLM provider (whose proprietary architecture processes the prompt). The text treats the LLM as a neutral cognitive utility, erasing the commercial objectives and alignment tunings of the massive corporations that built it.

Furthermore, the framing of the system "checking itself" or "detecting its own approach" conceals the fragility of hardcoded software rules. It obscures the fact that these "checks" are limited to exactly what the developers at Milestone Planning and Research had the foresight to program (e.g., counting open issues).

If these metaphors were replaced with mechanistic language—if "the system detects its own approach" became "the developer's threshold script triggers" and "the LLM constructs causal pathways" became "the LLM generates statistically correlated text"—the system's absolute dependence on human programming and corporate training data would become visible. The "magic" of the AI's insight would be correctly relocated to the developers who structured the data and the statistical models that synthesize language, dissolving the illusion of machine cognition.

Context Sensitivity​

The distribution of anthropomorphic language in this text reveals a sharp and deliberate asymmetry, concentrating heavily in theoretical vision-setting passages and capability descriptions, while relying on mechanistic language for limitations and rules.

The text begins with highly mechanistic language when diagnosing the failures of current AI deployment ("data pipelines," "statistical forecasting models," "coherence bias"). In describing the deterministic MATLAB layer, the language is rigorously mechanical: it "ingests," "computes," "locks," and "converts." However, the anthropomorphism aggressively intensifies in two specific contexts: when mapping the system to biological theory (Fuster/Friston) and when describing the capabilities of the LLM layer.

When discussing the biological analogs, the text shifts from computational processes to cognitive ones: the system deals in "sensory analogs" and "activates higher-order pattern representations." When detailing the LLM's "Orientation" role, "computation" becomes "interpretation," and "text generation" becomes "causal hypothesis formation." Here, the language climbs the agency gradient, sitting epistemic knowing alongside mechanical processing. This wording can have the effect of making the LLM appear to transcend its deterministic constraints.

Conversely, limitations are framed mechanistically. The "Zero constraint" and "Godel-Turing constraint" are described in terms of "indeterminacy," "expressive inductive systems," and "formal boundaries." This capability/limitation asymmetry leaves the reader with a deeply bifurcated picture of the system: it is a mechanistic, bounded tool when it needs to be constrained, but a conscious, reasoning agent when it needs to provide insights.

The register frequently shifts from acknowledged metaphor ("analogous process") to literalized claim ("the system asking whether it still belongs"). This pattern, characteristic of the field's inherited register, suggests an implied audience of project managers and executives who require rigorous governance (satisfied by the mathematical language) but desire the profound insights of an intelligent partner (satisfied by the consciousness verbs). The juxtaposition of locked statistical formulas with claims of "causal reasoning" serves to launder the indeterminacy of the LLM through the rigor of the deterministic layer, constructing an illusion of highly reliable machine intellect.

Accountability Synthesis​

Accountability Architecture

This section synthesizes the accountability analyses from Task 1, mapping the text's "accountability architecture"—who is named, who is hidden, and who benefits from obscured agency.

The text presents a unique accountability architecture: its explicit argument vigorously defends human responsibility, while its operational vocabulary subtly diffuses it. In Task 0, the text's stated position is clear: humans must own all irreversible outcomes, machines cannot self-regulate, and delegating action to an AI requires strict, human-designed situational checks. The text aggressively critiques the "confidence transfer problem" where humans hide behind AI outputs.

However, there is a profound tension between this argument and the vocabulary used to describe the "Orientation" phase. By asserting "the machine orients," the text treats the AI as an independent epistemic agent. When the language claims the LLM "constructs and ranks competing causal pathways," it attributes a high level of analytical authority to the machine. While the text insists the human "Decides," if the human's decision is based on a "reasoning map" entirely generated by the machine, the accountability is structurally undermined. If the machine's generated "causal hypothesis" is wrong, but looks perfectly coherent, the human decision-maker is set up to fail. The accountability sink does not disappear, but it shifts: the human remains legally/operationally responsible, but cognitively, they are subjected to the overwhelming influence of a system framed as a "causal reasoner."

Agentless constructions like "the system detects its own approach" or "an agent acts into a changed situation" erase the developers at Milestone Planning and Research and the deployers who set the parameters. This language diffuses responsibility away from the human designers who built the prompts and thresholds, transferring the perceived agency to the software artifact.

If we apply the "name the actor" test to the "Orientation" phase, the architecture shifts. If the text stated, "Milestone Planning designed prompts that cause the LLM to generate text resembling causal narratives, which the human must then verify," the human decision-maker's burden is clarified. They are not merely choosing among objective "pathways" discovered by a machine; they are filtering synthetic narratives generated by corporate models and constrained by Milestone's developers. The current distribution of responsibility serves institutional interests by providing the illusion of objective, machine-generated orientation, allowing leadership to feel supported by an "intelligent" system rather than recognizing they are relying on statistical text prediction.

Conclusion: What This Analysis Reveals​

The Core Finding

This analysis reveals two dominant anthropomorphic patterns operating in tension with the text's explicit governance argument. First, the biological/cognitive mapping pattern utilizes Fuster and Friston's neurobiological theories to describe a deterministic software pipeline as a "Cognitive Hierarchy" that activates "sensory analogs." Second, the epistemic investigator pattern elevates the LLM's statistical text generation into "causal reasoning," "interpretation," and the production of a "reasoning map." The biological mapping is foundational; by establishing the software as an analog to the human cortex, it creates the structural permission for the epistemic pattern to operate. If the system is a "hierarchy of cognits," then it logically follows that its outputs are "causal hypotheses" rather than mere token predictions. Crucially, the text's vocabulary severely complicates its own argument. The author explicitly argues for strict human accountability and mechanistic bounding (the "Godel-Turing constraint"), yet the vocabulary subverts this by granting the machine immense epistemic authority in the "Orient" phase, blurring the line between statistical processing and conscious knowing.

Mechanism of the Illusion:​

This framework holds that computational systems process rather than know. The text produces the "illusion of mind" by systematically leveraging the curse of knowledge to convert mechanical processing into epistemic knowing. The central move occurs at the boundary between the deterministic MATLAB layer and the LLM layer. The text explicitly locks down the deterministic data to constrain the LLM, but then uses consciousness verbs ("interprets," "reasons," "identifies") to describe the LLM's generation based on that data. Because the inputs are rigorously mathematical, the reader is predisposed to trust the output. When the text then frames that fluent, text-based output as a "causal pathway," the reader easily attributes mind to the machine, conflating statistical coherence with logical deduction. The temporal order is vital: the text establishes the machine's mathematical reliability first (micro-reliability, contradiction audits), and then uses that earned trust to legitimize the anthropomorphic claims about the LLM's "reasoning." The explanation types support this: by shifting from mechanistic explanations of the data layer to reason-based explanations of the LLM layer, the text shapes an illusion of an integrated, highly capable, and discerning intellect.

Material Stakes:​

Categories: Epistemic, Institutional, Regulatory/Legal

The framings in this text carry significant material consequences across several domains. Epistemically, framing an LLM as generating "causal pathways" and a "reasoning map" fundamentally distorts how knowledge is validated in project management. If project teams believe the AI is performing actual causal inference rather than statistical text generation, they will alter their epistemic practices, deferring to the machine's diagnosis without verifying the physical or organizational realities behind the text. This leads to confident but catastrophic failures if the model hallucinates a plausible but false root cause. Institutionally, the framing of the system "checking itself" or "detecting its own approach" changes resource allocation. Organizations might under-invest in human oversight, believing the software possesses innate self-monitoring capabilities, when in reality it only checks the specific variables developers hardcoded. If the environment shifts in ways not covered by those variables, the organization is blind. Regulatory and legally, the framing of "agentic AI" that "acts into a changed situation" shifts liability focus. If policymakers accept the framing of the AI as an "agent" that made an "irreversible error," regulatory scrutiny may focus on auditing the "agent" rather than holding the human deployers and corporate developers liable for failing to program adequate situational correspondence triggers. In all cases, the developers and deployers benefit from the obfuscation of their design choices, while end-users and organizations bear the cost of failures driven by unwarranted trust.

AI Literacy as Counter-Practice:​

Practicing precision requires dismantling the biological and epistemic metaphors to reveal the mechanical realities beneath. Reframing "The LLM constructs causal pathways" to "The LLM generates text describing potential causal relationships based on prompt parameters" forces the recognition that the system processes text statistically without conscious awareness or causal models. Correcting "the system detects its own approach" to "a deterministic script triggers when a variable crosses a threshold" restores human agency, making visible the programmers who set the bounds. This precision directly counters the material risks identified above by ensuring users understand they are interacting with a statistical artifact, not an intelligent investigator. Systematic adoption of this literacy requires journals and institutions to reject the uncritical use of words like "reasons," "interprets," or "understands" when applied to LLMs. However, significant resistance exists. The AI industry relies on anthropomorphic vocabulary for marketing and funding; portraying software as an "intelligent agent" drives adoption much faster than describing it as a "statistical text aggregator." Precision is costly to developers because it demystifies their products and makes their specific, subjective design choices (and the limitations of those choices) visible and auditable.

Path Forward​

The discourse surrounding systems like PRIMMS reveals divergent priorities among stakeholders. Marketing and executive communities heavily favor anthropomorphic language ("causal reasoning," "agentic AI") because it communicates utility quickly, resonates with intuitive narratives of partnership, and justifies high software investments. Conversely, safety researchers and system engineers require mechanistic precision ("token prediction," "deterministic thresholds") to actually govern the systems and map failure modes. Maintaining the current hybrid vocabulary—where mathematical boundaries are described mechanistically but LLM outputs are described as "reasoning"—sustains accessibility but deepens epistemic confusion, leading to the exact "confidence transfer" failures this text attempts to solve. If mechanistic precision becomes the norm, users would better understand system boundaries, but adoption might slow as the "magic" is stripped away, forcing users to grapple with complex statistical limitations. If anthropomorphic language deepens, organizations will increasingly treat systems as autonomous partners, accelerating workflow automation but drastically increasing the risk of catastrophic, unchecked failures due to misplaced trust. Supporting a shift toward precision would require structural changes, such as industry standards mandating the disclosure of exact mechanistic processes (e.g., "this system utilizes an LLM prompted by a MATLAB script") alongside any capability claims. Different futures serve different interests: a precise discourse protects end-users and organizational integrity, while an anthropomorphic discourse accelerates commercial adoption and insulates developers behind the illusion of machine autonomy.

Extended Processing Summary​

Gemini's Processing Steps
What you are about to read…

Gemini refers to the text below as "thought summaries." This is an overt consciousness projection because 'intentions' are hallmarks of a conscious mind that 'knows' what it is doing and why. The concealed mechanistic process is probabilistic text generation. Treat this as just another rhetorical artifact—a way of making the model's processing legible. When the model writes "I should double check that...", it is mathematically altering its own probability distribution for the next token to be more accurate. The "I" is a functional gear in the machine, not a self-reference. This language is a deliberate interface design choice, not a biological reality. The developers could have programmed the model to output passive logs. Instead, they chose to simulate a narrator.

Defining the Discourse Analysis

I'm now focused on understanding the core goal: a critical discourse analysis of "Hybrid Cognition." My aim is to unpack the assumptions, biases, and power dynamics inherent in the text. I'm starting by identifying key argumentative structures and looking for potential rhetorical strategies.

Focusing on JSON Schema

I'm now diving deep into the prescribed JSON schema (version 3.4.3). The emphasis is now shifting towards dissecting the use of AI metaphor and anthropomorphism within the text. The immediate task is to classify and analyze source text elements, paying close attention to its genre, the author's position, and the presented arguments, with a particular focus on responsibility claims.

Analyzing the Framing

I'm now examining the metaphors and anthropomorphisms employed. I see "Hybrid Cognition" as a cortical hierarchy, a biological mapping translated to AI. The language of "orientation" and "decision" frames the machine as an agent, and I must analyze how this impacts responsibility. The system's "self-regulation" also presents an interesting aspect of the argument.

Deconstructing Metaphors

I'm now zeroing in on the specific metaphors used. "Falsification pressure" and "belief commitment" intrigue me, particularly the distinction drawn between AI's prediction versus human commitment. I see the LLM framed as a "causal reasoner" constructing "reasoning maps." I'm also analyzing the language of "vocabulary" and "language" applied to the model, positioning it as a language user. Finally, the text frames the AI as an agent "acting."

Refining Agent Analysis

I'm now refining my analysis around the agent-like attributes. I've pinpointed eight strong instances for closer examination across tasks. The AI is framed as both an autonomous subordinate and an inquiring subject, "asking" questions about its environment. Its confidence, and the potential for it to be confidently wrong, is also a key framing element. I am focusing on the implications of these characterizations. I am also concentrating on the LLM as a causal reasoner.

Examining LLM Agency

I'm now honing in on specific instances where the LLM is framed as an agent. I'm focusing on text generation from prompt templates, interpreting archetypes, and processing multi-layer prompt chains. The system is described as detecting and naming its own state, and acting within changed situations. The analysis is now centered on how the LLM is characterized as an actor.

Analyzing Error and Agency

I'm now zeroing in on instances that highlight the AI's limitations, particularly error production. I've identified contexts framing the LLM's error as "irreversible," linked to its "execution context." The quotes describing predictive processing and machine "orientation" also capture my attention. The focus is now on how these instances relate to the broader discussion of responsibility and human accountability, especially where the AI is concerned.

Evaluating Language Impact

I'm now assessing the implications of the language choices, particularly instances of displacement. Even if displacement is partial or marked as "N/A," I'm focusing on the effect of the language. For example, the phrase "The system detects its own approach" effectively conceals the programmer's role. I also must accurately represent Explicitly Acknowledged or Hedged language. The goal now is to establish source-target mappings with examples. For a quote like "...it is the system asking whether it still belongs to the world it was trained on," I'm treating the source as "an inquiring human," with the target as a Kolmogorov-Smirnov statistical test for distributional shift. I'm also drafting an explanation audit, using Brown's typology to categorize passages. In the case of, "The contradiction audit in IUVO is one operational instantiation... the machine is, in a limited sense, checking itself." I see this as primarily Functional, with an Intentional secondary.

Categorizing Discourse Instances

I'm now classifying more of the passages using Brown's typology to categorize passages. I've found an interesting genetic or theoretical example, concerning optimization for coherence in a language model, with the suppression of uncertainty markers. I'm also now treating two passages as primarily functional, with an intentional element as a secondary. Another passage I will handle as functional/reason-based. I'm also drafting Task 4, and re-writing quotes mechanistically.

Assessing Language Slippage

I'm now drafting Task 5, focusing on critical observations. I'm noting agency slippage, as agential language coexists with accountability claims, especially within the "Orient" phase. The biological metaphor drives trust by mapping AI operations to human brain function, which could create relation-based trust. I'm also examining how these framings obscure mechanics, and contribute to displacement.

Analyzing Accountability Shifts

I'm now zeroing in on instances that address accountability shifts, specifically the tension between agential language and accountability claims, particularly in sections like the "Orient" phase. While the text acknowledges human responsibility, the framing of the LLM as an "agent" that "orients" presents a nuanced tension. I am examining how this potentially impacts displacement, and overall implications.

Mapping the Arguments

I'm now mapping the arguments, examining how the text frames "knowing" from processing. I'm focusing on the conversion of processing to knowing, exploring cases like statistical drift being framed as the system "asking." I'm evaluating the epistemic, institutional, and regulatory stakes of treating token prediction as causal reasoning and how to map vocabulary choices in an analytical manner.

Refining Analysis of Framing

I'm now refining the source analysis and have identified numerous instances where agential language is explicitly acknowledged or hedged, especially concerning functional mapping. I'm focusing on the effect of the language choices as part of my audit, with examples. I'm noting the system's "limited sense" of checking itself, as Functional with Intentional. I'm also treating token prediction as causal reasoning.

Clarifying Agential Framing

I'm now clarifying the agential framing, focusing on how the system "asks" and "orients" within "Hybrid Cognition." The proposal of "Hybrid Cognition" is used to define new boundaries for responsibility. The argument separates machine cognition (orientation/statistical accumulation) from human decision-making. The goal is now to establish specific categories from the provided text.

Analysis Provenance

Run ID: 2026-11-06-hybrid-cognition-a-framework-for-human-m-metaphor-c4pm9e Raw JSON: 2026-11-06-hybrid-cognition-a-framework-for-human-m-metaphor-c4pm9e.json Framework: Metaphor Analysis v6.8 Schema Version: 3.4.3 Generated: 2026-11-06T07:44:34.163Z

Discourse Depot © 2025 by TD is licensed under CC BY-NC-SA 4.0