Cognizer

The locus of adaptation

Human intelligence advances by changing what can be thought, not only by answering better within what already can be. Machine intelligence has moved in the opposite order.

Foundation models learn representations. Agents learn actions. Recursive systems improve their own procedures. But the abstractions those systems reason with, the way they formulate a problem, and the standard they hold evidence to are all inherited from us. The locus of adaptation — the highest-level structure a system can change through experience rather than receive — has risen steadily, and stopped short of the structures that generate cognition itself.

The boundary that matters sits between L3 and L4. An L3 system recursively improves how it executes cognition; it searches better, reasons longer, picks better tools. An L4 system recursively improves how cognition is generated. The first finds better answers inside a space. The second changes the space.

That difference has a consequence which shapes everything below. In optimization, a bad step is corrected by later data. In cognitive recursion, a structure admitted on bad evidence changes which questions get asked next, and therefore which evidence is collected. The error is not corrected by later data — it selects the later data.

So the admission rule — what a system is allowed to treat as established — is not a safety feature attached to the loop. It is the condition under which the loop converges on anything at all. Most of the design that follows is a consequence of taking that seriously.

An architecture for an explicit regime

Crossing the L3/L4 boundary requires less autonomy than it requires explicitness. A system cannot evolve structures it never represents. A regime is defined by its available abstractions, how it formulates problems, what it accepts as evidence, and how it explores — and in most systems all four are latent in the weights, inaccessible to inspection and therefore to revision.

The first move is to make those four into data. The Cognitive Brain below does this for a frozen model: a problem's decomposition is constructed while the problem is being solved, rather than fixed before it is read.

What may become a premise

A problem is represented as a demand anchor: a goal, plus a three-way split of the propositions around it. Established is usable as a premise. Unobserved is not established but could be, by consulting something outside the model. Open is neither, and must be settled by checking.

The second distinction is the one that does work. Failures on hard problems are mostly not errors of inference. They are sound inferences from propositions nobody established — a bandwidth figure assumed rather than measured, a scene fact presumed rather than observed. Collapsing “not yet looked up” into “uncertain” makes those indistinguishable downstream, though they call for different remedies: one is settled by reasoning, the other only by going and looking.

An anchor is not decomposed while anything is still unobserved, because decomposing around a hole produces sub-problems whose checkability depends on information nobody has. How that set gets emptied turned out to be the most consequential decision in the design.

An early version asked the model to fill the gaps and moved its answers into the established set. Its failure mode was characteristic: the system did not produce obviously wrong answers. It produced well-structured answers resting on a fabricated figure introduced three levels above, with every subsequent step correct with respect to it. Internally consistent, and unfounded — precisely the pathology that cognitive recursion amplifies.

The rule now separates proposing from observing. Only a source outside the model — a query against a real store, an instrument, a person answering through a real interface — produces a premise. The model may still propose, and its proposals are kept as obligations rather than discarded. A plausible proposal is frequently the right one; recording it as something to check preserves it while denying it the authority of a fact. The whole difference is in what the rest of the system may then do with it.

Units small enough to check

With a backbone chosen, the anchor expands into an ordered chain of minimal empirical logic units. A unit is one claim, scoped narrowly enough to be checked on its own.

Minimality is defined by verifiability, not by length. A step that cannot be checked without first resolving the rest of the problem is too large, and whatever is wrong inside it will surface only after the solution has been built on top of it. The test when expanding an anchor is not “is this a reasonable next step” but “could an independent party determine whether this is true, given only what is stated here.”

Each unit carries evidence in three channels, named for their roles in attention. V is direct support. K is the assumptions the claim rests on — testable, not yet tested. Q is material from another field that might transfer by analogy. The separation keeps a distinction prose collapses: “the design meets the power target” backed by a measurement and the same sentence backed by an assumption about clock gating are different claims, and a checker that cannot see which it has is reduced to judging plausibility.

The channels also have distinct fates. V is what a checker confirms against. K is what descends — when a unit becomes a sub-problem, its assumptions become the next level's open set, so the unexamined parts of a claim are exactly the agenda beneath it.

That dashed edge is worth separating from the familiar idea of retrying. A rejected unit is neither re-attempted against the same decomposition nor patched in place. The objection — a counterexample, an unmet requirement, a missing case — becomes the open question of a strictly smaller problem, attacked with its own backbone and its own evidence. The information content of a good rejection is high, and treating it as a specification rather than as an error is what turns that information into structure.

What “checked” is allowed to mean

Verification is the only thing that discharges a unit, which puts the weight of the design on what counts as verification.

Checking happens at two levels: each unit, and separately the assembled answer against the node's original objective. The second is not redundant. Units that are individually sound routinely compose into an answer that misses the goal — a design where every component is justified and the system still fails its target is the ordinary case in engineering, not an exotic one. A procedure that checks only its parts inherits that failure invisibly, because every local check reports success.

A verdict is admissible only if a check of sufficient standing actually ran, it addresses the whole stated objective, it is correct against its cited evidence, and it does not claim more than that evidence supports. Confidence, where a checker reports one, is kept for inspection and appears nowhere in that rule.

That exclusion was learned. An earlier version admitted a unit when a blended confidence score cleared a threshold, with the checker's assessment as one term in the blend. Fluent answers that nothing had checked got through, and the blend made it hard to see: the score was high because the generator was confident and the reviewer agreeable, and no quantity in the system recorded that no check had occurred.

So “nothing ran” is represented explicitly, and distinguished from “something ran and disagreed.” A unit in the first condition is neither admitted nor recursed on — recursion is justified by an objection, and an absence is not one.

Recursion, and what it costs

The result is a tree, but nothing fixes its shape. Depth, breadth, and where each branch stops are decided by what the checks say and what the budget allows.

solve(anchor):
  supplement until nothing is unobserved
  if nothing is open:  discharge with one check; return on success

  repeat up to a bounded number of times:
    activate a backbone;  expand into units
    for each unit:
      gather V / K / Q evidence
      unknown block  → reframe from another field, then check
      stable         → check; on failure it becomes a sub-demand
      sub-demand     → solve(child)
                       if the child passes, re-check it
                       against this node's own obligation
    if every unit passed:
      assemble the answer; check the whole answer
      passed → return verified
      failed → discard the decomposition, not the answer

  return partial — what passed, and what is still open

A child's success is not the parent's success

A sub-problem is carved out to discharge something specific, and it can be solved exactly as posed while leaving that obligation unmet. The child was given a narrowed question; the parent needed an answer to the original one. So a passing child's result is attached to the parent's unit and that unit is checked again, against the parent's wording. In the run below this is the fourth of five checks, and it is redundant with none of the others.

Failure discards the decomposition, not the answer

When the whole-answer check fails, the node does not edit its prose. It records the objection and the backbone that produced it, and expands again from a different angle. The failure is treated as evidence that the decomposition was wrong.

Spending that can be accounted for

Recursion with unbounded branching is an expensive loop, and the costs are not hypothetical — a single verification by a tool-using agent can run for minutes and consume six figures of tokens, and a node that re-decomposes pays for its chain again.

Grounding cognition in the world

Every guarantee above is conditional on something being able to answer a question. A system reasoning over text alone has almost no such source. Supplementation still terminates, but it terminates by moving everything into the open set: assumptions descend as the next level's open questions, the tree deepens, and nothing is ever discharged empirically.

The architecture does not fail loudly in that condition. It produces increasingly careful accounts of how much it has not established.

This gives the hardware a cognitive job description rather than an engineering one. Perception — placement, modality, latency, channel — sets what can be seen and at what price per observation. Since observations are charged against the same allowance that pays for reasoning, an observation costing more than what remains is not merely expensive but unavailable: the item it would have settled stays open, and the recursion descends instead. Beyond some round-trip cost the system begins to prefer argument to measurement, which is the substitution the whole design exists to prevent.

Intervention handles what perception cannot reach. An open item is open precisely because looking harder does not settle it — whether a design holds under load, whether a grasp succeeds on an unfamiliar object. Those are settled by arranging a situation that discriminates between the possibilities, which is acting rather than observing.

One consequence is counterintuitive. A real environment that does not cooperate is a requirement, not a hazard: the recursion is driven entirely by objections, so an environment that only ever confirms produces a system that never restructures. A simulator tuned until the agent performs well has, by this measure, been degraded.

Evidence

We have instrumented runs for the admission machinery and partial evidence for the decomposition claim. The rest is specified and not yet measured, and the tables below mark which is which.

One task, five checks

The checker was a tool-using agent in a sandbox, free to write and execute its own tests. Only the files listed for review were copied in; inputs were hashed before and after, so an agent that repairs the candidate it was asked to assess invalidates its own run. The task: an implementation of ceil_div(n, d) correct for all n ≥ 0, d > 0, rejecting d ≤ 0.

Check 1 returns a counterexample rather than a score, and that counterexample becomes the child's open question — what descends is the specific failing input, not an instruction to try harder. Checks 2 and 3 are the two levels applied at the child. Check 4 is the step a flat procedure omits. Check 5 closes the root. Across the wider experiment the agent ran seven times, consuming 467,819 input tokens (319,616 cached), 7,801 output tokens, and about 695 seconds.

Refusing to discharge the objective

The most informative result came from a case that did not pass. On a chip-design objective the agent built and executed a throughput and power model, reporting a peak of 8.192 TOPS and, under an assumed 0.5 W envelope, 16.384 TOPS/W. The arithmetic was sound and the model genuinely ran. But absent RTL, a process design kit, or physical measurement, the objective concerned a physical artefact that an executed parameter model is not evidence about. The verdict recorded was inconclusive, and the unit stayed open.

A two-valued notion of verification has only bad options here. Admit it, and a chip design is reported as verified on the strength of a parameter sweep. Reject it, and a legitimate analysis is discarded along with the bound it produced. The ordering lets the system keep what the simulation did establish — a result under stated assumptions — while refusing to let it discharge a claim about hardware. The assumed envelope stays an assumption, so a later reader can see which number was supposed and which was computed.

Reserved: comparative results

What would change our mind

Four commitments carry the design. The decomposition is chosen per node and reshaped by what fails, rather than fixed before the problem is read. Models may propose, but only something outside the model turns a proposal into a premise. A result is discharged when a check of sufficient standing says so, never when a number is large enough. And every surviving result carries the provenance of its check, so what crosses between attempts is bounded by what was actually established.

Each costs something, and the costs are of a kind. Strict supplementation leaves open obligations a more permissive method would have closed, so intermediate states look less finished. Two-level verification doubles the checking of a node that would have passed anyway. Re-decomposition discards work that was locally correct. Separating evidence by standing forbids a strict run from drawing on a large store of cheaply obtained experience. In each case the method pays — in visible progress, or in tokens — for a guarantee about what it is entitled to assert. That is the right trade only if confident unfounded answers are more expensive than slow ones. For the problems that motivate this work we think they are, but that is a judgement about the domain rather than a result.

Two limits are structural. A checking agent picks its own tests, and while we can validate that a check of the claimed kind ran against unmodified inputs with retrievable evidence, we cannot determine whether those tests were sufficient; nothing in the design closes that, and a system whose guarantees rest on its checkers inherits their blind spots. And the pattern library is a prior whose value is unmeasured — we describe it as attention over a window, and what is implemented is an ordered prompt with self-reported relevance.

The sense in which this is self-improving is narrow, and worth repeating because the term invites a stronger reading. Between attempts the repertoire grows, the ordering changes, and the starting ground improves. The model is untouched, nothing is trained, and no capability is added that was not there at the first attempt.

We began by asking whether machines can participate in the evolution of thought rather than only operate within its results. This does not settle that. It proposes that the participation has a precondition which is unglamorous and specific: a system may evolve the structures of its own cognition only to the extent that it can say what it has actually established, and how.