AI reasoning protocol graph over a douglas fir forest canopy
6 min read
Product Release

Reasoning Needs a Protocol Layer

By Published Updated

Our first product release is Scholialang: a protocol layer for AI reasoning. Scholialang helps agentic systems preserve reasoning state, use tools without quality loss, and reduce context cost across long-horizon work. It is built around a problem that is becoming impossible to ignore: model output is not the same thing as operational reasoning.

The AI stack has mature layers for prompts, tool calls, retrieval, orchestration, and logging. Scholialang is our attempt to give reasoning its own common substrate: a way to represent what was claimed, why it was accepted, what evidence supported it, what changed, and which later decisions inherited that state.

Without that layer, every agent run is mostly a private performance. With it, reasoning can become an inspectable system artifact.

The missing interface

Most production AI failures are not caused by one bad sentence. They come from a breakdown in transfer. A model makes a plausible claim. A tool call treats it as a fact. A second agent receives a condensed summary. A workflow takes action. By the time a human reviews the outcome, the original uncertainty has disappeared.

That is an interface problem. Reasoning needs a wire format that survives handoff. It needs typed claims, explicit dependencies, confidence, source boundaries, contradictions, retractions, and closure. It needs to make uncertainty portable instead of letting it decay into fluent certainty.

Glowing network of branching logic paths
A protocol layer gives reasoning state a durable shape across models, tools, and reviewers.

What a protocol layer must carry

A useful reasoning protocol does not need to expose private chain-of-thought. In most enterprise settings, that is the wrong goal. The protocol should capture accountable reasoning artifacts: goals, observations, evidence, assumptions, decisions, open questions, contradictions, actions, and conclusions.

Those artifacts need structure. A claim should know which evidence supports it. A decision should know which assumptions it depends on. A contradiction should be preserved instead of silently overwritten. A conclusion should close the loop on the goal it was meant to satisfy.

The point is not to make models sound more rational. The point is to make reasoning inspectable when software starts depending on it.

Why this belongs in the AI infrastructure stack

At Doug Fir Labs, we see neuro-symbolic architecture and reasoning protocols as adjacent parts of the same foundation. Symbolic systems give models a way to reason over explicit structure. Protocols give that structure a way to move through a real system without losing accountability.

This matters most when AI leaves the chat window. Agents that reconcile invoices, review claims, triage incidents, or draft regulated decisions need more than plausible answers. They need a durable record of how state changed and why the next action was allowed.

AI reasoning protocol graph over a douglas fir forest canopy
Reliable systems grow from durable layers, not isolated moments of intelligence.

The practical test

The standard should be simple: if an AI-driven workflow produces an important outcome, another system should be able to inspect the reasoning record without replaying the entire prompt transcript. It should see the goal, the evidence, the accepted claims, the rejected alternatives, and the final decision boundary.

That is where reasoning starts to look less like generated text and more like infrastructure. It becomes versionable. It becomes testable. It becomes governable. Most importantly, it becomes something teams can improve deliberately instead of debugging after the damage is already downstream.

What the first pilots show

The early numbers are not a final benchmark, but they are already useful. The strongest launch-day continuity result is a three-model replay smoke test: fresh Opus 4.8, Fable 5, and GPT-5.5/Codex sessions matched the original decision from Scholialang trace carryover in 135/135 trace-seeded cells. The important caveat is that formal lift depends on cold-start headroom; highly consistent models leave less room to show improvement even when the trace arm is perfect.

The operational signal is cost. In a 150-cell Claude Fable 5 pilot, Scholialang's hash_list context mode reduced Session-5 input tokens by 41.0% with no measured quality loss. The more aggressive hash_only_lazy mode reached 49.5% reduction, with a small quality tradeoff in that run. A separate Codex full-stack pilot independently reproduced a 30.45% lazy-hash reduction with quality parity.

Reusable reasoning keeps carried context flatterClaude Fable 5 pilot: 150/150 cells ok02k4k6kS1S2S3S4S56,3753,7593,220v0.5 inlinev0.6 hash_list: -41.0%v0.6 hash_only_lazy: -49.5%
Mean input tokens per session, S1 to S5, Claude Fable 5 pilot (150/150 cells OK). v0.5 inline context grew to 6,375 tokens by session 5; v0.6 hash_list held at 3,759 (-41.0%) and hash_only_lazy at 3,220 (-49.5%). Compact references keep accumulated reasoning usable without replaying every prior atom.

Doug Fir Labs is working directly on this protocol question. Visit Scholialang.org for more details, including the paper, protocol specification, and beta plugins for Codex and Claude Code, or follow the Scholialang GitHub repo.

More from Doug Fir Labs

Glowing network of connections through douglas fir roots

Does the Evidence a Model Cites Drive Its Conclusion? Our preprint is out

A pre-registered causal test of declared evidence relations in Scholialang reasoning traces on Qwen2.5-7B-Instruct. A model's emitted symbolic label can causally steer its subsequent conclusion, even when the accompanying facts disagree.

Preprint3 min readRead
Forest canopy aerial

Why Neuro-Symbolic Architecture Is the Missing Layer in LLM Infrastructure

Large language models are powerful pattern matchers, but pattern matching alone doesn't constitute reasoning. We explore how composing symbolic reasoning primitives with neural inference creates models that are more capable, auditable, and trustworthy.

Research7 min readRead