Large language models have long surpassed simple text continuation. They write code, analyze data, plan actions, and hold meaningful conversations. In many tasks, their reasoning looks surprisingly structured — and that’s true.
But there is an important detail that is rarely stated directly: the structure of reasoning in LLMs is not part of the model’s architecture. It emerges as a side effect of large‑scale training and in‑context learning.
Between the neural core and the agent/tool layer, one can interpret a kind of intermediate reasoning level — implicit, unformalized, and arising from transformer behavior. This level works, but it is not controlled or guaranteed to be reproducible.
This article explores why such a level makes sense to consider, why it matters, and why attempts to formalize it are starting to appear.
The location of the “black box”
A simplified view of a modern LLM system:
[ Neural core ]
↓ (attention, probabilities, KV-cache)
[ Implicit reasoning level ] ← the black box
↓
[ Agents / tools / actions ]
The model can reason, but:
- it does not explicitly separate intentions/constraints/values from facts and methods
- it is not required to stabilize its output before moving forward
- it can expand an idea without any counterbalance
- it can proceed despite unresolved contradictions
- it has no built‑in rollback rules
- it has no invariants preventing “half‑formed” states
Existing methods like CoT, ToT, GoT, ReAct, Reflexion, LangGraph, and AutoGen formalize interaction, search, or tool‑driven loops, but they do not introduce invariants of reasoning stability — meaning they do not enforce mandatory rules for stabilization, integration, or rollback.
Why a formal reasoning layer might be useful
Some classes of tasks require:
- stability
- explainability
- reproducibility
- explicit constraints and risk handling
- integration of values and facts
These include medicine, law, ethics, safety, strategic planning, and autonomous systems.
A small example
Task:
“Create a plan for implementing a new security policy.”
Without a structural invariant:
The model may jump straight to steps, skipping risks, legal constraints, or conflicting requirements.
With an invariant like “constraints → integration → only then planning”:
The model first fixes risks, laws, resources, and conflicts.
Only after stabilization does it generate the plan.
The result is less creative but more reliable and explainable — which matters in domains where mistakes cost money or lives.
An example of a formalization attempt: A11
Several approaches are emerging that try to make this intermediate level explicit.
One of them is A11 (Algorithm 11).
A11 is not a “revolution” or “the only correct way.”
It is simply an example of how one might formalize the reasoning process between the neural core and the agent layer.
Interesting elements in A11 include:
- a two‑pole geometry (values/constraints ↔ facts/methods)
- mandatory integration before moving forward
- paired expansion ↔ compression with fractal recursion
- a central stabilizing operator
- strict invariants (no partial execution, rollbacks only in the Core)
This does not make A11 “better” than existing methods.
It makes it a different class — not a tree, not a graph, not a loop, but an architecture of reasoning.
When a formal reasoning layer is genuinely useful
It matters when:
- steps cannot be skipped
- risks cannot be ignored
- contradictions must be resolved before proceeding
- every transition must be explainable
- the output must be stabilized
In other words, when errors are expensive.
When it is not needed
- simple tasks
- creative tasks
- fast responses
- multi‑agent workflows
- tool‑driven pipelines
Conclusion
Modern LLMs can reason, but they do so implicitly.
Between the model and the agent layer, one can interpret an intermediate reasoning level — a black box that works but is not formalized.
Attempts to make this level explicit are beginning to appear.
A11 is one such attempt — not the only one and not claiming to be a revolution — but interesting because it introduces strict invariants, balance, and integration of opposing factors.
Whether such a layer is needed will be determined by benchmarks, repositories, and real‑world use.
But the idea of formalizing the intermediate reasoning level looks promising for tasks where reliability is essential.
You can find a reference implementation and more details in the A11 repository: https://github.com/gormenz-svg/algorithm-11
Top comments (0)