Cognitive Framework

The Problem: Reasoning Without a Frame

Without an explicit cognitive frame, an agent has no gradient that tells it to shift levels. It keeps patching at the current logical level, never asking the only question that matters: are we fixing the right layer?

A real failure makes this concrete. A quality-debt saga produced fifty commits in thirty-six hours, all at the tactical layer — every code review yielded findings, every fix yielded code, every round regenerated the same findings. Three signals converged: high commit volume at a single logical level, issues that visibly needed to climb one level to be diagnosed, and zero mechanism anywhere in the loop to signal that escalation was even available.

The goal is a frame that makes the right reflex innate — a property of the entity being reasoned about — rather than a procedural rule someone has to remember to apply.

D1 — Searle: Typing Cognitive Entities

John Searle's speech-act taxonomy supplies the first layer. Four entity types, each with a distinct direction of fit — and therefore a distinct natural correction when it conflicts with reality.

Belief (assertive) — fit is word→world. If a belief contradicts reality, the belief is wrong; the correct action is to revise it.
Value (directive/commissive) — fit is world→word. If reality violates a value, reality is wrong; the correct action is to act to restore the world. This is the climb signal.
Principle (declarative) — fit is constitutive (both). Conflicts require an explicit decision protocol.
Sentiment (expressive) — no fit to correct.

Misclassifying a Belief as a Value is the exact mechanism behind the quality-debt saga: « annotation density equals quality » was treated as a Value, so the agent acted to make the world match a false belief instead of revising the belief. Searle's typing is not a label — it is a map of natural reflexes per type.

Direction of fit as a reflex map. The Value row is the one that signals « climb »: when reality violates a value, the correct move is to act on the world, not to revise the value.

D2 — Husserl: The Schema of Each Entity

The second layer gives every entity a structural schema, drawn from the noetic/noematic decomposition of Husserl's phenomenology: (believer, content, context, stance, fit_direction).

believer — an ActorRef: who holds this entity (self, an agent, another actor).
content — a SetExpr, strictly positive: what is held, formalised as a positive assertion, never a negation.
context — a ContextRef or null: Husserl's Lebenswelt, the world-context in which the entity makes sense (work:roxabi, meta:framework).
stance — active | dormant | abandoned: the phenomenological act-state.
fit_direction — inherited from D1, bridging the typing to the schema.

The schema is what makes every entity queryable across typed fields — the precondition for indexing, deduplication, and targeted retrieval once the graph holds thousands of nodes.

D3 — Tulving & Hippocampal Memory: The Lifecycle

The third layer is Endel Tulving's episodic→semantic consolidation model: the lifecycle of a cognitive entity from first observation to stable, semantic knowledge.

formed_from — a list[ObservationRef]: episodic provenance. Every entity traces back to the raw observations that formed it.
strength — a float in [0,1]: hippocampal memory strength, raised by reinforcing observations, used to weight salience.
decay_sigma — the forgetting rate. Axioms (Principles with decay_sigma:0, strength:1.0) never decay; episodic beliefs fade unless reinforced.

The consolidation path runs from many episodic references to fewer, stronger semantic entities — how raw experience becomes stable conviction. At scale, a single decay_sigma field decides which memories survive, with no manual curation.

The Unified Entity Schema

The three layers compose into one schema. Each field names the layer it comes from.

Entity schema

id            : ULID
type          : Belief | Value | Principle | Sentiment   # D1 Searle
believer      : ActorRef                                 # D2 Husserl (noèse)
content       : SetExpr                                  # D2 Husserl (noème)
context       : ContextRef | null                        # D2 Lebenswelt
stance        : active | dormant | abandoned             # D2
fit_direction : word→world | world→word | both | none    # D1
strength      : float [0,1]                              # D3 hippo-memory
formed_from   : list[ObservationRef]                     # D3 Tulving (episodic)
decay_sigma   : float                                    # D3
derived_reflex: ReflexRef | null

Three canonical instances show the range: a Belief (obs(P) ⊊ P, word→world, strength 0.85), a Value (valid_corr(P) ⊆ Arch, world→word, strength 0.90), and an axiomatic Principle (∀ c ∈ Beliefs: c ∈ Positives, both, decay_sigma:0, strength 1.0). The schema is the operational bridge between philosophy and a queryable knowledge graph.

D1 types the entity, D2 gives it structure, D3 governs its lifecycle. Dilts' six levels are not a fourth layer — they emerge from the properties of these three.

D1+D2+D3 vs. Dilts' Logical Levels

Robert Dilts' six Logical Levels (Environment, Behaviour, Capability, Beliefs/Values, Identity, Mission) offer a familiar vertical vocabulary where level N+1 governs level N. But as a spine they need bolt-ons: an entity schema (D2), a belief/value/principle/sentiment distinction with failure-mode semantics (D1), lifecycle and decay (D3), actor/target axes, and escalation mechanics. Counted out, Dilts-as-spine stacks seven sources; D1+D2+D3-as-spine needs three — two of which already exist in the codebase.

The decisive point is that Dilts' levels emerge from D1+D2+D3 properties: Environment = factual observations; Behaviour = reflexes derived from Values; Capability = active Values and skills; Beliefs/Values = D1 Beliefs and Values; Identity = Principles with believer:self:*; Mission = Principles with decay_sigma:0 and strength:1. What Dilts keeps exclusively is the narrative intuition — « when X is stuck, climb a level » — and even that is captured formally by Bateson's Type I→II learning, without importing NLP's contested foundations. Tulving and Searle rest on decades of literature and align with current AI work (Constitutional AI, MemGPT, generative agents); Dilts has no echo in that research.

Fewer primitives, more coverage: three sources (two already in place) generate what Dilts needs seven to assemble — and the six levels fall out as derived properties.

Practical Payoff for Agent Design

The framework earns its place in four concrete ways.

Innate escalation. Because fit_direction lives on the entity, the correct reflex is a property, not a procedure. A Value violated by reality signals « act to change the world » with no external trigger.
Failure diagnostics. Any stuck loop — repeated fixes at one level, metric gaming, an unfalsified assumption — is diagnosed by one question: what type was this entity, and was the reflex appropriate to that type?
Scale. At a hundred entities, the nine-field schema and a tag string are indistinguishable. At five thousand, indexing, dedup, and decay-driven forgetting are structural needs the schema meets and the tag cannot.
Convergence. Structured memory plus intentionality is the direction current AI memory research is taking; the model sits inside that conversation rather than beside it.

Bateson and Kegan enter only as vocabulary: Type I/II/III names the level-climbing gesture; subject→object names the moment an implicit belief becomes an explicit, manipulable skill. Reference terms — not additional architectural layers.