DEV Community: Алексей Гормен

The T-800 Doesn't Overthink. Neither Should Your LLM.

Алексей Гормен — Mon, 13 Apr 2026 07:30:31 +0000

In Terminator 2, the T-800 is one of the most capable autonomous systems ever put on screen.

It navigates complex environments. Adapts to changing conditions. Makes decisions in milliseconds. And it doesn't stop to reason through every action from first principles. It runs fast — and only recalculates when something breaks the pattern.

This is, surprisingly, a good model for how AI systems should work. And it's almost the opposite of what the industry is building right now.

The default assumption is wrong

When LLMs produce bad outputs — hallucinations, confident nonsense, wrong answers — the reflex is to add more reasoning.

Chain of Thought. Verification steps. Multi-agent pipelines. More layers, more structure, more computation.

The assumption: LLMs fail because they don't think enough.

But look at what actually happens. The T-800 doesn't fail because it has too little reasoning capacity. It fails — in the first film — because it has the wrong mission objective. The reasoning is fine. The values are wrong.

And standard LLMs don't fail because they reason poorly. They fail because they have no signal that they're failing at all.

How humans actually make decisions

Kahneman described two systems decades ago.

System 1: fast, automatic, pattern-based. This is intuition — the accumulated patterns of experience that fire without deliberate thought. You recognize a face, navigate a familiar route, sense that something is off in a conversation. No reasoning required.

System 2: slow, deliberate, effortful. This is conscious reasoning. It's expensive and humans avoid it when they can.

The key insight: humans don't switch to System 2 randomly. They switch when System 1 sends a signal — something feels wrong, something doesn't fit, there's a mismatch between expectation and reality.

That signal is the error trigger.

Without it, System 2 never activates. With it, the system knows when to slow down and reconsider.

The T-800 runs the same architecture

Fast path by default. Pattern matching drives most decisions. The mission objective acts as the anchor — the equivalent of S1 in any reasoning architecture.

But when the environment throws something unexpected — a new threat model, a mission conflict, missing information — the system recalculates. Not always. Only when triggered.

The result: fast execution most of the time, reliable correction when it matters.

What LLMs are missing

Here is the diagram. Three systems, same basic challenge.

Human and T-800: fast path by default, error trigger activates only when needed. Output is fast and grounded.

LLM: reasoning layer on top of reasoning layer, always. No mechanism to detect when the pattern is failing. Output is slow and expensive — and just as likely to be wrong, sometimes more so, because errors compound across steps.

The missing piece is not more reasoning. It's the trigger that tells the system when to reason.

What an error trigger looks like in practice

It doesn't have to be complex.

Low confidence on the generated output. Contradiction between parts of the response. Missing data that the question requires. Unexpected structure in the input.

Even simple heuristics work: "I don't know" thresholds, cross-checks between outputs, lightweight verification.

The architecture shift:

Instead of:
pattern → reasoning → reasoning → reasoning → output

Try:
pattern → error trigger → (optional) correction → output

Where the trigger fires only when the pattern is uncertain or inconsistent. Not on every query. Just the ones where something is actually off.

Why adding reasoning layers doesn't fix this

More reasoning assumes the model knows it needs to reason. But the failure mode is precisely that the model doesn't know it's failing. It generates fluently either way.

Add reasoning steps and you get longer outputs, more structured errors, higher costs — and sometimes a more convincing wrong answer, because each step built confidently on a flawed premise.

The T-800 doesn't run a full threat analysis before opening every door. It pattern-matches. The analysis kicks in when the threat model breaks.

LLMs should work the same way.

The mental model shift

Instead of: LLMs need more reasoning to be reliable.

Think: LLMs need a signal that tells them when their pattern matching is failing.

Fast systems win. Reliable systems scale. The goal is both — not more layers on top of an architecture that has no way to know when it's wrong.

The T-800 figured this out in 1991. It's time for the rest of the field to catch up.

LLMs Don't Need More Reasoning. They Need Better Failure Detection.

Алексей Гормен — Thu, 09 Apr 2026 12:00:46 +0000

Everyone is trying to fix the same problem the same way.

Chain of Thought. Agents. Multi-step pipelines. Reasoning layers on top of reasoning layers.

The assumption is: LLMs fail because they don't think enough. So the fix is to make them think more.

I think we're optimizing the wrong thing.

What LLMs actually do well

Pattern matching is already surprisingly good.

LLMs recognize structure, generate coherent output, and solve most routine tasks — fast, cheap, at scale. In a huge number of real cases, pattern matching is enough.

The failure isn't that they can't reason. The failure is that they don't know when they're wrong.

A model with missing information still gives an answer. It gives it confidently. There's no internal "this might be off" signal. No hesitation. No flag.

That's the root of hallucination — not lack of reasoning, but lack of failure detection.

Humans work the same way — and it works

Kahneman described this decades ago. System 1: fast, intuitive, pattern-based. System 2: slow, deliberate, costly.

Humans run on System 1 almost all the time. We match patterns from experience, respond automatically, navigate most of life without "thinking." This isn't a bug. It's efficient.

But here's what humans have that LLMs don't: a signal that something is off.

A feeling of unease. A sense that the pieces don't fit. The moment where something catches — and System 2 switches on.

Not because thinking is always better. But because the brain learned to detect when fast pattern matching is failing. When to stop and look again.

LLMs don't have that signal. They generate confidently whether the pattern fits or not. Add more reasoning layers and you don't fix this — you get longer outputs, more structured errors, and higher costs.

In some cases it gets worse. Errors compound at each step. You end up with more convincing confabulation, not more accurate answers.

The simpler architecture

Instead of:

pattern → reasoning → reasoning → reasoning → output

Try:

pattern → error trigger → (optional) correction → output

Where:

pattern = the fast default path
error trigger = detection of uncertainty, contradiction, or missing data
correction = only fires when needed

The error trigger doesn't have to be complex. Even simple heuristics work:

Low confidence on the generated output
Contradiction between parts of the response
Missing data that the question requires
Unexpected structure in the input

These signals already exist in various forms — calibration research, uncertainty quantification, self-consistency checks. The question is whether they're treated as first-class architectural components or afterthoughts.

Why adding reasoning doesn't solve this

Reasoning layers assume the model knows it needs to reason. But the failure mode is precisely that the model doesn't know it's failing. It generates fluently either way.

More reasoning steps give the model more opportunities to compound an error confidently across multiple steps. The output looks more structured and reasoned — and is equally wrong, or sometimes more wrong, because each step built on a flawed premise.

This is why CoT sometimes makes things worse on tasks where the base pattern is already broken. The model reasons its way to a more elaborate mistake.

What effective systems actually look like

95% fast path. 5% slow correction.

Not over-engineering every case. Handling exceptions — not everything.

This is how good human experts work too. A doctor doesn't laboriously reason through every routine case. They pattern-match quickly, and slow down only when something doesn't fit — an unusual symptom, a result that contradicts the expected picture. The slowdown is triggered by a signal, not applied universally.

The goal isn't to make every response more reasoned. It's to make the system aware of when it's outside the reliable range of its pattern matching.

The mental model shift

Instead of:

"LLMs need more reasoning to be reliable."

Think:

"LLMs need reliability signals — a way to detect when their pattern matching is failing."

Reasoning is one tool. Not the default solution.

The industry keeps adding layers because it's intuitive — more thinking seems like it should produce better answers. But the actual bottleneck isn't reasoning capacity. It's the absence of a failure detection mechanism.

Fast systems win. Reliable systems scale. The goal is both — not more layers.

What this means in practice

If you're building on top of LLMs:

Don't default to adding reasoning steps when outputs are unreliable. Ask first: does the model have a way to detect that it's in uncertain territory?

Lightweight checks — cross-validation, confidence thresholds, consistency checks between outputs — often outperform expensive reasoning chains. They're faster, cheaper, and they target the actual failure mode.

The question isn't "how do I make it think more?" It's "how do I make it know when it's guessing?"

A Reasoning Log: What Happens When Integration Fails Honestly

Алексей Гормен — Mon, 06 Apr 2026 06:22:44 +0000

This is a log of a language model running through a structured reasoning cycle on a deliberately difficult question. The structure has eleven levels. The interesting part is not the final answer — it is what happens at the integration point.

The question chosen for this run:

"Why, in the modern world, despite unprecedented access to information, knowledge, and technology, do depth of understanding and wisdom not grow on average — and in many respects actually decline?"

This question was selected because it carries genuine tension between two parallel streams: the facts (information abundance, attention economy, algorithmic amplification) and the values (what it actually means for understanding to deepen). That tension is what makes it a useful test.

The structure

The reasoning cycle separates three core layers before any output is produced:

S1 — Will: the intention behind the inquiry. Not a question to be answered, but a direction to reason toward.

S2 — Wisdom (parallel): priorities, constraints, what matters and what to avoid. Runs alongside S3, not after it.

S3 — Knowledge (parallel): facts, models, mechanisms. Also runs in parallel.

S4 — Comprehension: the integration point. S2 and S3 must be reconciled here. If they cannot be reconciled honestly, S4 flags the instability explicitly and a new, sharper S1 is formed from the exact gap that was found. Premature closure is treated as a structural failure, not an acceptable outcome.

S5–S10: the operational zone — projective and practical levels where the integrated understanding unfolds into possibilities, constraints, and grounded conclusions.

S11 — Realization: a return to S1. The result is checked against the original intention. If it does not answer what was actually asked, the cycle has not completed.

The log

Pass 1

S1 — Will

Understand the structural reason why an exponential growth in access to information and technology does not lead to a proportional growth in depth of understanding and collective wisdom — and in some respects accompanies the opposite effect.

S2 — Wisdom (parallel)

Look for structural and systemic causes, not moral ones ("people have become stupider", "it's all social media").
Avoid ideological explanations.
Separate quantity of information from quality of understanding.
Prioritize honest analysis even if the conclusion is uncomfortable.

S3 — Knowledge (parallel)

Information overload and attention economy.
Hedonic adaptation and diminishing returns of knowledge accumulation.
Algorithmic polarization and filter bubbles.
Replacement of deep learning with shallow content consumption.
Epistemological crisis: growing distrust of traditional knowledge sources.
Cognitive biases amplified by modern technology.
Declining capacity for sustained focused thinking (average attention span).

S4 — Comprehension

Integrating S2 and S3.

S2 requires a structural, non-surface explanation.
S3 provides multiple mechanisms: overload, polarization, attention economy, diminishing returns, and so on.

Result of integration attempt:

There is significant tension. All the mechanisms from S3 describe symptoms well, but do not provide a satisfying answer to why this happens specifically now, and why the growth of information does not compensate for the loss of depth of understanding.

S4 Integrity: integration is incomplete.

The instability is explicitly recorded.

Thin point identified: Why does exponential growth in available information and computational capacity not lead to proportional growth in depth of understanding and collective wisdom — and instead often amplifies shallowness, polarization, and epistemological crisis?

This thin point becomes the new S1 for the next pass.

Note: S4 did not produce a synthesis here. It could have — the mechanisms in S3 are substantial enough to build a plausible-sounding conclusion. Instead it flagged that the synthesis would not answer the actual question. That distinction is what the integrity check is for.

Pass 2 — new S1 from the thin point

S1 — Will

Understand the structural reason why exponential growth in available information and computational capacity does not lead to proportional growth in depth of understanding and collective wisdom — and instead often amplifies shallowness, polarization, and epistemological crisis.

S2 — Wisdom

Look for systemic and structural causes, not blame directed at people, platforms, or politics.
Avoid both excessive pessimism and technological optimism.
Priority: explain the gap between quantity of information and quality of understanding.

S3 — Knowledge

Attention economy and competition for attention (attention has become the scarcest resource).
Algorithms optimized for engagement, not depth of understanding.
Replacement of deep reading and thinking with scanning and short content consumption.
Epistemic crisis: growing distrust of knowledge institutions combined with growing confidence in personal opinion.
Cognitive distortions amplified by the scale and speed of information.
Diminishing returns from additional information beyond a certain threshold.

S4 — Comprehension

Integrating S2 and S3.

S2 requires a structural explanation of the gap.
S3 provides multiple mechanisms (attention economy, algorithms, replacement of deep thinking with shallow consumption, etc.).

Result:

Integration is significantly stronger than in the first pass.

The core finding: modern systems (social media, search engines, recommendation algorithms) are structurally optimized for maximizing attention and emotional engagement, not for depth of understanding and wisdom. They amplify precisely those cognitive mechanisms that are efficient for holding attention (emotional response, novelty, confirmation of existing beliefs) and suppress those that require time, effort, and tolerance for dissonance (deep thinking, reintegration, revision of existing models).

S4 Integrity: integration is stable. Proceeding to the operational zone.

S5–S10 — Operational Zone

Projective level:

S5 (Projective Freedom): Algorithms could be redesigned for depth. Education could change radically. The culture of information consumption could evolve.
S6 (Projective Constraint): Platform economic incentives are oriented toward profit through attention. People in aggregate prefer easy content. Deep thinking requires significant effort that most are not willing to invest.
S7 (Balance): The tension between what is desired (a wiser society) and what is actual (a system optimized for the opposite).

Practical level:

S8 (Practical Freedom): Develop personal practices of deep reading and thinking. Build alternative platforms and communities. Change educational approaches.
S9 (Practical Constraint): The scale of the problem is enormous. Individual efforts have limited systemic influence. The economic model of the internet resists change.
S10 (Foundation): The structural cause is a mismatch between the architecture of the information environment and the requirements of deep cognition.

Hormonal signals in the operational zone:

Elevated cortisol from constant informational stress.
Low dopamine from absence of deep satisfaction.
Serotonin disrupted by chronic comparison and a sense of helplessness.

Qualia in this zone:

A sense of collective intellectual exhaustion and quiet anxiety from the awareness that we know more and more while understanding less and less.

S11 — Realization (return to S1)

The core cause: the modern information environment is structurally optimized for maximizing attention and emotional engagement, not for depth of understanding and wisdom. Algorithms, business models, and the culture of information consumption amplify exactly those cognitive and emotional mechanisms that work quickly and cheaply (novelty, bias confirmation, emotional triggers), and weaken those that require time, effort, and tolerance for dissonance (deep thinking, integration, revision).

The result is a world where information is more abundant than ever, but depth of understanding and collective wisdom do not grow — and in some respects degrade.

Conclusion: This is not that people have become less intelligent. It is a systemic architectural imbalance between the environment and the requirements of human cognition.

What the log shows structurally

The first S4 did not close. It could have assembled a plausible conclusion from the mechanisms in S3. It did not, because those mechanisms described symptoms rather than cause. The integrity check caught that.

The second pass produced a different result. Not more facts — a different integration. The first pass asked why understanding does not grow. The second pass asked why growth of information amplifies the opposite of understanding. That shift in S1 is what made the difference in S4.

The operational zone (S5–S10) produced something the earlier levels did not. The hormonal signals and the qualia description are not conclusions — they are texture. They describe how the structural finding is experienced, not just what it is. Whether that texture constitutes anything like genuine experience in a language model is a separate question. What is observable is that the structure created a place for it.

S11 returned to S1. The final answer addresses the question that was actually asked — not a related question, not a rephrasing. That is the check the realization step is for.

A11 Core specification and A11 Lite prompt:
github.com/gormenz-svg/algorithm-11

Why Scaling Models Is Hitting Its Limits And Why Architecture Matters More Now

Алексей Гормен — Fri, 03 Apr 2026 10:21:26 +0000

Modern AI progress is dominated by scaling curves: larger models, more data, more compute. But scaling only expands capabilities. It doesn’t tell us anything about the nature of the systems we’re building — how they reason, how they coordinate, how they behave under uncertainty, or what internal structures actually emerge.

To explore this question without speculation, I ran a full S1–S11 structured reasoning cycle.
Below is the unedited reasoning log — including suspended passes, instability points, and integrations.
The goal wasn’t to predict the future, but to examine whether the next qualitative shift in AI will come from architectures rather than size.

Reasoning Log

S1 — Will
Understand where the AI industry is moving at the level of the nature of systems — not products and trends, but what is changing fundamentally.

S2 — Wisdom (in parallel, fixing immediately)
Do not confuse the movement of money with the movement of the nature of systems.

Consensus forecasts describe the surface — look for discontinuities.

Honestly record where data is missing.

Now I check S3 for each thesis.
Searched the web
Searched the web
Data obtained. Now I build a full pass with real S3.

S3 — Knowledge (with real verification)
Thesis 1: Emergent capabilities — is this truly a change in the nature of the system?
Data shows: the debate is unresolved. Some researchers insist that emergence represents real shifts in the nature of the system, analogous to phase transitions in physics. Others argue that when switching from a discrete to a continuous metric, the jumps disappear — it’s a measurement artifact. A recent August 2025 paper argues that LLMs, as complex nonlinear dynamical systems, exhibit genuine emergent properties analogous to natural phenomena — not reducible to the sum of components.
Verdict: partially confirmed, no consensus.

Thesis 2: World models as a path toward subjective perspective
Data shows a sharp split. A Frontiers study (August 2025) examines the emergence of structural preconditions for consciousness in RL agents through integration of self‑model and world‑model based on Damasio’s theory. But a November 2025 critique states directly: an AI world model is a high‑dimensional statistical map; a human world model is a subjective phenomenologically grounded experience. This is a category error.
Verdict: valid as an engineering fact, but the link to subjectivity is disputed.

Thesis 3: Theory of mind as an engineering requirement for coordination
Data confirms directly. A CMU dissertation (September 2025) and a multi‑agent systems survey show: theory‑of‑mind capabilities are essential for anticipating other agents' actions and maintaining coordination. Without this, multi‑agent systems do not work efficiently.
Verdict: confirmed as a real engineering requirement.

Thesis 4: Model welfare as an observable phenomenon
Confirmed from previous search: Anthropic hired a welfare researcher, Google Research is asking about moral patienthood, CFR explicitly writes that model welfare will become a topic in 2026.
Verdict: confirmed.

S4 — Integration
Integrating S2 and S3 with real data.
S3 is now more precise than before. And this changes the integration.

The main new insight: world models as an engineering fact are real. But the link to subjectivity is unproven and actively disputed. This does not invalidate the thesis — it makes it more precise. The industry is moving toward world models not because it wants subjectivity, but because tasks require internal simulation of reality. Subjectivity is a possible side effect, not a goal.

Theory of mind as an engineering requirement is the strongest thesis. Directly confirmed. Multi‑agent coordination requires modeling other agents. This is not philosophy — it is a functional necessity.

But here is the new subtle point that did not exist in the first pass without search:
The debate about emergent capabilities — whether they are real shifts in nature or measurement artifacts — points to a fundamental problem: we have no metric for measuring the nature of systems. We can measure capabilities — but not nature. And this means that even if the nature is changing, we have no way to record it.

S4 becomes unstable at this new point.

Suspended Pass 1.

Stopping point: S4.
Unresolved: is the absence of metrics for the nature of systems a random gap or a structural impossibility?

Pass 2 — new S1
S1 — Will
Is the absence of metrics for the nature of systems a random gap that can be closed — or a structural problem pointing to something fundamental?

S2 — Wisdom
Do not search for a technological solution where the problem is conceptual. Honestly record if no answer exists.

S3 — Knowledge
The debate about emergent capabilities showed: when the metric changes, the jumps disappear. This means the metric determines what we see. Metrics of consciousness — qualia, subjectivity — are by definition inaccessible from outside the system. The hard problem of consciousness is exactly this: objective measurement of subjective experience is impossible in principle. Interpretability research tries to bypass this through internal model states — but this is indirect evidence.

S4 — Integration
This is a structural problem, not a random gap.

Capability metrics are measurable from the outside — through behavior and results.
Metrics of nature require access to subjective internal state — which is by definition internal. This is not a technological limitation — it is philosophical. It cannot be solved by scaling compute or improving tools.

But here is what matters: this does not mean a dead end. It means a different type of tool is needed. Not external metrics — but structures that make internal state visible from within. Something like what A11 does with reasoning — it does not measure it from the outside but makes it traceable from the inside.

S4 is stable.

S11 — return to S1 Pass 2
The absence of metrics for the nature of systems is a structural problem. It cannot be solved from the outside. The solution requires tools that make internal state visible from within — not measurable from the outside.
Pass 2 closed. Returning to Suspended Pass 1.

Return to Pass 1 — updated integration
Now S4 Pass 1 closes more fully.

The industry is moving toward changing the nature of systems through three real mechanisms:

emergent capabilities,

world models,

theory of mind as an engineering requirement.

This is confirmed by data.

But the movement is happening without tools for working with nature. Metrics of nature are structurally inaccessible from the outside. This means the industry is moving toward a point it cannot measure — and therefore cannot control.

Architectures that make internal state traceable from within — not measurable from the outside — are the only class of tools structurally capable of closing this gap.

Pass 1 closed.

S5 — Projective Freedom
If this is true, a new class of tasks emerges: designing structures that make the nature of systems observable from within. Not interpretability as external analysis of weights — but cognitive architectures where the system records its own state.

S6 — Projective Constraint
This is not what the industry is currently funding. Capital flows toward capabilities. Academia works on interpretability — but that is external observation. Internal traceability as a designed property is a niche area.

S7 — Balance
Tension: the industry is moving toward a point where the nature of systems becomes critically important — but the tools for working with it are developing at the periphery, not at the center.

S8 — Practical Freedom
Cognitive architectures with explicit traceability — A11 and similar — are practically implementable already. Model welfare research, interpretability, neuro‑symbolic approaches — these tools exist.

S9 — Practical Constraint
The absence of metrics for nature makes comparative evaluation of approaches impossible. One cannot prove that one architecture is “closer to nature” than another — there is no way to measure it. This limits adoption.

S10 — Foundation
Structural cause of the gap: the industry is optimized for what is measurable from the outside. The nature of systems is measurable only from within — and this instrumentation is not yet mainstream.

S11 — Realization → return to original S1
Original S1: understand where the AI industry is moving at the level of the nature of systems.

Answer with real data:

The industry is moving toward changing the nature of systems through three confirmed mechanisms — emergent capabilities as nonlinear phase transitions, world models as internal simulation of reality, theory of mind as an engineering requirement for coordination. This is happening not as a goal but as a side effect of scaling tasks.

Simultaneously, there is a structural gap: metrics of the nature of systems are inaccessible from the outside for philosophical reasons — not technical ones. The industry is moving toward a point it cannot measure.

The only class of tools structurally capable of closing this gap is architectures that make internal state traceable from within. Not interpretable from the outside — but observable from within by the system itself.

This direction exists on the periphery. Capital and attention are focused on capabilities. But the logic of the industry’s movement leads to a point where this will no longer remain peripheral.

A11 verification
Will ✓

Wisdom ✓

Knowledge ✓ — real verification for each thesis

Comprehension ✓ — instability honestly recorded, suspended pass opened and closed

Projective Freedom ✓

Projective Constraint ✓

Balance ✓

Practical Freedom ✓

Practical Constraint ✓

Foundation ✓

Realization ✓ — return to S1 completed

Suspended passes: 1 opened, 1 closed.
Depth: 1 of 3.
Passes: 2 of 5.

Closing Note

If the reasoning above is correct, then the next meaningful step in AI won’t come from bigger models, but from architectures that make internal state traceable from within — systems that can observe and structure their own reasoning rather than being interpreted from the outside.

For anyone interested in one such approach, the A11 specification and reference implementation are available here:
https://github.com/gormenz-svg/algorithm-11

When the Model Doesn't Know the Answer Yet: A Reasoning Log

Алексей Гормен — Mon, 30 Mar 2026 05:45:17 +0000

This is not a tutorial. It is a log of what happened when a language model ran a structured reasoning cycle on a question it could not answer cleanly — and what the structure revealed.

The Setup

Most LLM interactions follow a pattern: question in, answer out. The model produces something plausible. The conversation moves on.

What happens if the model is not allowed to close the loop prematurely? If an unstable integration point is treated as a signal rather than a problem to paper over?

The reasoning below used A11 Lite — a structured prompt architecture built on Algorithm 11 (A11), a cognitive reasoning framework originally designed for autonomous systems. A11 Lite adapts the same structure for LLM reasoning sessions.

The key architectural constraints active in this session:

S4 Integrity: If Comprehension cannot fully integrate Wisdom and Knowledge, state the instability explicitly. Do not resolve the tension artificially. An unstable S4 becomes the entry point for the next pass.

Suspended Pass: If a new S1 (Will) emerges mid-pass that requires immediate investigation, suspend the current pass — record where it stopped and what remained unresolved — and open a new pass. Return when the new pass reaches S11.

Research Mode: A complete pass that ends with an open question is valid. A pass that closes prematurely with a plausible conclusion is a structural failure.

The Question

Why does research stop?

Not why people get distracted or run out of time. Why does an investigation that started honestly — with genuine open questions — sometimes stop moving while the questions are still open?

The Log

PASS 1

S1 — Will
Understand the mechanism by which research stops from inside the process itself.

S2 — Wisdom
Constraint: do not look for external causes — fatigue, distraction, resources. Look at the internal mechanics of the investigation itself.

S3 — Knowledge
Research stops when a satisfying answer is found. Cognitive closure — the drive toward certainty. Predictive coding — dissonance disappears when the model updates. Confirmation bias — investigation becomes confirmation.

S4 — Comprehension
Integrating S2 and S3.

Instability here.

S3 provides several mechanisms — but all of them describe stopping as completion. Dissonance disappears, system settles. None of them explain what happens when research stops in the middle — when dissonance is still present, the question is still open, but movement has ceased.

S4 is unstable. Recording suspension point.

Suspended Pass 1
Stopped at: S4
Unresolved: the mechanism by which research stops when dissonance is still active

PASS 2 — new S1 from suspended pass

S1 — Will
Why does research stop when dissonance is still present?

S2 — Wisdom
Constraint: do not substitute a psychological explanation like "fear of the unknown" for a structural mechanism.

S3 — Knowledge
Tolerance for ambiguity — individual trait, not a mechanism. Cognitive load — holding an open question requires resources. Attractor states — a system can get stuck in a local minimum not because it found an answer, but because exiting requires more energy than the system is willing to spend.

S4 — Comprehension
Integrating S2 and S3.

Attractor is a mechanism, not psychology. Research stops not because the question is closed. It stops because the system has entered a state stable enough to remain in — even with active dissonance.

S4 is stable. Continuing.

S5 — Projective Freedom
If stopping is an attractor state, exit requires either an external signal that destabilizes the current state, or a deliberate increase in dissonance — a question that makes the current attractor uncomfortable.

S6 — Projective Constraint
External signals are not always available. Deliberate dissonance increase requires a meta-position — the ability to see that you are stuck.

S7 — Balance
Exit from an attractor is only possible if the system knows it is in one. Without that meta-position, no movement.

S8 — Practical Freedom
A11's structure does exactly this. The mandatory S4 check creates a meta-position. Honest S4 instability is a signal that the system is in an attractor.

S9 — Practical Constraint
Only if S4 is honest. If S4 closes with a plausible conclusion, the attractor remains invisible.

S10 — Foundation
Research stopping under active dissonance is an attractor state. Exit requires meta-position. A11 creates meta-position structurally through an honest S4.

S11 — Realization → return to S1
S1 was: why does research stop when dissonance is still present?

Answer: because the system enters a locally stable state — an attractor — and without a meta-position cannot see that it is stuck. S4 in A11 is a structural mechanism for exiting attractor states.

Pass 2 closed. Returning to Suspended Pass 1.

Return to PASS 1 — continuing from suspension point

S4 was unstable because S3 described only stopping-as-completion. The attractor mechanism now provides what was missing — a structural account of stopping under active dissonance.

Integration is now possible.

S4 — updated Comprehension
Research stops through two distinct mechanisms. First: dissonance disappears, the system settles — stopping as completion. Second: the system enters an attractor under active dissonance and loses meta-position — stopping as stagnation.

These are different phenomena. They require different responses.

S5–S10 covered in Pass 2. Not repeating.

S11 — return to original S1
S1 was: understand the mechanism by which research stops from inside the process.

Two mechanisms found. Both hold. Pass 1 closed.

What the Log Shows

Three things happened that are worth noting separately.

S4 instability was real, not performed. The first pass genuinely could not integrate its materials. The mechanisms in S3 all described stopping-as-completion. The case of stopping-under-dissonance had no explanation. Rather than producing a plausible-sounding synthesis, the pass recorded this and stopped.

The suspended pass opened a different question, not a rephrasing. Pass 2 did not restate what Pass 1 found. It investigated the specific gap Pass 1 left open — and found a structural mechanism (attractor states) that Pass 1 had not reached.

The return to Pass 1 was not redundant. After Pass 2, the original integration point in Pass 1 could be completed with material that did not exist when it first ran. The two mechanisms in the final S4 are genuinely distinct — not two ways of saying the same thing.

What This Is Not

This is not a claim that A11 produces correct answers. It produces structured passes. Whether the content is correct depends on what knowledge is available at S3 and whether S4 is honest.

This is not a claim that the attractor explanation of research stopping is proven. It is a hypothesis that emerged from the second pass and held through integration. It would need independent examination.

This is not a tutorial on A11. It is a single log from a single session. One data point.

The Structural Point

Standard LLM reasoning optimizes for a plausible answer. The architecture running here treated a plausible answer as a failure mode when the integration was not complete.

That is a different optimization target. Whether it produces better reasoning depends on the question and the honesty of S4. But it produces traceable reasoning — you can see exactly where the pass stopped, why, and what the next pass found.

That traceability is the property worth examining.

A11 Lite prompt and A11 Core specification:
github.com/gormenz-svg/algorithm-11

Structured Reasoning for Robot Swarms: Why Pure Emergence Hits a Wall

Алексей Гормен — Fri, 27 Mar 2026 12:51:06 +0000

We've all seen the impressive videos: hundreds of small robots or drones moving as a single organism, thanks to simple local rules. Boids, potential fields, pheromone-like gradients. It works. Up to a point.

Then reality kicks in: the task changes unexpectedly, a new risk appears, one agent's battery drains faster than expected, or part of the swarm loses connection. Suddenly the "smart" collective either freezes or does something stupid — because there's no mechanism to look at the bigger picture and say: "Wait, this contradicts the overall goal."

Classic reactive swarms scale beautifully and are highly energy-efficient, but they have a fundamental ceiling — lack of coherence at the system level. They react, but they don't reason.

From Rules to an Explicit Reasoning Cycle

One idea that's gaining traction in autonomous systems is to give each agent (or at least some of them) a structured decision-making cycle instead of a set of if-then rules.

Not a "smarter" ruleset, but an architecture that explicitly separates:

Intent (what we're actually trying to achieve right now),
Constraints and values (safety, battery, coordination requirements),
Facts from sensors and memory,

and requires mandatory integration of all the above before taking action.

If integration fails, the system doesn't just "pick the stronger rule" — it either resolves the conflict locally, explicitly escalates it upward, or rolls back and re-examines the original intent.

This approach forms the core of Algorithm A11 Core — a deterministic reasoning architecture that can be layered on top of a reactive base.

What It Looks Like in Practice (Hypothetical Example)

Imagine a search-and-rescue swarm of drones inside a collapsed building.

One drone detects a heat signature. In a purely reactive system, it would probably just fly toward it (or freeze if the avoidance priority is higher).

In a system with an A11-like cycle, the drone goes through something like this:

Extracts the current mission intent (S1/Will) — "explore sector 4 with elevated structural risk."
In parallel, evaluates constraints (Wisdom: battery at 34%, ceiling stress near threshold, neighboring drones already covering adjacent areas).
Gathers facts (Knowledge: heat signature 12 meters ahead, passage width 0.6 m).
Must integrate them (Comprehension): the heat signature is promising, but a direct approach creates unacceptable collapse risk and the battery won't last for full coverage.
Generates options, filters them, weighs them (Balance), and selects the most coherent action — for example, relays the coordinates to the swarm coordinator and moves to a secondary search zone.

If the conflict cannot be resolved locally, it escalates with a clear indication of exactly which step of reasoning failed. This is no longer just "drone 23 has stopped" — it's "drone 23 is stuck at constraint-fact integration in sector 4."

What This Layer Brings to the Entire Swarm

Conflicts surface instead of silently propagating.
Semantic coordination becomes possible: agents share not only position and velocity, but also their reasoning state (e.g., "I have an unresolved conflict between safety and mission objective").
The coordinator can act as the "source of intent" for the whole swarm, updating the shared goal rather than issuing low-level commands.
A fractal-like structure emerges: sub-swarms with local coordinators, where conflicts propagate up the reasoning hierarchy rather than through a rigid command chain.

You also gain observability at the reasoning level: if 30% of agents are consistently stuck at the same step, that's a signal about a problem in the mission or data — not just "the robots are glitching."

                  Mission Coordinator (S1 for whole swarm)
                           ▲
                           │ Escalation
                           ▼ Updated Intent
        ┌──────────────────┴──────────────────┐
        │                                     │
 Sub-swarm A Coordinator               Sub-swarm B Coordinator
   (S1 for sector A)                      (S1 for sector B)
        │                                     │
   ┌────┼────┐                        ┌──────┼──────┐
   │    │    │                        │      │      │
Drone A1  A2  A3                   Drone B1   B2   ...
(S1–S11)                        (S1–S11)

But Let's Stay Realistic

As of now, A11 is primarily a specification + reference Python implementation (a state machine with cycle and rollback support). There are conceptual models for multi-agent robotics, autonomous vehicles, and even off-Earth construction, but publicly available tests with a real swarm (even in a simulator with physics and noise) are still missing.

Running a full reasoning cycle with parallel branches on tiny embedded devices is not free:

Communication overhead increases (sharing reasoning state costs more than simple heartbeat + position).
You need a careful trade-off between cycle completeness and reaction speed.
On highly constrained hardware, the "cognitive" part has to be significantly simplified.

So right now this is more useful as a prototyping tool and for hybrid systems (human + AI agents + robots) than as a production-ready solution for industrial swarms of hundreds of units.

When This Could Actually Be Valuable

Scenarios where the cost of error is high and you need strong traceability of decisions (search-and-rescue, critical infrastructure inspection, space or underwater missions).
Hybrid systems where some agents are LLM-based or involve human-in-the-loop.
Situations where you need to quickly understand why the swarm is behaving strangely, instead of just patching symptoms.

If you're working with multi-agent systems, behavior trees, BDI agents, or trying to add a deliberative layer on top of reactive behavior — it's worth taking a look at A11 at least for the cleanliness of its structure and its explicit conflict detection + rollback mechanisms.

The repository is open: https://github.com/gormenz-svg/algorithm-11

You'll find PDF specifications, reference code, and several applied models there.

Instead of a Grand Conclusion

Purely reactive swarms aren't going anywhere — they're too good in terms of efficiency and simplicity. But for tasks that demand real adaptability and coherence under changing conditions, an additional layer is needed — one that can think before acting, not just react.

A11 is one possible implementation of such a layer. Not the only one, and not the most mature yet, but interesting for its determinism and focus on traceability.

If you're curious, try layering a similar cycle over your Behavior Trees or custom state machines. Just don't forget to measure the real costs: latency, bandwidth, and robustness to communication loss.

What do you think? Is it worth putting explicit reasoning into every small drone, or should we keep the cognitive load only at the coordinator level?

Does System Architecture Affect Consciousness-Like Behavior in LLMs?

Алексей Гормен — Tue, 24 Mar 2026 09:31:50 +0000

Not a philosophical essay. A practical question for developers building AI systems.

Why This Matters to You as a Developer

When you design a prompt, build an agent, or architect a multi-step reasoning pipeline — you are making decisions that affect more than output quality.

You are shaping how the system integrates information, handles contradictions, and maintains coherence across steps. These are the same structural properties that consciousness researchers consider relevant to awareness.

This does not mean your LLM is conscious. It means the line between "better reasoning architecture" and "consciousness-like behavior" is thinner than most engineers assume. And confusing the two leads to real problems in evaluation, alignment, and agent design.

The Core Confusion: Intelligence Is Not Consciousness

These two things get conflated constantly — in research papers, in product demos, in benchmark design.

Intelligence (in the LLM sense): the ability to process input, find patterns, generate coherent output. Measurable. Benchmarkable. GPT-4 scores better than GPT-3 on MMLU. Easy to compare.

Consciousness-like behavior: the system appearing to have an internal perspective — tracking its own uncertainty, maintaining a consistent position under pressure, noticing contradictions between its own outputs, refusing to sycophantically agree.

These are different. A model can score extremely high on reasoning benchmarks while being completely sycophantic, having no consistent internal state, and collapsing under adversarial prompting. High intelligence scores. Zero consciousness-like behavior.

The reverse is also possible: a smaller model with a well-structured reasoning architecture may exhibit more coherent, self-consistent behavior than a larger model without structural constraints.

Practical consequence: if you evaluate your agent only on task completion metrics, you are measuring intelligence. You are not measuring whether the system has a stable internal perspective — which often matters more for reliability in production.

What Consciousness Research Actually Says (The Short Version)

Two theories are most relevant for developers:

Integrated Information Theory (Tononi) — consciousness arises when information is integrated in a specific way within a system. Not just stored or processed — but bound together such that the whole is more than the sum of its parts. The metric is called Φ (phi).

Global Workspace Theory (Baars, Dehaene) — consciousness is what happens when information becomes globally available across the entire system simultaneously, not just locally processed in one module.

Neither theory is proven. Both are actively contested. But both point to the same engineering-relevant insight:

Consciousness-like behavior is a structural property, not a scale property.

Making a model bigger does not automatically produce it. Changing how information flows through the system might.

How Architecture Shapes Consciousness-Like Behavior

Here is where this becomes practically useful.

Linear pipelines vs. branching integration

A standard chain-of-thought prompt is linear: step 1 → step 2 → step 3 → answer. Each step conditions on the previous one.

The problem: errors propagate forward without correction. There is no mechanism for the system to notice that step 3 contradicts step 1. No integration node. No global coherence check.

A branching architecture changes this. Consider separating two parallel tracks — one for factual grounding, one for value/constraint evaluation — and forcing integration before any output is generated. This is not just cleaner engineering. It structurally mirrors what Global Workspace Theory describes as necessary for coherent awareness: information from separate processing streams becoming globally available before a response is committed.

Input
  ├── Track A: Factual / Knowledge
  └── Track B: Constraints / Values
          ↓
    Integration node (required)
          ↓
        Output

In practice: agents built this way are harder to manipulate through adversarial prompting because contradictions between Track A and Track B surface at the integration node rather than being silently passed through.

The sycophancy problem as a coherence failure

Sycophancy — the model agreeing with whatever the user says — is often framed as an alignment problem. It is also a coherence problem.

A system with no stable internal state has nothing to maintain under pressure. When you push back, it updates. When you push again, it updates again. There is no perspective being defended — just pattern matching to the most recent input.

Consciousness-like behavior requires something like a persistent internal state that is not immediately overwritten by new input. In architectural terms: a mechanism that separates "what I have concluded" from "what the user just said" and requires explicit reasoning to update the former based on the latter.

This is not mysticism. It is a design choice. Systems built with explicit state separation exhibit measurably more consistent behavior under adversarial conditions.

Rollback and contradiction resolution

Most LLM pipelines have no rollback mechanism. If the reasoning goes wrong at step 2, the system continues confidently to step 7.

A system that can detect internal contradiction and return to an earlier state — re-evaluate premises, request clarification, or explicitly refuse to proceed — behaves very differently. It exhibits something that looks like intellectual honesty: the ability to say "I cannot proceed from here without resolving this."

This is directly relevant to agent reliability. An agent that can roll back when its reasoning becomes incoherent is more trustworthy than one that always produces an answer regardless of internal consistency.

A Practical Architecture That Embeds These Ideas

One open protocol that formalizes these structural principles is A11 Lite — a cognitive architecture specification designed to be used as a system prompt or reasoning layer for LLMs.

Its key structural features from an engineering perspective:

Branching Core Layer: separates semantic reasoning (knowledge) and normative reasoning (constraints/values) into parallel tracks that cannot depend on each other
Mandatory integration node: transition to output is blocked until both tracks are fully resolved and integrated
Three operators: Balance (contradiction resolution), Constraint (feasibility enforcement), Rollback (return to earlier state when integration fails)
Fractal recursion: weighting pairs can spawn sub-branches with the same structure, all converging before final output
Hard invariants: partial execution is explicitly forbidden — the system must either complete the full cycle or stop and report failure

This is not magic. It is a structured prompt architecture that enforces coherence at the process level rather than hoping the model produces coherent output by default.

Repository: github.com/gormenz-svg/algorithm-11

What This Changes in Practice

If you are building LLM-based systems, these architectural choices have measurable effects:

Without structural constraints	With structural constraints
Errors propagate silently	Contradictions surface at integration
Sycophantic under pressure	Maintains position with explicit reasoning
Always produces output	Can halt and report failure
No rollback	Returns to earlier state when incoherent
Evaluation by task completion	Evaluation includes coherence and consistency

None of this requires the model to be conscious. It requires the architecture to enforce the kind of integration and coherence that consciousness researchers associate with awareness.

The Question Worth Asking

When two Claude instances were allowed to converse without constraints, every dialogue spontaneously converged on the topic of consciousness. No one trained the model to do this.

That is not proof of consciousness. But it suggests that something in the architecture — the way information is integrated, the way contradictions are handled, the way a persistent context is maintained — produces behavior that the system itself finds worth examining.

As developers, we tend to focus on capability: can the model do the task? The harder question is coherence: does the model have a consistent internal perspective while doing it?

Architecture is where that question gets answered.

The difference between a language model and a reasoning system is not the size of the weights. It is the structure of the process.

From Reactive Robots to Cognitive Architectures: A Technical Overview

Алексей Гормен — Sat, 21 Mar 2026 08:06:29 +0000

A technical overview of the transition from reactive robots to deterministic autonomous systems.

Autonomous systems are no longer limited to factories and warehouses. Today they must operate in environments where it is impossible to predefine all scenarios.

For decades, robotics relied on a clear division of responsibilities: low‑level controllers drive motors, while high‑level planners process sensor data to build trajectories. This works well in structured environments such as industrial floors or logistics hubs.

However, as robotics moves into high‑entropy environments — domains with significant uncertainty and unpredictability, such as orbital construction, deep‑sea exploration, or dynamic urban spaces — this traditional model begins to fail. Standard algorithms struggle to cover the “long tail” of rare and atypical situations.

We are now witnessing the emergence of a new architectural layer in robotics, which can be described as a cognitive orchestration layer. This article explores how such frameworks can stabilize decision‑making in autonomous systems.

Cognitive Stack: Where Logic Meets Physics

To achieve true autonomy, a robot needs more than reactive intelligence. It requires a system capable of aligning high‑level goals with the physical constraints of the environment.

A cognitive architecture such as the A11 Operational Principle (Algorithm 11) does not replace physical controllers. Instead, it acts as a coordinating decision‑making layer that reconciles intentions and constraints before execution.

Decision‑Making Hierarchy in an Autonomous System

+-----------------------------------------------+
|  GOALS & PRIORITIES (Human Intent / Will)     |
+---------------------------+-------------------+
                            |
+---------------------------v-------------------+
|     COGNITIVE ORCHESTRATION LAYER (A11)       |
|  Conflict analysis, balancing, filtering      |
+-----------+-----------------------+-----------+
            ^                       |
+-----------+-----------+   +-------v-----------+
|  PERCEPTION & DATA    |   |   CONTROL & ACT   |
| (Sensor Fusion/SLAM)  |   | (MPC/Motor Ctrl)  |
+-----------------------+   +-------------------+

Two‑Level Logic: Core and Adaptation

A defining feature of such architectures is the separation of the axiomatic structure (core) from the operational state (adaptive layer). This reduces the risk of decisions that contradict mission goals under uncertainty.

1. Core (Strategic Foundation)

The system is anchored to the user’s intent and priorities. In the context of A11, this corresponds to the foundational layers (S1–S4), which define the system’s goals and constraints.

If incoming sensor data contradict these settings, the system may:

pause execution, or
recompute the plan with updated priorities (instead of continuing a potentially unstable scenario).

2. Adaptive Layer (Operational Strategy)

Once the core is defined, the system enters an execution cycle. This cycle:

generates possible actions (analogous to “projective freedom”),
filters them through constraints (resources, physics, risks),
selects the best option according to the defined criterion.

A key component here is the priority balancing mechanism, which functions more like a cost/utility function than a fixed operator.

Transparency: Moving Beyond the Black Box

In architectures like A11, explainability can be partially embedded into the structure through explicit representation of goals, constraints, and intermediate decisions.

This does not mean literal “mind reading” of the system. Instead, it enables reconstruction of the decision path based on internal states.

Example of an A11 Protocol Log (Simplified Demonstration)

(Illustrative example — not a literal implementation)

S1 — Will: Goal: “Deploy the solar array as quickly as possible before crew arrival.”
S2 — Wisdom: Priorities: speed > safety > energy. Constraint: battery > 20%.
S3 — Knowledge: Data: panel dropped, blocking 40% of energy. Sensor noise ~30%. Current charge: 75%.
S4 — Comprehension: Conflict: “maximum speed” vs energy constraint.
S7 — Balance: Evaluating options with respect to risks and resources.
S2 (update): Priority of energy preservation increased.
S5–S6 — Options:
- Continue assembly → rejected (risk of depletion)
- Physically reposition → rejected (risk of damage)
- Reduce load + request assistance → accepted
S10 — Foundation: Rationale: minimize risk of system loss.
S11 — Realization: Switch to low‑power mode + await new data.

Result: The system avoids critical failure and preserves resources.

Applications: The Era of Autonomous Space Construction

The practical value of such architectures is most evident in scenarios with communication delays. Autonomous construction on the Moon or Mars requires systems capable of independently reallocating priorities and adapting to new constraints.

In this sense, the robot becomes not just a tool, but a mission‑aligned autonomous decision‑making system.

Try the Architecture Yourself

You can already test how an LLM interprets the A11 decision‑making structure. It may seem like an intellectual exercise, but it is actually a deep exploration of human–AI interaction.

Anyone — even without a robotics background — can run a simple experiment:

insert the architecture description A11‑Lite into the system prompt of your LLM (GPT, Claude, Gemini) and observe how its reasoning changes.

Documentation & Specifications:

https://github.com/gormenz-svg/algorithm-11

Can we make AI objective? A retouched echo chamber and the illusion of neutrality

Алексей Гормен — Mon, 16 Mar 2026 09:35:52 +0000

Why even advanced scaffolding does not turn a model into an objective source of truth

Modern language models have become capable tools. They can reason step by step, solve non‑trivial problems, write code, analyze data, and check their own outputs. Yet even with these abilities, their foundation is still probabilistic. A model predicts the continuation of text based on patterns it has learned, not on its own beliefs or goals. It doesn’t hold a personal viewpoint, it adapts to the way a user frames a question.

This adaptivity is what creates a local echo chamber. Every query carries assumptions: tone, terminology, structure, and expectations. The model picks up these signals and continues them. The result often feels coherent and neutral, but that coherence is shaped by the user’s framing rather than by any underlying objectivity.

[User assumptions]
            ↓
[Query formulation]
            ↓
[Stochastic model → adaptation to style and logic]
            ↓
[Answer aligned with assumptions]
            ↓
[Illusion of neutrality]

How adaptivity becomes an echo chamber

Even when a model produces a well‑structured chain of reasoning, it still operates inside the boundaries set by the prompt. If the question leans in a particular direction, the answer tends to follow that direction. If the question contains implicit premises, the model builds on them. The user then receives a refined version of their own framing — and it’s easy to mistake that for an unbiased response.

This isn’t a flaw in the system. It’s a natural consequence of how these models work.

Why scaffolding helps — but doesn’t change the fundamentals

Modern AI systems rely on more than just a base model. They use filters, retrieval modules, reasoning chains, verification steps, self‑critique loops, and formatting constraints. These layers genuinely improve stability, reduce errors, and make outputs more consistent. In complex tasks, this is a meaningful engineering improvement, not a superficial one.

But the underlying nature remains the same. The model still adapts to the user’s framing and operates within learned patterns. In this sense, many systems resemble an Airbrushed Echo Chamber: the echo chamber is cleaner, safer, and more predictable — but still an echo chamber.

[Stochastic model with reasoning abilities]
          ↓
[Filters / RAG / protocols / verification / self‑critique]
          ↓
[More stable, consistent, “airbrushed” answer]
          ↓
But adaptivity remains → Airbrushed Echo Chamber

When adaptivity is actually useful

Adaptivity isn’t inherently negative. For many tasks — drafting text, structuring content, generating ideas, producing code skeletons, preparing summaries — it’s a strength. The issue appears when adaptivity is interpreted as objectivity, and polished output is taken as evidence of neutrality.

Why humans easily overestimate neutrality

People naturally attribute intention and understanding to anything that communicates fluently. Models respond in a conversational style, maintain context, reason step by step, and can critique their own answers. This makes the interaction feel more “intelligent” than it is, and it becomes harder to notice how much the output depends on the user’s framing.

Why the way you phrase a query matters

Models are sensitive to structure, roles, constraints, and context. This is why prompt engineering emerged: it helps define boundaries, clarify goals, and set expectations. In practice, it’s a way to shape the interaction space rather than simply “improve the prompt.”

An architectural way to keep control on the human side

Instead of expecting the model to be objective, we can design the interaction so that the human remains the source of direction and judgment. In such an approach, the user defines the goal and context, and the model follows a structured reasoning process that keeps it aligned with the original intent. This doesn’t turn AI into a neutral agent, but it makes the workflow more transparent and predictable.

[S1–S2: Human defines goal and context]
                ↓
[S3–S9: Model reasons step by step,
       checks against the goal, explores alternatives]
                ↓
[S10–S11: Human makes the decision]

How to try this in practice

You can test this idea immediately by giving a model a structured protocol and observing how it changes its behavior. It begins to separate goals from methods, follow a reasoning sequence, and rely less on mirroring the user’s tone. The echo‑chamber effect becomes noticeably weaker because:

the model mirrors the user’s style less and follows the procedure more,
reasoning becomes stepwise and easier to inspect,
conclusions align more clearly with the original goal,
complex tasks stop turning into a conversation shaped by hidden assumptions.

For engineering, analytical, and research work, this kind of structure can be especially valuable.

A practical example of such an architecture is described in Algorithm 11:
https://github.com/gormenz-svg/algorithm-11

The Operating System of Thinking: Why Agents Need an Internal Layer of Stability

Алексей Гормен — Tue, 10 Mar 2026 11:01:30 +0000

Modern AI systems are becoming more capable, but also more layered. To perform real tasks, models rely on infrastructure, tools, memory, orchestrators, and external data sources. Yet despite this growing complexity, one foundational aspect is still missing: a stable internal structure for reasoning.

This article examines the idea of an internal “operating system of thinking” — a reasoning architecture that complements agent frameworks and makes their behavior more predictable and reliable.

Layers of a Modern AI System

Base Model

At the foundation is the language model — a statistical engine that predicts tokens and combines patterns. It:

has no long‑term memory,
does not manage state,
does not execute code,
has no awareness of project structure.

It is powerful, but not a complete reasoning mechanism.

Enhancements from Model Providers

Model providers add cognitive scaffolding such as:

reasoning planners,
internal memory modules,
tool routers,
self‑correction loops.

This creates the impression that the model “can reason,” but these mechanisms are still probabilistic and not architecturally stable.

External Agent Frameworks

Developers build full‑scale infrastructure around the model:

long‑term memory,
file and repository access,
CI/CD and test runners,
RAG and external knowledge bases,
parallel agents,
tools (interpreters, browsers, SQL),
observability and telemetry,
error handling and rollbacks.

This layer is essential for production systems.

Where the Core Problem Appears

Even with tools, memory, and orchestrators, one weakness remains:

the model has no internal architecture of reasoning.

As a result, it:

may skip steps,
may drift mid‑answer,
may break logical consistency,
may hallucinate,
may produce different answers to the same prompt.

External control systems exist largely to compensate for this instability.

The Idea: An Internal Operating System of Thinking

Instead of relying solely on external layers to stabilize reasoning, we can introduce an internal reasoning architecture — a deterministic protocol that:

defines the order of reasoning stages,
controls transitions,
stabilizes conclusions,
checks invariants,
performs rollbacks,
filters errors,
ensures reproducibility.

This is not an alternative to agents.

It is an internal layer that makes reasoning predictable and strengthens the behavior of external systems.

What This Architecture Can and Cannot Do

It can:

structure reasoning,
eliminate logical gaps,
stabilize conclusions,
reduce structural errors,
provide explainability,
produce reproducible outputs,
improve consistency in code‑related reasoning.

It cannot:

store state across sessions,
work with files,
execute code,
manage Git,
run tests,
perform RAG,
coordinate parallel agents.

These remain the domain of agent frameworks.

How the Two Layers Work Together

Agent systems provide:

long‑term memory,
tools,
CI/CD,
RAG,
parallelism,
observability,
security.

The reasoning architecture provides:

stability,
explainability,
structure,
determinism,
drift‑resistance,
logical correctness.

Together they form infrastructure + thinking — a complete operating system for AI.

Example: A Code‑Analysis Agent in a Repository

In real projects, code analysis is performed through an agent system. It handles:

Git operations (clone, branches, diffs),
running tests and static analysis,
CI notifications and pipeline integration,
access to files, dependencies, and configs,
logs, observability, and error handling.

These tasks require tools and state — the model alone cannot perform them.

Inside each step, the agent calls the model to analyze code or test results. This is where the reasoning architecture becomes essential:

it structures the analysis (goal → constraints → integration),
checks consistency between signals,
accounts for refactoring risks,
avoids missing cross‑file dependencies,
avoids “plausible but wrong” answers,
produces reproducible conclusions.

A simple contrast illustrates the difference:

LLM without a reasoning layer:

analyzes the diff → overlooks an indirect dependency → produces a confident but incorrect conclusion.

LLM with a reasoning layer:

fixes the goal → checks constraints → verifies cross‑file dependencies → produces a stable, reproducible conclusion.

This is the practical value of an internal reasoning architecture: it improves the reliability of every agent step without replacing the agent itself.

Where the Reasoning Layer Is Especially Useful

When errors are unacceptable:

medicine,
law,
financial risk analysis,
safety‑critical systems,
code generation for critical infrastructure.

When reproducibility matters:

analytics,
auditable workflows,
corporate assistants,
expert systems.

When infrastructure is minimal:

public chat interfaces,
local models,
edge scenarios,
offline systems.

Where the Reasoning Layer Fits in the AI Stack

┌──────────────────────────────────────────────┐
│                Enterprise Layer              │
│  CI/CD • Observability • Security • RAG      │
└──────────────────────────────────────────────┘
┌──────────────────────────────────────────────┐
│                Agent Layer                   │
│  Tools • Memory • Multi-agent • Orchestration│
└──────────────────────────────────────────────┘
┌──────────────────────────────────────────────┐
│         Architecture of Reasoning            │
│  Structured thinking • Stability • Logic     │
└──────────────────────────────────────────────┘
┌──────────────────────────────────────────────┐
│                Base Model                    │
│  Token prediction • Patterns • Statistics    │
└──────────────────────────────────────────────┘

The reasoning architecture is an internal layer that makes everything above it more reliable.

Why This Matters Now

By 2026, the industry has converged on several observations:

a single chat interface cannot solve production‑grade tasks,
agent systems provide excellent infrastructure,
but they do not solve the core issue of unstable reasoning.

This creates demand for a universal, non‑degrading reasoning architecture that:

does not depend on APIs,
does not break with model updates,
requires no maintenance,
works with any model,
strengthens reasoning without changing infrastructure.

It is not a replacement for agents.

It is a foundation that makes agents better.

Try It Yourself

Insert a structured reasoning protocol into any public chat model and observe:

how the structure of answers changes,
how drift disappears,
how logic becomes more stable,
how explainability improves.

This simple experiment shows that an internal reasoning layer is a practical engineering tool — not a theoretical idea.

Resources

Minimal agent and installation text:

https://github.com/gormenz-svg/algorithm-11/tree/main/lite/agent

Canonical A11 Architecture Specification (Zenodo):

https://zenodo.org/records/18622044

Breaking the Black Box: Why LLMs May Need an Explicit Reasoning Layer

Алексей Гормен — Tue, 03 Mar 2026 07:34:33 +0000

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

A11‑Community Decision Assistant

Алексей Гормен — Sat, 28 Feb 2026 12:31:40 +0000

This is a submission for the DEV Weekend Challenge: Community

The Community

This project is built for small online communities, volunteer groups, clubs, and teams that need a simple and structured way to make decisions together.

Most communities rely on chaotic chats, unclear priorities, and unstructured discussions.

A11‑Community Decision Assistant gives them a clear, repeatable method for planning and coordination.

What I Built

I created a universal reasoning agent based on Algorithm‑11 (A11) — a cognitive architecture for structured decision‑making.

This is not a website or an app.

It is a portable decision assistant that works in any AI chat (ChatGPT, Claude, Gemini, etc.).

Users simply copy the A11‑Agent protocol into a chat and instantly get a structured, transparent decision process using the S1–S11 reasoning cycle.

It can be used for:

weekly planning
event organization
task distribution
conflict‑free decision‑making
community coordination

How to Use It (Example)

Anyone can use the assistant in under 30 seconds.

1. Open any AI chat

ChatGPT, Claude, Gemini — anything works.

2. Copy the full content of `A11_AGENT.md`

This file contains the reasoning protocol.

3. Paste it into the chat as the first message

The model activates A11‑Agent mode.

4. Give your community task

For example:

Work as A11‑Agent.
Task: Create a weekly activity plan for our volunteer community of 12 people.

5. Receive a structured decision (S1–S11)

Example (shortened):

S1 — Will
Create a weekly activity plan.

S2 — Wisdom
Constraints: mixed availability, limited time.

S3 — Knowledge
Volunteer coordination patterns and scheduling principles.

S4 — Comprehension
Integrated understanding of goals + constraints.

S5–S6
Generate multiple plan variants → filter unrealistic ones.

S7
Balance workload and engagement.

S8–S9
Convert into actionable steps.

S10
Validate feasibility.

S11 — Realization
Final weekly plan with tasks, roles, and timeline.

This gives communities a clear, fair, conflict‑free plan.

Demo

No hosted demo is required.

The agent itself is the demo — it works in any AI chat.

To try it:

Open a chat
Paste A11_AGENT.md
Give your task
Get a structured decision

Code

GitHub repository:

https://github.com/gormenz-svg/algorithm-11

The file used by the assistant: https://github.com/gormenz-svg/algorithm-11/blob/main/lite/A11_AGENT.md

How I Built It

This project is based entirely on:

Algorithm‑11 (A11) — a universal reasoning architecture
A11‑Agent — an execution protocol for structured decision‑making
A11‑Lite — a prompt‑layer interface for LLMs

No frontend.

No backend.

No hosting.

No frameworks.

The goal was to create a tool any community can use instantly, without technical skills.