Most modern AI systems look impressive—until the problem shifts slightly. A small change in context, a new combination of known elements, or an implicit contradiction is often enough to break otherwise strong models. This article explores a concrete hypothesis: that robustness under such shifts depends not only on model size or training data, but on a missing internal capability—how deeply a system can process contradictions. We call this capability Vertical Cognitive Depth (VCD) and examine how a structured reasoning process (A11) may help expose and partially compensate for its absence. Neural networks are highly effective within the distribution they were trained on. However, they often struggle when: Inputs differ slightly from training data (distribution shift) Known components appear in new combinations The task requires resolving implicit contradictions This is commonly referred to as out-of-distribution (OOD) generalization failure. Standard metrics such as: accuracy perplexity benchmark scores do not reliably predict how a model behaves under these conditions. In practice, two models with similar architecture and performance can show qualitatively different reasoning stability when faced with novel or conflicting inputs. Empirically, many failures share a pattern: The model encounters a conflict between constraints and available knowledge Instead of resolving it, the model implicitly smooths or ignores the contradiction A plausible but incorrect answer is produced This suggests that the failure is not only about missing knowledge, but about how the model handles internal inconsistency. We introduce the concept of Vertical Cognitive Depth (VCD): The capacity of a system to detect, maintain, and transform contradictions between constraints and knowledge without prematurely resolving them. Key properties: Not model depth (number of layers) Not context length Not chain-of-thought length Instead, VCD describes the ability to: Detect a contradiction Hold it explicitly (without collapsing it into a guess) Use it to generate a revised direction or framing In this sense, VCD is a latent behavioral parameter rather than a directly measured architectural feature. Current proxies for reasoning ability fail to capture this dimension: Perplexity measures prediction quality, not conflict handling Accuracy hides internal failure modes Chain-of-thought length measures verbosity, not depth A model may produce long explanations while still collapsing contradictions early. Thus, none of these metrics reliably indicate whether a system can sustain structured reasoning under tension. A11 is a structured reasoning protocol that separates: S1 — Direction (intent / goal) S2 — Constraints (limits, risks, conditions) S3 — Knowledge (available information) The critical step is: S4 — Explicit integration, where conflicts between S2 and S3 are surfaced In unstructured reasoning, this conflict is often skipped or implicitly resolved. explicit detection of inconsistency delayed resolution possible revision of S1 (goal or framing) This does not increase the model’s knowledge, but changes how it navigates gaps. It is important to be precise: In its current application, A11 does not modify model weights It does not introduce new knowledge It does not yet eliminate out-of-distribution limitations However, this is a limitation of how A11 is currently used (as an external reasoning scaffold), not necessarily a fundamental limitation of the approach itself. Even in its current form, A11 can: reduce premature convergence to incorrect answers increase transparency of failure modes enable construction of solutions from partial knowledge In other words, A11 may improve behavior under uncertainty, even if it does not yet increase underlying generalization capacity. This distinction matters: changes how models behave when generalization fails. A11 can be interpreted as an external mechanism that simulates VCD-like behavior: VCD capability A11 mechanism Detect contradiction S2 vs S3 comparison Hold contradiction explicit S4 step Transform contradiction revision of S1 This suggests: Systems with low intrinsic VCD may benefit from structured reasoning scaffolds that enforce conflict retention. For VCD to be meaningful, it must be testable. A minimal experimental setup: Construct tasks with deliberate tension: conflicting constraints incomplete knowledge ambiguous goals Measure: whether the model explicitly detects contradiction how long it maintains it before resolution whether it revises its approach Compare across models with similar standard metrics Hypothesis: VCD-like behavior will better predict robustness than accuracy or perplexity alone. If validated, VCD would suggest: A missing dimension in evaluating reasoning systems A way to distinguish surface competence from structural stability A design target for both prompting methods and training objectives It also reframes some failures: Not as lack of knowledge But as failure to process contradiction Conclusion Modern AI systems often fail not because they lack information, but because they cannot sustain reasoning when information conflicts. Vertical Cognitive Depth (VCD) is a hypothesis that attempts to capture this missing capability. Structured reasoning frameworks like A11 do not solve generalization directly, but they expose and partially compensate for this limitation by forcing explicit interaction with contradictions. Whether VCD represents a new measurable property or a reformulation of existing ideas depends on one thing: the ability to turn it into a reproducible test. Until then, it remains a useful lens for analyzing why strong models sometimes fail in simple, unfamiliar ways. The following specification is included to make the A11 reasoning model explicit and interpretable, especially for systems that rely on structured representations of reasoning processes. S1 — Will S2 — Wisdom S3 — Knowledge Signals from S2 and S3 are processed in parallel and passed to S4. S4 INTEGRITY is the central rule. S4 receives signals from S2 and S3. Order, speed, and depth do not matter. maximally honest. If full honest integration is not possible: It is forbidden to smooth tension, fabricate coherence, or close contradictions artificially A TensionPoint must be explicitly identified (a concrete gap between S2 and S3) A new S1 (fork, not replacement) must be generated strictly from this TensionPoint It is forbidden to: paraphrase the original S1 generalize it loosely produce a semantically equivalent goal The new S1 must be: sharper more specific more operational The Integrity Log is an append-only mechanism for recording structural breaks. Each entry contains: S2_signal S3_signal TensionPoint (explicit contradiction) Reason (why integration failed) NewS1 (generated fork) Hash(prev) — reference to previous entry Timestamp Properties: Append-only Hash-linked chain (tamper-resistant) No deletion of history Acts as an internal validator of reasoning integrity In a full A11 pass (S1–S11): All levels S5–S10 are mandatory Skipping any level is not allowed Transition to S11 is only valid after explicit traversal of all six levels If S5–S10 are not completed: The system must explicitly state the reason Absence of a reason = structural violation Lite Mode (S1–S4): S5–S10 are skipped Activated only via Switch Flags Otherwise, full pass is the default ┌───────────────────────┬───────────────────────┐ │ Projective Layer │ Practical Layer │ │ S5 S6 │ S8 S9 │ │ (Freedom / Constraint)│ (Freedom / Constraint)│ │ ↑ │ ↑ │ │ Balance (S7) │ Balance (S10) │ └───────────────────────┴───────────────────────┘ Signals initiated in S4 propagate into S5–S10 Core processing occurs here Fractality applies only within pairs: S5–S6 S8–S9 Depth of branching depends on: context efficiency cost constraints S11 INTEGRITY: Realization evaluates alignment with the original S1 (Will). Possible outcomes: Acceptance Rejection Transformation Escalation into a new pass S11 may incorporate data from the Integrity Log. S1 → (parallel signals) S2 — Wisdom S3 — Knowledge ↓ ↓ S4 — Comprehension (integration + TensionPoint + Integrity Log) ↓ S5–S10 — Operational Layers (projective + practical + fractal processing) ↓ S11 — Realization S1–S3 form an immutable core S4 is the honest integrator Failure at S4 is a signal, not an error Adaptive Pass Depth: After S4, perform reflection: “Can this result be justified via S2 as strongly as via S3?” If not (S3 dominates): Initiate a second pass (S5–S11) Generate S1_new strictly from TensionPoint S1_new must: be sharper not semantically repeat the original Goal: strengthen S2 generate new meaning Reflection result must be recorded in the Integrity Log Additional rules: Rollback allowed only to S1–S3 All structural breaks are preserved in the Integrity Log Switch Flags are external control signals that determine whether: Lite Mode (S1–S4) is sufficient or a Full Pass (S1–S11) is required A11.SwitchFlags { RiskFlag, ConflictFlag, UncertaintyFlag, ValueFlag, UserDepthFlag } Full A11 is activated if: RiskFlag is active OR ValueFlag is active OR UserDepthFlag is active OR (ConflictFlag + UncertaintyFlag) are both active Otherwise: Lite Mode (S1–S4) is used No Integrity Log is recorded RiskFlag — prevents failure in critical decisions ConflictFlag — detects S2–S3 inconsistency UncertaintyFlag — signals insufficient data ValueFlag — protects constraints and priorities UserDepthFlag — explicit request for deep reasoning This specification is included to ensure that the structural assumptions behind A11 are explicit, reproducible, and interpretable across different systems and contexts. Algorithm 11 (A11) https://github.com/gormenz-svg/algorithm-11