Artificial Intelligence Is Not Artificial Reasoning
The industry uses one word for two different things: the capability (intelligence) and the process (reasoning). In an LLM, reasoning is emergent — a byproduct of training on data, happening somewhere in the forward pass, transient and unobservable, and biased by the model’s own momentum. Artificial reasoning (AR) is our term for the alternative: reasoning that is engineered — encoded as an explicit System-2 process with a reflective loop, in which each iteration takes the prior reasoning sequence and an analysis of it as input to the next. AI asks a model what it thinks. AR defines how the system must think. The distinction determines what can be inspected, governed, and defended — and it is about the architecture of the reasoning, not the substrate that executes it. The bet underneath it is falsifiable.
The memo that agreed with itself
Late on a Thursday, thirty cases into the queue, a disputes analyst writes up a denial. Recurring charge, cardholder says he never signed up, merchant produces an enrollment record. She was trained for exactly this — the certification course, the hundred closed files she studied, a mentor’s rule of thumb about merchant records — and the training answers before she finishes reading. The day answers with it: after thirty cases, the thirty-first arrives pre-shaped by the thirty before it. A queue has a current, and by late afternoon everything floats downstream.
Friday morning she rereads it, carefully, twice. It reads even better than it did on Thursday. That is the trap: a justification, reread, confirms itself. The phrasing carries the authority of already having been written, every sentence agrees with the sentence before it, and the file has quietly stopped being the thing under review — the memo has.
Her supervisor has a rule, learned expensively: never review the memo — review the file. Memo face-down, she rebuilds the timeline from the raw record, and the derivation breaks at step two. Nothing on the bank’s side ties the cardholder to that enrollment; the merchant’s record looks identical whether the customer signed up or an account-takeover did. The memo wasn’t wrong because the analyst was careless. It was wrong because the first pass had written the second pass’s script.
That is this post in one scene. A model reasoning in a single pass is the analyst rereading her own memo — fluent, self-confirming, carried by everything her training taught her and everything the day has already stacked in front of her. Artificial reasoning is the supervisor’s rule made into architecture: the next pass never reads the prose, only the record. The difference between those two is the difference between a justification and a reason.
One word, two things
When a bank tells its examiner “we use AI in dispute resolution,” the sentence names a capability and hides a process. The capability is real: modern models draft, classify, and synthesize at levels that were research fiction five years ago. The process is the problem: how any particular determination was reached. For a decade the industry has answered process questions with capability answers — benchmark scores, accuracy rates, model cards — and wondered why trust never followed. Averages describe populations. The examiner, the auditor, and the consumer’s attorney each ask about one decision.
The conflation has a linguistic root. “Artificial intelligence” names what the system has. Nothing in our vocabulary names how the system thinks — because in the standard architecture, nothing engineered does the thinking. The reasoning is an emergent behavior of a single forward pass: distributed across billions of weights, sensitive to sampling noise, inspectable only through the prose it leaves behind. Ask the model to explain itself and you get a second generation — a plausible story about the first, not a record of it. We have written before about why logging that story is not governance.
Where the reasoning lives
Artificial reasoning is our term for an architecture in which the reasoning is relocated: out of the weights, into an explicit structure. In an IRG graph, a regulated determination is decomposed into typed steps — classify the issue, assemble the evidence, test each element of the rule separately, challenge the draft adversarially, converge or abstain. Each step runs with its own criteria; gates decide what proceeds; and the loop is reflective: an iteration does not continue the previous one — it takes the prior reasoning sequence, and an analysis of that sequence, as input to a fresh pass. The system revises its reasoning instead of extending it. The whole run records itself as it executes: the trace is not documentation about the computation. It is the computation. In a sentence: in AI, reasoning is emergent; in AR, reasoning is engineered.
The contrasts are stark, and each one is architectural rather than rhetorical. Locus: in AI, reasoning happens inside a model; in artificial reasoning, models are components inside the reasoning. Persistence: a forward pass evaporates; a graph run is an artifact that outlives the decision. Verification: a monolithic answer can only be checked from outside, after the fact; an explicit structure is checked from within, step by step, while it runs. Failure mode: a model must produce the next token, so it guesses fluently when it should hesitate; a graph with an abstention path stops, says why, and routes to a human. Governance surface: one undifferentiated act offers nothing to govern; a structure of separate judgments offers everything — which step, which evidence, which criterion, which reviewer.
That last contrast is why our tagline orders the words the way it does: active governance through artificial reasoning. Governance that inspects outputs after generation is passive whatever its dashboards cost. Governance inside the reasoning — gates that run while the decision is being made — requires that there be reasoning to be inside of. The term names the precondition.
Why in-pass reasoning cannot escape itself
The deepest reason emergent reasoning resists governance is not that it is hidden — it is that it is biased by construction. To see why, it helps to hold a one-paragraph sketch of how a language model actually works. Training distills a vast corpus into billions of numeric parameters — the weights — and the weights are frozen before the model ever sees your case: whatever it “knows,” it knew before you asked. At run time it writes one token at a time, and every token is conditioned on the entire context so far — the prompt, the evidence, and, crucially, its own words as they accumulate. Those two facts are the whole machine. They are also two distinct biases, which we have written about as momentum.
Parametric momentum is the pull of the weights: every continuation is drawn toward the patterns of training, so reasoning tends to arrive where reasoning like it has arrived before — whatever the file in front of it says. Contextual momentum is the pull of the context: an early commitment — a framing, a mistake, a premature conclusion — conditions every token after it, with the authority of already having been said. In the opening scene, these are the analyst’s training and the analyst’s Thursday pile: the priors she arrived with, and the day already sitting in her context. And neither is a defect. Momentum is why the model works at all — the patterns are the competence, the coherence is the fluency — right up until the task stops being continuation and becomes deliberation. Chain-of-thought inherits both. That is what makes so much of it performative: a trace that performs reasoning rather than records it, drafted under the same momenta as the answer it justifies.
The reflective loop is the engineered countermeasure. Because each iteration receives the prior sequence as evidence to analyze rather than as a prefix to continue, contextual momentum is interrupted at the iteration boundary — the new pass owes nothing to the old one’s phrasing, only to its content. How completely it is interrupted is a measurable property of the loop’s design, not a slogan — revision rates across iterations are exactly the kind of number the backtest below exists to produce. And because each step is scoped, criticized by an adversarial node, and gated on stated criteria, parametric momentum is constrained to places where it can be caught: a plausible-but-ungrounded step fails its gate instead of gliding into the record. Decomposition then adds a lever no monolith can pull: the nodes need not share a substrate. A different model can execute each role — right-sized to the task, trained on different data — so every node boundary where the substrate changes is also a break in parametric momentum. No single set of priors runs the whole determination, and a challenger drawn from a different lineage does not inherit the generator’s blind spots. One model reasoning alone has one momentum; a graph of heterogeneous models has many, pointed at each other. None of this makes the system unbiased — nothing does. It makes the bias interruptible, which is the property governance actually needs.
The unbundling arrives at its last stop
Naming the category is less radical than it sounds, because the industry has been walking toward it for years without naming it. Mixture-of-experts unbundled computation. Retrieval unbundled document access. Tool use unbundled arithmetic and code. DeepSeek’s Engram unbundled static memory, and VibeThinker’s compression result suggested reasoning and knowledge were never the same thing. One capability after another has been pulled out of the monolithic model into explicit components with explicit interfaces — because explicit components can be engineered, priced, and improved independently. Reasoning is the last major capability still fused into the forward pass. Artificial reasoning is what it looks like unbundled: not a smarter model, but a reasoning layer with the model underneath it.
What the term does not claim
A new category term earns skepticism, so here are the boundaries, stated plainly. Artificial reasoning is not anti-AI. Today’s implementations execute their reasoning operations with language models, and better models make better operations — but the category is defined by the architecture of the reasoning, not by what executes each step. The substrate is an implementation choice, and implementation choices evolve. It is not a return to expert systems. The old symbolic programs engineered both the structure and the judgment, and shattered on the judgment; end-to-end AI learns both, and forfeits the structure. AR occupies the position neither could: engineered structure over learned judgment. It is not a claim that models cannot reason. They plainly do something reasoning-like, and chain-of-thought research keeps improving it — inside the pass, where it remains transient, unauditable, and subject to its own momentum. Our claim is narrower: for decisions an institution must defend, reasoning that exists only inside a forward pass is not an artifact, and institutions defend artifacts. It does not multiply model risk — it makes model risk addressable. From a model-risk lens, the natural objection runs: if each step is its own call, a twelve-node graph looks like twelve inventory entries where there used to be one. The count is right; the accounting is backwards. A monolithic call is one entry that cannot be meaningfully validated — no purpose narrower than “decide,” no scoped behavior a test set can cover, no internal surface to monitor. Decomposition is what creates the surface that validation requires: each node has a stated purpose, a pinned substrate, and a bounded contract small enough to actually test — and that includes the adversarial and gate nodes, which are components validated the same way, not exempt referees. The seams between nodes are instrumented precisely where errors would otherwise propagate unseen. Engineers decompose every system they intend to debug, for the same reason: a black box does not have fewer failure modes — it has the same failure modes without handles. Twelve obligations you can discharge are not a burden relative to one you cannot. And the term is ours — a proposed name for an architecture we think the industry will converge on regardless of what anyone calls it.
The claim we can be proven wrong about
A category is only worth naming if it makes a testable bet, so here is ours. On regulated adjudication workloads — disputes, adverse action, alert triage — a governed graph of right-sized open models will match or beat a frontier model’s single pass on the metrics that decide deployability: overturn rate on review, citation validity, consistency across identical fact patterns, and correct abstention on thin records. Not on benchmarks — on an institution’s own closed cases, against its own historical determinations. That is precisely the backtest we run with design partners, and if the structured system cannot rival the monolith on decision-grade evidence, the category collapses back into marketing. We would not have named it if we did not expect that test to come out our way — but expecting is not knowing, which is exactly why the backtest comes before the deployment.
Artificial intelligence gave machines answers. Artificial reasoning gives institutions reasons — inspectable while the decision is being made, defensible after it ships. One is a capability. The other is the architecture that makes the capability governable.