Notebook

Could the four axes shape reasoning itself?

Status — thinking out loud This is an untested hypothesis, written down because the logic holds up, not because it's been shown to work. It is not a proposal, not a roadmap item, and not part of the DEBT standard — the spec, reasoning, protocol and cases pages are the standard; this is a thread I'm pulling next to it. The single experiment that would confirm or kill it is near the top of the page, on purpose.

The protocol page is about gating an action before it happens. Writing it, a bigger question kept surfacing and wouldn't sit down: if DEBT can gate a decision, could the same four axes shape the reasoning that leads to one? It's a tempting thought, and tempting is exactly the thing the Trap axis warns about — so this page tries to do the opposite of get excited.

The one test, first

Everything below is only worth reading if this experiment comes back yes, so it goes first. The whole idea reduces to a single question:

Does a multi-axis cost signal route reasoning better than one good scalar? If a four-number cost doesn't beat a single confidence number at deciding where to spend effort, the extra axes are vocabulary, not mechanism.

It's cheap to run and needs none of this platform — no DEBT corpus, no agents, no Engine. Take any task where correctness is checkable. Attach cheap proxies for two axes that genuinely differ in what you'd do about them: reversibility (can this step be undone) and downstream-weight (how much leans on it). Then compare two policies: route on the vector (checkpoint the irreversible step, spend extra compute on the load-bearing one) versus route on a single confidence number. If the vector wins measurably, the multi-axis structure is the reason — and only then does this earn more than a notebook page. If it ties the scalar, the answer arrived cheaply and a pillar was saved.

Two versions, and only one is interesting

The idea splits the moment you look at it, and the half that feels biggest is worth the least.

The weak version is the exciting-sounding one: a model scores its own reasoning on d/e/b/t as it goes, and gates on the result. This is self-grading with the same pen. The thing producing the score is the reasoning you're trying to discipline, and models are famously badly calibrated about their own correctness — confident exactly when they shouldn't be. So a model scoring its own inference doesn't give an independent signal; it gives a correlated one. It's the protocol page's scorer problem, but worse, because a reasoning "step" has no clean boundary to score the way a discrete tool call does. This version feels like a model growing a conscience and is mostly noise wearing four letters.

The strong version is narrower and might be real: DEBT not as something the model computes about itself, but as an external multi-axis cost signal — at training or inference time — that routes to a different remedy per axis. This is where the four axes might earn their keep, and the reason is the one rule DEBT never gives up: no collapse to a single number.

Note — scalar vs vector routing A scalar cost c ∈ [0, 1] supports exactly one response: scale caution by c. A vector (d, e, b, t) supports four — one per axis: high e → checkpoint the step; make it reversible high d → insert a verification step before trusting it high b → spend more compute; everything downstream leans here high t → distrust this path because it looks clean A single confidence number cannot tell these four situations apart — it can only say "be careful." The claim under test is that the routing the vector enables beats the routing the scalar allows. That, and nothing more.

Why the logic holds (and what that caps)

This isn't empty territory, which is both the reason to take it seriously and the reason not to oversell it. "Reasoning should be modulated by the cost of being wrong at each step, not just by what's probable next" is already, in pieces, one of the things making models better: process and verifier reward models that grade reasoning steps, selective prediction (knowing when to abstain), and adaptive test-time compute (spending more thinking on harder steps). The instinct has good company.

That company cuts both ways. It means the direction is sound — and it means a chunk of "DEBT into reasoning" is describing improvements the field is already getting under other names. So the honest ceiling on the idea isn't "this invents step-cost reasoning." It's "this proposes that decomposing step-cost into independent axes routes behaviour better than a single signal does." Narrower, and the only part that would be new.

The borders

Three limits, stated plainly, because a thinking page that hides them is just a proposal in disguise.

Self-scoring is correlated, not independent. The model can't be the clean judge of its own reasoning; if it could mis-reason, it can mis-score the mis-reasoning the same way. Any version that relies on the model grading itself inherits this and is the weak version above.

Relabeling uncertainty as "Detectability" is communication, not capability. Calling a model's uncertainty by a four-axis name makes that uncertainty easier for a human to talk about — which is worth something, since that's DEBT's whole pitch for risk — but it doesn't make the model reason better. "Better vocabulary about reasoning" and "better reasoning" are different products, and only the second one is the claim that would matter here.

It still has to beat the scalar. The strong version is interesting precisely because it's falsifiable, and the falsification is simple: if multi-axis routing doesn't outperform one good confidence number, the idea is a vocabulary contribution, not a mechanism one. Elegant structure is not evidence. The half-life of λ, the Trap port, this — same rule every time: the elegance is real and it is not the proof.

Where this sits

A thread, not a destination. The right next move for a direction is different from the right move for a result: you test a direction cheaply before building anything around it, rather than writing it up as if it were settled. So this stays exactly here — one notebook page, logged as a hypothesis — and gets no more surface, no roadmap line, and no place inside the standard until the scalar test reports back. If it comes back yes, the multi-axis structure already built for DEBT is the reason it would work, and then it earns the write-up. Until then, it's a good question with honest logic behind it, which is all this page claims it to be.

Read the protocol → Why four axes →