Roxabi
EN

AGENT COGNITION

Derived Reflexes

A derived reflex is not a rule — it is the action sequence that emerges inevitably when an agent holds the right atomic beliefs simultaneously.

Cortex

Version 1.0 · Updated

01

Beliefs, Atoms, and the Pipe

A belief expressed as a single natural-language sentence is a packet. It compresses approximately six distinct atomic beliefs — propositions that must be unpacked individually using set-algebra notation: relations between sets plus predicate logic. The unpacking is not interpretation; it is a deterministic expansion of what the sentence already claims.

A reflex is not a belief. It is the action sequence that is forced into existence when all atomic beliefs are held simultaneously. It is derived by composition — never written as a separate rule, never maintained as a gate. The pipeline operator → is functional: the output of step n is the sole input to step n+1. No global variable crosses step boundaries.

The Dilts logical-level model places beliefs at level 4 (Beliefs/Values). Reflexes live at levels 2–3 (Behaviour / Capacity). The higher level governs the lower: a correctly formulated belief at level 4 makes the reflex at level 2 automatic. This is the innate > triggered principle — an emergent reflex needs no trigger condition written separately.

Anti-beliefs — propositions of the form X ∉ Y — require no explicit prohibition. If Corr_valides ⊆ Archi and Patch ∉ Archi, then Patch ∉ Corr_valides is deduced by set containment. The exclusion is logically implied, not manually enforced. This is why belief-level correctness is more robust than gate-level correctness: gates can be bypassed; deductions cannot.

Key figures: ≈6 atomic beliefs per natural-language belief · derivation maps level 4 → levels 2–3 · 0 separate gates need to be written once beliefs are well-formed.

ATOMIC BELIEFS — LEVEL 4 C₁: obs(P) ⊊ P C₂: obs(P) ⊆ Sym(P) C₃: |Sym(P)| ≥ 1 C₄: ∃ RC(P) : Sym ⊆ effets compose DERIVED REFLEX R — LEVELS 2–3 obs(P) Sym(P) RC(P) Corr(P) NAIVE REFLEX ✗ obs(P) patch(obs(P)) skips C₁…C₄ — patches the symptom, not the cause
Atomic beliefs at level 4 compose into a derived reflex. The naive short-circuit skips intermediate steps, patching the observed symptom directly.
02

Maxims: Debugging and Operations

Three engineering maxims for the ops and debug domains. Each is given with its formal decomposition so the derivation is visible, not asserted.

R₁ "Every problem is a symptom" root-cause

Let

  • P the problem
  • obs(P) what is observed
  • Sym(P) symptom set
  • RC(P) root cause(s)
  • Corr split into Patch and Archi, with Patch ∩ Archi = ∅

Atomic beliefs

  • C₁ obs(P) ⊊ P observation is strictly smaller than the whole problem
  • C₂ obs(P) ⊆ Sym(P)
  • C₃ |Sym(P)| ≥ 1 often > 1
  • C₄ ∃ RC(P) : Sym(P) ⊆ effets(RC(P))
  • C̄₅ Patch ∉ Corr_valides anti-belief
  • C₆ Corr_valides ⊆ Archi
✓ DERIVED obs(P) → enumerer(Sym(P)) → find(RC(P)) → architect(Corr(P))
✗ NAIVE obs(P) → patch(obs(P)) — seeing a symptom and patching it is a workaround, not a correction.
"An exit code reports; it does not judge" ops / CI

Beliefs

  • G a gate or scanner
  • exit(G) ≡ ranOK exit 0 means "ran without crash", not "nothing found"
  • verdict(G) ⊥ exit(G) the verdict is orthogonal to the exit code
  • found(G) ≠ ∅ ⇏ exit(G)=broken anti-belief
  • verdict(G) ∈ report(G)
✓ DERIVED run(G) → exit := ranOK → write(verdict→report) → gate reads report
✗ NAIVE found ≠ ∅ → exit ≠ 0 → set -e short-circuits the pipeline — the CI never reaches the report, and findings are lost.
"Do not diagnose a hang from a short snapshot" debug

Let

  • H hang hypothesis
  • w observation window
  • D expected task duration

Atomic beliefs

  • C₁ obs(w) where w ≪ D ⊄ preuve(H) too short a window does not constitute evidence
  • C₂ silence(w) ⊆ {hang, work-in-progress} silence is ambiguous
  • C₃ |causes(silence)| > 1 futex_wait + zero IO ≠ deadlock
✓ DERIVED suspect(hang) → set w := D → mesurer(w) → conclude
✗ NAIVE obs(1s) → conclude(hang) — a one-second absence of output is not a hang.
03

Maxims: Security, Concurrency, and Fix-Agents

"Every input is hostile until proven otherwise" security

Beliefs

  • I input
  • trust(I) = ⊥ by default
  • valid(I) ⇒ trust(I) only explicit validation elevates trust
  • I ∉ trusted ⇒ I ∉ {query, exec, render} anti-belief
✓ DERIVED receive(I) → validate → sanitize → use
✗ NAIVE receive(I) → use(I) — treating arrival as authorization.
"Verify the canonical source after a push" concurrency

Beliefs

  • S shared state
  • report(success) ⊊ vérité(S) the success report is a proper subset of ground truth
  • ∃ concurrent mutators S can drift between the push and the next read — other sessions, auto-merge, or CI can mutate S mid-task
✓ DERIVED push → re-read(canonical(S)) → assert → continue
✗ NAIVE push → trust(report) → continue — acting on a snapshot that may already be stale.
"Verify the target exists before applying a fix" fix-agents

Beliefs

  • T target file
  • F fix
  • existence of T is a precondition for apply(F)
  • ¬exists(T) ⇒ apply(F) is invalid — correcting an absent target is the silent revert of a strategic decision
✓ DERIVED receive(F) → assert exists(T) → else escalate → apply(F)
✗ NAIVE receive(F) → apply(F) — creating a file that was deliberately deleted.
04

Maxims: Refactoring, Tests, and Dependencies

"An abstraction earns its name at three uses" refactoring

Let

  • A abstraction
  • uses(A) set of usage sites

Atomic beliefs

  • C₁ |uses(A)| ≥ 3 ⇒ A justified three independent uses validate that the abstraction has a stable boundary
  • C̄₂ |uses(A)| < 3 ⇒ A ∉ justified coupling cost exceeds benefit below three uses
✓ DERIVED repeated pattern → count(uses) → if ≥ 3 abstract → else duplicate
✗ NAIVE pattern seen 2× → abstract immediately — premature abstraction couples two sites before the boundary is known.
"Every untested code is presumed broken" tests

Beliefs

  • C code
  • ¬tested(C) ⇒ correct(C) unknown
  • "it compiles" ∉ proof(correct) anti-belief
  • |paths(C)| > 1 in any non-trivial function
✓ DERIVED write(C) → enumerate(paths) → cover → green
✗ NAIVE write(C) → ship — compilation is not correctness.
"Every dependency is a debt" dependencies

Beliefs

  • D dependency
  • coût(D) = {attack surface, mandatory updates, CVE exposure, transitive graph}
  • adding D unconditionally increments that debt
  • "it's free" is false for any non-zero transitive closure
✓ DERIVED need → seek(stdlib) → else evaluate coût(D) → pin → justify
✗ NAIVE need → install immediately — treating convenience as zero-cost.
05

The Meta-Maxim: Correct at the Right Logical Level

"Correcting at the same logical level is a loop" meta

Let

  • L current logical level
  • fix@L applying a correction at level L

Atomic beliefs

  • C₁ recurring problem @L ⇒ probable cause @L+1 recurrence at a level points to a structural fault in the level above
  • C̄₂ fix@L on a cause @L+1 = palliative the symptom returns because the cause is untouched
✓ DERIVED recurrence@L → ascend(L+1) → fix@L+1
✗ NAIVE recurrence@L → re-fix@L — a saga of fifty commits over thirty-six hours, all at the tactical layer, never closes a structural debt. The loop continues until someone climbs a level.

This is the closing principle of the framework. It applies to every other maxim. When a reflex keeps failing, the fault is not in the reflex — it is in the beliefs at level 4. The correct move is to reformulate the belief one level up, then re-derive the reflex. The reflex is downstream; the belief is the root.

When a reflex misfires repeatedly: do not patch the reflex. Climb one level, inspect the belief, reformulate it, re-derive. recurrence@L → ascend(L+1) → fix@L+1.

06

The Grammar of Derivation

The derivation is mechanical, not interpretive. Each logical form of an atomic belief maps to a specific step type in the reflex. The table is the grammar.

FORM READING BECOMES IN THE REFLEX X ⊆ Y every X is Y a filter / guard X ⊊ Y X is a proper part of Y widen before acting X ∉ Y anti-belief / exclusion refusal / escalation ∃ x : P(x) existential search until found ∀ x : P(x) universal cover everything |X| > 1 cardinality ≥ 2 enumerate, not just first
Every logical form in the belief set maps mechanically to a step type. The grammar removes ambiguity from the derivation.

The four-step derivation algorithm applies this grammar to any belief set:

  1. Order atomic beliefs by data dependency — obs(·) first, act(·) last. The sequence reads from observation to action.
  2. Translate each belief into a step using the grammar above: ⊆/⊊ → transformation · anti (∉) → guard · ∃/∀ → search or coverage · |·| > 1 → enumeration loop.
  3. Chain steps with →. Output of one step is input to the next. No global variable.
  4. Name the naive reflex — the direct obs → act short-circuit — to make the gap visible and the drift conscious.
1 Order by data dependency — obs(·) first, act(·) last 2 Translate form → step type (⊆→filter, ∉→guard, ∃→search, |·|>1→loop) 3 Chain with → (functional pipe — no global variable) 4 Name the naive reflex — obs → act direct — to make drift visible NAIVE ✗ obs→act
Four deterministic steps turn any well-formed belief set into a derived reflex. Step 4 — naming the naive short-circuit — is what makes the engineering gap legible.

Taxonomy anchor: this model feeds directly into the Cortex entity taxonomy — Belief | Value | Principle | Sentiment. Beliefs live at level 4 and are stored as first-class entities. Reflexes live at levels 2–3 and are never stored as independent entities — they are derived on demand from the belief graph. Conflating the two is the original category error this framework exists to prevent.

07

What This Demonstrates

Five findings from the analysis of nine engineering maxims across six domains:

  1. A natural-language belief ≈ 6 atomic beliefs. Spoken language compresses semantic content that must be explicitly unpacked before a correct reflex can be derived. The compression is not a flaw — it is the reason derivation is necessary.
  2. Decomposition surfaces anti-beliefs automatically. Propositions of the form X ∉ Y are not written as prohibitions; they emerge from set containment. The exclusion is logically entailed, not manually guarded — which makes it robust against the guards being removed.
  3. The reflex emerges from beliefs by composition. No separate gate, no separate rule, no separate trigger condition needs to be written. The pipe is the reflex. Innate > triggered.
  4. Correct beliefs at level 4 are more robust than guards at levels 2–3. A guard can be bypassed. A deduction cannot. Formulating the belief correctly is the upstream investment that eliminates downstream patching.
  5. Reflexes are never stored as independent entities. In the Cortex taxonomy, reflexes are derived on demand from the belief graph. Storing a reflex independently would decouple it from its beliefs, making it unverifiable and unmaintainable.

The practical implication: when a reflex misfires, do not debug the reflex. Audit the beliefs. Find the atom that is missing, imprecise, or at the wrong level. Reformulate it. The correct reflex follows.