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.

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.

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.
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.

