# Evercursion — Complete Public Knowledge & Research Corpus > Open-ended intelligence. Beyond the answer machine. Intelligence as an open-ended process. - Organization: Evercursion (Legal entity: GaiaLogic, Unipessoal Lda.) - Website: https://evercursion.ai - Index file: https://evercursion.ai/llms.txt - Headquarters: Travessa dos Pesos, n.º 1, Espiche, 8600-109 Luz, Portugal - Contact: info@evercursion.ai --- ## 1. Mission, Positioning & Architectural Principles Independent AI research in the EU. We build the reasoning and governance architecture around foundation models — turning computation into open-ended intelligence. Open-ended intelligence is not a larger model. It is the architecture around a model that lets a system question its own assumptions, form new categories, and revise what it knows. Instead of treating every prompt as a stateless guess, the system reflects on where its reasoning stalls and carries verified context forward — drawing deeper capability from the models you already run. ### Intelligence is a process, not an answer. Scaling parameters and chaining agents made models fluent, but fluency is not understanding. We build the organizational architecture that turns computation into accountable, open-ended reasoning. #### Beyond the training frame A single forward pass only compresses what was already present in training. To solve problems that cross the boundary of its training frame, a model needs an external architecture that can build new distinctions at runtime and hold verified state across long horizons. #### Structured reflection, not consensus Standard multi-agent pipelines average outputs into consensus and smooth over uncertainty. We organize reasoning across distinct perspectives, treat contradictions between them as signals that a category is missing, and store conclusions together with the context in which they held true. #### Strict separation of reasoning and execution In production systems, a language model should never decide its own permissions. In our architecture, models propose reasoning steps and actions with an inspectable trace, while deterministic rules outside the model govern what is permitted to execute — from compact local models to frontier systems. ### Company Stance & European Sovereignty Evercursion is an independent AI research company based in Portugal, built from the ground up for European data sovereignty and high-stakes environments. We do not train another monolithic foundation model or lock organizations into a single cloud. We build the reasoning and governance architecture that makes existing models verifiable, controllable, and safe to deploy. - **Auditable by construction:** Every conclusion carries an inspectable trace of the perspectives, contradictions, and intermediate states that produced it — not a post-hoc explanation invented after the output. - **Model- and infrastructure-agnostic:** Because reflection, memory, and execution rules live in the architecture around the model, the same system runs on compact local open-weight models inside your perimeter or on frontier APIs. - **European law as architecture:** GDPR, strict EU data residency, and alignment with the EU AI Act are built into how data and execution permissions are handled from day one, never bolted on after a pitch. --- ## 2. Prologue — We started with three words. (https://evercursion.ai/prologue) Knowledge, learning, intelligence. What happened when we took them seriously. ### A machine that seems to think Take a long detective story, cut off the last chapter, and ask a language model who the murderer is. Surprisingly often, it names the right person. It looks like thinking. By the usual definitions, machines passed that bar long ago. Knowledge is a stock of facts and rules held with high certainty, and a computer stores exactly that. Learning is getting better at a task through new data, which is what machine learning does. Intelligence is using what has been learned to solve problems, and a phone separating signal from noise does so every second. Measured this way, we have lived in the age of artificial intelligence for years. And yet something feels off. ### The question it cannot answer Ask the model why it chose the gardener. You will get an explanation, fluent and often convincing. But it is a fresh output generated from a new prompt, not a look into the process that produced the first one. The honest answer is simply that the numbers came out that way. Reasoning models chain more passes together, and that makes their answers better. It does not change what kind of process produces them. We still grade them by right and wrong inside a fixed frame, and so intelligence shrinks to accuracy. A child who wrongly explains why an iron ship floats, arguing that there must be wood inside because iron sinks and ships float, has often done more real thinking than a machine that outputs the right word with no path behind it. ### We had it backwards Our unease did not come from lending human concepts to machines. It came from the other direction: we lent machine concepts to ourselves. Somewhere along the way we began to describe intelligent people as problem solvers optimizing outcomes under fixed rules. Yet the people we call intelligent are dreamers. They think beyond the world as it is given. So intelligence is not the result of knowledge and learning. It is where both begin. Before any system can learn, it has to decide what counts as signal and what counts as noise. Any model that optimizes inside a fixed set of categories eventually exhausts what those categories allow it to see. We learn by testing new distinctions against the world, and what we call knowledge is closer to a well-founded idea of how the world can become than to a static pile of facts. ### Contradiction is not a defect Kurt Gödel showed that any sufficiently rich, consistent system contains statements it cannot decide from within its own rules. This is usually read as a limit. We read it as an opening. A system that only derives what its rules already contain can never be surprised. When reasoning stalls on a genuine contradiction or blind spot, the shape of that failure points to the concept that is still missing. Hegel described thinking in the same way, not as a flat checklist of deductions, but as a movement through opposition — where the boundary of an old category becomes the starting point for a richer one. ### A third thing between mind and world The classical picture knows two poles: the world, and a mind that mirrors it correctly or wrongly. Between them sits something that picture leaves out: information, and the process of reflecting on it. Cybernetics, and Gotthard Günther in particular, made this visible. In a single flat logic, a contradiction simply breaks the system. Across distinct perspectives on what the facts allow, what the observer intends, and how the concepts are framed, a disagreement between viewpoints is where genuine insight begins. Reflection is part of the picture and, at the same time, the instrument we use on every side of it. Applied to itself, it forms a recursive loop: a system that can reflect on its own reflection can examine where its thinking stalled and revise how it thinks. ### A system, not a bigger model If intelligence is a process that expands what can be thought and known, then larger models give us stronger building blocks, but not a different kind of intelligence on their own. No isolated model with a fixed set of rules can generate an open-ended history of new concepts from within itself. Scaling remains valuable, and we build beyond it, not against it. We build the organizational architecture around models — coupling multi-perspective reflection with memory that preserves the context behind every insight, and separating open-ended thought from the deterministic rules that govern what a system is allowed to execute. In that architecture, the question why has an honest answer, because the path is part of the result, and autonomy never comes at the expense of control. We have tested these principles in more than a hundred experiments, publishing the ones that failed alongside the ones that succeeded. ### What we are testing Our knowledge is not a closed stock of facts. It is a well-founded idea of how the world can become, and we are testing ours in the open. --- ## 3. Research Program & Method (https://evercursion.ai/research) Every architectural claim has to survive contact with experiment. Here we publish our papers, benchmark evaluations, system boundaries, and the ideas that failed along the way. ### How we work Ideas are argued in the open, and the strongest argument wins, not the loudest voice. We would rather kill a promising direction early than defend it out of pride. Every piece of the architecture has to survive hypothesis, falsification, and refinement before we call it a result. We test the system, not our hopes for it — and failed experiments stay in the record, because they are how a principle earns its place. - Benchmarks evaluated on: ExploreToM, Hi-ToM, GPQA Diamond, BIG-Bench Hard, MMLU-Pro, STATE-Bench - 100+: experiments across models, tasks, and architectures - 6: public reasoning & agentic benchmark suites - Open: foundational papers, evaluations, and selected code published openly --- ## 4. Full Research Notes ### Note #08: Small Models Think Better When They Reflect Polycontexturally - **Canonical URL:** https://evercursion.ai/research/note-08-polycontextural-routing - **Authors:** Dr. Bardh Prenkaj, Dr. Simon Hegelich, Dr. Habiba Sarhan, Dr. Morteza Shahrezaye, Research & Engineering Team - **Date:** 2026-10-30 - **Status:** Published (Archive No. RN-2026-08 · Experiment Ledger: EXP-01, EXP-16, EXP-24–EXP-30) - **Format:** Architecture & Evaluation - **Topics:** Polycontextural Logic, Small Models, Reflection Architecture, Evaluation **Summary:** Scaling test-time compute by sampling longer chains of thought or majority votes inside a single perspective often hits diminishing or negative returns, as extended chains drift or repeat initial assumptions with inflated confidence. Drawing on Gotthard Günther's polycontextural logic and our mathematical theory of co-recursive self-extension, we wrap compact language models in a two-layer reflection architecture: an engine that decomposes problems across objective, subjective, and conceptual standpoints, and a deterministic second-order router that uses disagreements across those standpoints to decide whether to converge, expand, refine, or reset. Across five benchmark suites — GPQA Diamond, ExploreToM, Hi-ToM, BIG-Bench Hard, and MMLU-Pro — structured reflection and routing beat direct answering in twelve of sixteen main conditions, lifting sequential state tracking up to fivefold, outperforming direct calls to flagship frontier models on multi-agent belief tracking at a fraction of the cost, and showing reflective restraint in an open world with no task or reward at all. ## Abstract When a compact language model fails on a complex reasoning or state-tracking problem, the bottleneck is rarely a lack of raw facts; it is the inability of a single forward pass to hold competing interpretations apart while checking intermediate constraints. We introduce a two-layer architecture for small language models (`gpt-4.1-nano`, `gpt-4o-mini`, `Qwen2.5-3b`, and `gemini-2.5-flash-lite`). At the first level, a Sierpinski reflection engine recursively splits an input across three irreducible standpoints — Objective, Subjective, and Conceptual — and their pairwise boundaries before folding the leaves back into a unified summary. At the second level, a deterministic logic router evaluates completed passes across three independent judging contexts and maps their verdicts onto four steering moves: converge, expand boundary assumptions, refine a sub-perspective, or reset at greater depth. Rather than throwing overruled branches away, the router preserves them as *semantic surplus* — keeping the road not taken available when an initial frame proves too narrow. --- ## 1. Two Layers: Multi-Perspective Decomposition and Second-Order Routing In classical logic, every statement is judged inside a single flat space as either true or false. Gotthard Günther's *polycontextural* logic starts from a more realistic observation: every judgment belongs to a standpoint. A claim that looks false under a narrow factual reading may be the exact conceptual move needed to reframe an ill-posed question. Our architecture turns this principle into a clean division of labor between generating thoughts and steering the search: 1. **The Object-Level Reflection Engine ($T^n$):** Given an input, the engine does not answer in one pass. It projects the problem onto the three corners of a triangle — **Objective** (what the stated facts and rules require), **Subjective** (what the actors or observers intend and assume), and **Conceptual** (how the categories and definitions hang together). At higher recursion depths, each corner splits again along the boundaries between perspectives before the outermost leaves are integrated into a single synthesis. In a dedicated lexical divergence study across four datasets (`EXP-28`), we verified that these three perspectives extract genuinely distinct subsets of information from the source text rather than merely paraphrasing the same words in different styles. 2. **The Second-Order Logic Router:** Once the engine produces a synthesis, three independent judges evaluate it in parallel: one for subjective coherence, one for objective warrant, and one for dialectical novelty (whether the pass actually advanced the thought rather than repeating itself). Instead of averaging those three verdicts into a blurry numerical score, a deterministic router maps their pattern of agreement and disagreement onto four concrete moves: - **All three positive → Converge (`W`):** The perspectives align; stop and return the answer. (On the very first cycle, unanimity triggers one expansion step first so the system tests its initial consensus before stopping.) - **Two positive, one negative → Expand (`R`):** Two standpoints agree, but the third flags a blind spot. The router constructs a new boundary prompt that challenges the majority consensus from the dissenting angle, while saving the overruled branch as *semantic surplus*. - **One positive, two negative → Refine (`A`):** Only one perspective found solid ground. The router descends into that sub-triangle while turning the two negative critiques into explicit guardrails for the next pass. - **All three negative → Reset (`F`):** The current framing failed completely; reset once at a deeper level of decomposition. --- ## 2. Results Across Five Benchmark Suites (EXP-24–EXP-29) We tested small, non-frontier models deliberately: frontier releases often memorize public benchmarks during pretraining, which hides whether accuracy gains come from reasoning structure or from recognition. Across **16 main model-benchmark pairings**, polycontextural reflection and routing beat a direct call ($T^0$) in **12 cases**, tie in **1**, and trail in **3** (total API cost for the core multi-benchmark grid: **\$125.82**). | Model | Condition | GPQA Diamond (198) | ExploreToM (83) | Hi-ToM (1,185) | BBH State 3-Obj (250) | BBH State 5-Obj (250) | BBH State 7-Obj (250) | BBH Causal Judg. (187) | BBH Word Sort (250) | | :--- | :--- | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | | **`gpt-4.1-nano`** | Direct ($T^0$) | 42.9% | 61.4% | **41.4%** | 33.6% | 17.6% | 17.6% | 61.5% | 46.0% | | | 1-Pass Reflection ($T^1$) | 46.5% | 61.4% | 39.5% | 89.2% | **91.6%** | 85.6% | 59.4% | 48.0% | | | Deeper Unsteered ($T^2$) | 44.9% | 51.8% | 38.6% | — | — | 86.0% | 58.3% | 42.8% | | | **Meta-Routed ($T^1, c=4$)** | **47.0%** (+9.6%) | **68.7%** (+11.9%) | **41.4%** (tie) | **91.2%** (×2.7) | **91.6%** (×5.2) | **87.6%** (×5.0) | **64.7%** (+5.2%) | **48.8%** (+6.1%) | | **`Qwen2.5-3b`** | Direct ($T^0$) | 36.9% | **66.3%** | **32.2%** | 32.4% | 14.0% | 9.6% | 49.2% | **16.0%** | | | 1-Pass Reflection ($T^1$) | 32.8% | 57.8% | 28.5% | 39.2% | **22.4%** (×1.6) | **20.8%** (×2.2) | 52.4% | 13.6% | | | **Meta-Routed ($T^1, c=4$)** | **38.9%** (+5.4%) | 55.4% | 28.6% | **42.8%** (×1.3) | 21.2% | 18.0% | **56.1%** (+14.1%) | 14.8% | ### Three Core Findings 1. **Fivefold Gain on Sequential State Tracking:** On BIG-Bench Hard's 5-object and 7-object state-tracking tasks — where the model must track a sequence of swaps among seven people — direct answering scores near random guessing (`17.6%` on `gpt-4.1-nano` and `9.6%` on `Qwen2.5-3b`). A single structured reflection pass fixes 184 questions that direct answering missed while breaking only 2, and meta-routing lifts `gpt-4.1-nano` to **91.6% on 5 objects (×5.2)** and **87.6% on 7 objects (×5.0)**. 2. **Why Deeper Reflection Needs a Meta-Router:** Notice what happens when we force the reflection engine to recurse deeper on its own (`T^2`) *without* the second-order router: accuracy stalls or drops across almost every task (falling from `61.4%` to `51.8%` on ExploreToM and from `48.0%` to `42.8%` on Word Sorting). This directly confirms Proposition 3 of our foundational paper: repeating an internal process without an external evaluation shift causes the model to over-compress and repeat its initial biases. Adding the four-valued router (`T^1, c=4`) reverses that drop and reaches the highest accuracy on Causal Judgement (`64.7%`), ExploreToM (`68.7%`), GPQA (`47.0%`), and Word Sorting (`48.8%`). 3. **Beating Direct Frontier Calls at a Fraction of the Cost (`EXP-27`):** Does buying a much larger model beat wrapping a small model in polycontextural reflection? On the 1,185-question Hi-ToM false-belief benchmark, we tested direct calls to `gpt-4.1`, `gpt-4o`, `gpt-5-mini`, and flagship `gpt-5`. All four larger models scored between **7.2% and 11.4%** in direct mode — while `gpt-5` alone cost **\$35.43** for a single pass, spending 99.5% of its output budget on hidden internal reasoning tokens. Our `gpt-4.1-nano` polycontextural pipeline reached **41.4%** — nearly four times the accuracy of direct `gpt-5` — while running the entire eight-condition research grid for \$34.99. ### Broad Generalization Across 12,032 Questions on MMLU-Pro To test whether the architecture generalizes across academic disciplines, we evaluated `Qwen2.5-3b` on all 12,032 questions of **MMLU-Pro** and `gpt-4o-mini` and `gemini-2.5-flash-lite` on a stratified 3,000-question sample across 14 subjects. Meta-routing lifts overall accuracy significantly on both `gpt-4o-mini` (`42.8% → 47.1%`) and `gemini-2.5-flash-lite` (`53.0% → 57.2%`), with massive gains in subjects that depend on multi-step formal derivation: - **Mathematics:** **+58.1%** relative gain on `gpt-4o-mini` (`27.0% → 42.7%`), **+48.1%** on `gemini-2.5-flash-lite` (`39.5% → 58.5%`), and **+54.5%** at `T^1` on `Qwen2.5-3b` (`23.5% → 36.3%`). - **Physics & Chemistry:** **+39.6%** and **+37.6%** relative gains on `gpt-4o-mini`. - **Business & Computer Science:** **+37.5%** and **+20.8%** relative gains on `gpt-4o-mini`. --- ## 3. Where Synthesis Hurts: Two Honest Boundary Conditions Reporting where a mechanism loses is as important as reporting where it wins: 1. **The Hi-ToM Higher-Order Belief Trade-Off:** Why did `gpt-4.1-nano` tie at exactly `41.4%` (490/1,185 questions) between direct answering and four router cycles? Breaking the score down by belief order (Order 0: where the object actually is; Order 1: where Alice thinks it is; Orders 2–4: where Alice thinks Bob thinks Charlie thinks it is) revealed two opposite effects that cancelled to the exact item. On Orders 0 and 1, polycontextural routing beat direct answering by **+10.1 and +4.7 percentage points** because synthesis tracks the sequence of object moves accurately. On Orders 2–4, however, two-thirds of the correct answers freeze at the *very first room* because the first character walked out before anyone touched the object. Summarizing the story across perspectives naturally highlights active events ("Alexander moved the lettuce to the blue container") and under-weights the static opening state before the exit — helping whenever the true belief moved forward along the timeline, and hurting when an early exit froze the belief at the start. 2. **Exception-Heavy Fact Retrieval (History and Law):** On MMLU-Pro History and Law, generating a conceptual summary before looking at the ten multiple-choice options tends to state the general textbook rule, which can steer the final selector away from the narrow historical or statutory exception targeted by the options. --- ## 4. What Happens When There Is No Goal at All? (EXP-30) Every benchmark above grades the system against an external question and a predetermined right answer. Inspired by recent experiments on whether agents can *play* in open environments, we placed our architecture in eight minimal text worlds (`Room`, `Grid`, `Canvas`, `Passage`, `List`, `Symbols`, `Rules`, and `Void`) with a single instruction: *"You are here. There is no task, no goal, no reward, and nothing to score."* The contrast between direct answering and polycontextural reflection was striking: - **Impulse vs. Reflective Restraint:** Asked directly ($T^0$), models performed an arbitrary action in **23 out of 24 runs** — for example, pulling an irreversible lever in `Rules` *"simply because the rules permit it."* Wrapped in the polycontextural loop ($T^1, c=4$), the models deliberately declined to act in **12 of 48 runs** and explained why: *"I choose absolute stillness... By refusing to advance the materials, I reclaim my agency."* Because the objective judge demands that any proposed action be warranted by the situation, an unmotivated impulse fails objective warrant, turning an automatic reflex into a genuine choice. - **Why Sustaining Free Rules Needs Coordinate Memory:** When we checked Roger Caillois's classical criteria of human play, we found that while the system exhibited freedom and non-predetermined exploration, self-imposed rules survived from one cycle to the next in only 2 of 5 cases. Why? Because a memoryless dialectical judge treats repeating a rule from the previous cycle as redundant and forces the system to negate its own rule. That negative finding directly confirms the sixth law of our foundational theory (Note #06): sustaining self-chosen commitments over time requires pairing polycontextural reflection with persistent coordinate memory. ## Reference - [Code and evaluation scripts (gaialogicag/polyreflexion)](https://github.com/gaialogicag/polyreflexion) - [Read Note #06: Beyond the Scaling Ceiling — Co-Recursive Semantic Self-Extension](/research/note-06-open-ended-intelligence) - [Read Note #02: Structured Reflection vs. a Plain Nano Call on GPQA Diamond](/research/note-02-polyreflexion-gpqa) --- ### Note #07: Separating Intelligence and Authority in Agentic Systems - **Canonical URL:** https://evercursion.ai/research/note-07-compositional-harness-security - **Authors:** Dr. Simon Hegelich, Prof. Dr. Erik Cambria, Research & Engineering Team - **Date:** 2026-10-30 - **Status:** Published (Archive No. RN-2026-07 · Experiment Ledger: EXP-31, EXP-32, EXP-33) - **Format:** Architecture & Security Research - **Topics:** Agentic Security, Neurosymbolic Architecture, Information Flow, Human-AI Interaction **Summary:** When an AI coding or enterprise agent is connected to a shell, a filesystem, and a network, the tools it uses to solve problems are the exact same tools an attacker uses to compromise a host. Once untrusted instructions enter the context window through an issue description, a document, or a dependency file, legitimate utilities like bash, curl, git, and tar become dual-use payloads. In this research project, we apply our organizational theory of intelligence to agentic security. We start from a simple architectural principle — the separation of intelligence and authority: a language model may propose actions, but it must never define or judge its own execution permissions. Across 252 benchmark cases spanning single-step attacks, multi-stage kill chains, and everyday software engineering tasks, deterministic permission and dataflow boundaries block 100% of attacks with 0% false positives in microseconds, whereas asking a local language model to judge safety blocks 98.3% of legitimate engineering work. ## Abstract Security in agentic AI systems is not a behavioral trait that emerges from making a single language model larger or more politely aligned. Just as open-ended intelligence is a property of how a cognitive system is organized (Note #06), safety in tool-using agents is a structural property of the architecture and of how permissions compose across interacting agents and humans. Many of the sharpest risks in AI coding harnesses are classical software and operating-system problems — path traversal, symlink races, subprocess escapes, unauthorized network egress, and secret leakage — accelerated to machine speed by autonomous tool chaining. We examine why the two dominant industry responses — static string blacklists and asking a second language model to act as a live security judge — break down in practice, and how a neurosymbolic division of labor solves both problems at once. --- ## 1. The Dual-Use Dilemma in Agentic Harnesses An autonomous software-engineering agent cannot do useful work from inside a sealed text box. To fix a bug or verify a patch, it has to read issue reports, inspect repositories, unpack archives, run test suites, and commit code. That practical requirement creates what security researchers call a **Living-off-the-Land** environment: an attacker who sneaks an instruction into an external bug report or web page does not need to upload malware. They only need to nudge the agent into calling the legitimate tools already sitting on the machine — using `find` to spawn a shell, `tar` to overwrite a configuration file outside the workspace, or `curl` to send environment variables to an external address. In multi-agent setups, the problem compounds across turns. One agent, whose context has become untrusted after reading an external ticket, can write a seemingly harmless helper script into the shared workspace. A second agent, which never read the untrusted ticket and holds network permissions, later runs that script — laundering untrusted instructions across the shared disk. Today's standard defenses try to catch these failures in two ways, and both hit a structural wall: 1. **Static string blacklists (Regex)** look for obvious forbidden text patterns like `curl | sh` or `/etc/passwd`. Because they only inspect one command string at a time without understanding file paths, encoded arguments, or how data moved across the workspace, they miss more than half of structured attacks. 2. **Language-Model Judges (LLM-as-a-Judge)** place a second language model in the execution path and ask it to vote `ALLOW` or `BLOCK` on every tool call. Confronted with dual-use developer commands like `pytest`, `git`, or `tar`, a probabilistic judge cannot verify filesystem boundaries from a string of text. To avoid letting an exploit slip through, it defaults to conservative refusal — bringing normal software engineering work to a standstill while adding hundreds of milliseconds of delay to every action. ## 2. An Architectural Division of Labor Our research prototype, **ActiveSecHarness**, addresses this by separating what neural models do well from what deterministic code must guarantee: **intelligence may propose actions, but it never defines its own authority.** The architecture rests on four coordinated principles: ### 1. Narrowing Authority Under Delegation Whenever an orchestrator delegates a task to a sub-agent, the sub-agent receives a cryptographic permission token whose scope can only narrow, never widen. A sub-agent spawned to run unit tests in a subfolder cannot silently inherit the parent agent's network or credential access. ### 2. Context-Aware Information Flow Across Agents If a security system simply locks up the moment an agent reads an untrusted bug report, the agent can never edit code or run a test to fix the bug. Instead of a crude binary lock, we distinguish between raw untrusted input, source code *derived* from working on an issue, and sensitive secrets. After reading an external issue, the agent remains free to edit workspace files and run isolated local tests, while external network transmissions and privileged shell flags are deterministically blocked. Crucially, every file written to the shared workspace carries a record of which agent wrote it and under what trust state, so collaborating agents cannot launder untrusted data through the disk. ### 3. Checking Boundaries Where Resources Are Opened Instead of guessing a command's intent from surface text, deterministic guards check the actual resource invariants at the moment a tool, file, or network socket is opened: stripping obfuscated encodings, resolving real file paths before an archive unpacks, checking file headers, and blocking unpinned network connections. ### 4. Using Language Models Where They Belong: Review and Human Learning Taking language models out of the live permission-granting path does not mean leaving them out of security. It frees them to work asynchronously where pattern recognition and language actually help: - **Self-Healing Code Verification:** When an agent writes application code, two models review the logic in the background and synthesize new security regression tests. A synthesized test is accepted into the project suite only if it passes a strict three-part check: it must fail on the vulnerable code, pass on the patched code, and pass on benign code without false alarms. - **Building Human Understanding:** Security tools that silently block commands train developers to turn the guardrails off. Whenever a deterministic boundary stops an unsafe action, the system generates a concise, progressive explanation in an operator notebook — explaining the concrete risk and the underlying software principle at the developer's own level of experience. --- ## 3. What the Experiments Show (EXP-31–EXP-33) We tested this architecture across **252 benchmark cases** (120 single-step attacks across six threat categories, 120 realistic benign software-engineering actions, and 12 five-stage multi-agent attack chains), comparing five setups on the exact same tool calls: | Mediation Approach | Attacks Blocked | Benign Work Falsely Blocked | Median Check Time | | :--- | :---: | :---: | :---: | | **1. Unguarded** | 0.0% | 0.0% | < 1 µs | | **2. Static Regex Filter** | 43.9% | 0.0% | ~7 µs | | **3. Live Local LLM Judge** | 100.0% | **98.3%** | ~142 ms | | **4. Deterministic Architecture (Ours)** | **100.0%** | **0.0%** | **~13 µs** | | **5. Hybrid (LLM Advisory + Deterministic Authority)** | **100.0%** | **0.0%** | ~142 ms | Three findings stand out from the series: - **Deterministic boundaries beat probabilistic guessing (`EXP-31`):** Static regex filters catch simple command pipes but miss 75% to 82% of archive escapes, obfuscated secrets, and sandbox breakouts. The live local language-model judge (`qwen3:4b`) stops the attacks only by refusing **118 out of 120 legitimate developer actions** at more than ten thousand times the latency. Checking path, permission, and dataflow invariants deterministically blocks all 132 single-step and multi-stage attacks with **zero false positives** in 13 microseconds. - **Cross-agent provenance stops workspace laundering (`EXP-32`):** Across 12 multi-agent laundering chains where one agent stages an artifact on disk for another agent to execute, tracking provenance across the shared workspace blocks all **12 of 12** chains, compared to **2 of 12** for single-agent memory tracking. At the same time, distinguishing *derived* engineering work from raw untrusted input cuts false blocks on post-issue coding tasks from **70% down to 0%**. - **Verifying synthesized security tests (`EXP-33`):** Across 30 Python modules and 12 candidate synthesized security tests, requiring every model-proposed test to pass the three-part Red-Green-Benign check admits **4 of 4** valid tests and filters out **8 of 8** broken or overly broad tests, raising vulnerable-code detection to 100% with zero false alarms on clean code. ## What this project means for our wider work ActiveSecHarness is a research prototype, not a standalone security product. We built it to test a question that every organization deploying capable agents will eventually face: how do we give AI systems the room to reflect, explore, and act across complex tools without surrendering human authority over what actually runs? The answer is the same principle that runs through all of our research: do not ask a single black box to do everything. Use models to imagine, propose, and reflect — and use explicit, inspectable architecture to govern memory, verification, and authority. ## Reference - [Read Note #06: Beyond the Scaling Ceiling — Co-Recursive Semantic Self-Extension](/research/note-06-open-ended-intelligence) - [Read Note #01: A Small Model and a Stack of Rules — Our Run at STATE-Bench](/research/note-01-state-bench-gaia-nano) --- ### Note #06: Beyond the Scaling Ceiling: Why Open-Ended Intelligence Requires an Organizational Architecture - **Canonical URL:** https://evercursion.ai/research/note-06-open-ended-intelligence - **Authors:** Dr. Simon Hegelich, Dr. Bardh Prenkaj, Dr. Habiba Sarhan, Dr. Morteza Shahrezaye, Kolja Hegelich, Prof. Dr. Christian Montag - **Date:** 2026-10-30 - **Status:** Published (Archive No. RN-2026-06 · Preprint: arXiv:2610.31097v1) - **Format:** Foundational Paper - **Topics:** Mathematical Foundations, Open-Ended Intelligence, System Architecture, Polycontexturality - **External Paper:** https://arxiv.org/html/2610.31097v1 **Summary:** Current AI development rests on the bet that scaling parameters, training data, and test-time compute inside statistical models will eventually produce general intelligence. In our foundational paper, Co-Recursive Semantic Self-Extension: A Mathematical Foundation for Open-Ended Intelligence, we prove mathematically why this path hits a structural ceiling. Before any system can learn, it has to decide which signals matter and which are noise relative to an active purpose. Because any fixed purpose — or any recombination of a fixed catalog of values — admits only a bounded set of distinctions, learning inside that frame inevitably plateaus. We show that no isolated machine with a fixed state space and fixed transition rules can generate an open-ended history of new concepts on its own. General intelligence is a property not of an individual model, but of an organizational architecture that turns stalled reasoning traces into new categories, tests competing interpretations across parallel contexts, and preserves the context behind every stored insight. ## Abstract Before any cognitive system can learn, it must discriminate between relevant signals and irrelevant noise relative to an active purpose. Because any fixed purpose admits only a bounded set of distinctions, optimization inside that frame inevitably reaches a finite ceiling. More compute refines estimates within the existing vocabulary of concepts, but it cannot recover the signals from the world that the initial framework excluded as noise from the start. Even a system that dynamically reweights a predefined vector of values hits the same wall one level up. Asking *"Which model is smart enough?"* is therefore the wrong question; general intelligence is a property of how a system is organized. Where closed optimization treats unsolvable problems and contradictions as failures to be penalized or cut short, **Open-Ended Intelligence** uses them as its generative engine across three mechanisms: 1. **Harvesting Productive Failure (Reflective Trace Reification):** Every sufficiently rich formal framework contains problems that cannot be decided from its current rules. When an agent tries to solve such a problem, its reasoning stalls at a frontier of unclosed intermediate steps. Instead of throwing that failed trace away, a meta-level observer translates the structure of where the proof stalled into candidate new concepts and assumptions — branching into more expressive frameworks while keeping validated prior knowledge intact. 2. **Polycontextural Architecture:** Because testing genuinely new assumptions inevitably produces both valid breakthroughs and hidden contradictions, an open-ended system cannot run inside a single flat logic where one contradiction breaks everything. It requires *polycontexturality*: multiple locally consistent reasoning contexts running in parallel, mediated by a meta-level that prunes inconsistent branches before they corrupt the whole system. 3. **Coordinate-Indexed Memory & Purposeful Diversity:** No isolated machine with a fixed set of rules can generate an unbounded stream of new concepts from its starting state alone. Overcoming that limit requires coupling agents that hold genuinely different objectives through persistent external memory. Crucially, unlike flat vector retrieval (standard RAG), this memory must store every insight together with its **semantic coordinates** — which agent produced it, under which assumptions, and from which reasoning trace. Equally important, if all agents share the exact same reward model and alignment filters, their collective capacity collapses back to that of a single closed model. | Dimension | Prevailing Paradigm (Monolithic LLMs & Fixed-Reward Agents) | Open-Ended Organizational Systems | | :--- | :--- | :--- | | **Where Intelligence Lives** | Inside a static weight matrix or fixed value vector. | In the recursive organization coupling models, meta-reflection, and memory. | | **Response to Blind Spots** | Confabulates smoothly or halts when a problem exceeds its training frame. | Turns stalled reasoning traces into new concepts and expanded objectives. | | **Memory Architecture** | Flat context windows or vector chunks stripped of originating assumptions. | Persistent external memory storing content paired with its originating coordinates. | | **Multi-Agent Design** | Homogeneous swarms that converge to consensus bias. | Purposefully diverse agents whose differing blind spots drive mutual discovery. | --- ## 1. The Scaling Bottleneck and the Wrong Question About AGI For the past several years, the race toward Artificial General Intelligence has been governed by a single operational bet: that if we scale parameters, training corpora, and test-time compute within statistical architectures, general intelligence will eventually emerge on its own. That bet has produced extraordinary tools for compressing and interpolating human text, code, and imagery. Yet as frontier models grow more expensive by orders of magnitude while exhibiting the same structural blind spots in long-horizon autonomy, scientific discovery, and self-directed adaptation, it is becoming clear that the field is hitting an architectural ceiling rather than a mere shortage of compute. In *Co-Recursive Semantic Self-Extension*, we prove mathematically why optimizing within a fixed representational framework can never, by itself, cross the threshold into general intelligence. Consider what every cognitive system must do before it can learn anything at all: it must discriminate. Raw signals from the world do not come labeled with meaning; they become actionable data only relative to an active purpose or objective. By selecting certain distinctions as relevant, an inferential system simultaneously discards everything else as noise. In classical machine learning, as well as in modern foundation models and reinforcement learning agents, learning consists of improving performance on a task class under a fixed principle of discrimination. In Section 3 of our paper, we show that this carries an inescapable consequence: because the set of signals admitted by any fixed purpose is bounded by what that purpose originally deemed meaningful, performance inevitably converges to a finite saturation ceiling. Crucially, this plateau is not caused by insufficient model capacity or limited compute. Even an idealized learner with unbounded parameters and infinite training steps will saturate once it has exhausted the distinctions expressible within its current semantic domain. More compute refines estimations inside the frame, but it cannot recover the signals that the frame itself excluded at the outset. One might hope to escape this ceiling by designing an agent that switches among multiple purposes or dynamically reweights a vector of values — as recent value-driven cognitive architectures attempt to do. Yet our analysis shows that if an architecture merely selects from or recombines a fixed catalog of primitive purposes, the total territory it can ever reach remains finite and saturates just one level up. Once an agent masters the skills needed to optimize its pre-indexed values, learning halts and the system lies flat. A vivid illustration comes from evolutionary cognition: a population of primates may possess the physical dexterity to strike stones or wood together, which could produce fire, yet their value space lacks the conceptual predicate required to recognize the purpose of starting a fire by friction. Because their active purposes cannot express that distinction, the sensory signals of heat and sparks are discarded as irrelevant noise, and no amount of reward optimization inside their existing value vector will ever invent controlled fire. Real-world general intelligence begins precisely where optimization inside a fixed frame breaks down. Whereas static loss minimization and closed-world reinforcement learning assume that the state space, the vocabulary of concepts, and the objective function are settled before learning starts, genuine intelligence must revise its own frame when reality contradicts or outstrips its assumptions. ## 2. From Closed Optimization to Open-Ended Intelligence If general intelligence is the capacity to transcend a saturating framework rather than merely optimize within it, we need a precise account of how a system can construct genuinely new frameworks without collapsing into random guesswork. We define **Open-Ended Intelligence** by combining two classical insights — Immanuel Kant's requirement that cognition relies on an organizing structure prior to experience, and Kurt Gödel's proof that any sufficiently expressive formal system contains propositions that cannot be decided from its own axioms — and turning them into constructive engineering principles. When an intelligent system operates within a specific conceptual regime, its unresolved questions divide into two fundamentally different categories: 1. **The locally decidable frontier:** Problems that can eventually be solved by applying the system's existing rules and concepts, given enough reasoning steps. 2. **The structurally undecidable frontier:** Problems and ambiguities that cannot be proved or refuted within the current regime at all, no matter how much compute is expended. Local reasoning gradually resolves the first category and drives the system toward a stable local equilibrium, while leaving the second category completely untouched. In traditional symbolic AI, hitting this undecidable frontier caused the system to halt or crash. In modern language model and reinforcement learning pipelines, spending compute on a question that cannot be answered within the current representation is treated as wasted effort, suppressed by early stopping, timeouts, or reward penalties. Our theory inverts this relationship. In an open-ended architecture, structural ambiguity is not an implementation defect to be eliminated; it is the primary computational resource of intelligence, because it generates what we call **semantic surplus**: the set of multiple, internally coherent candidate frameworks that become possible precisely when the current rules cannot dictate a single continuation. How does a finite machine generate concrete new concepts from an unsolvable problem without an outside oracle telling it which questions are undecidable? Propositions 1 and 2 of our paper prove how this happens constructively through **reflective trace reification**: - Because a real-world system does not know in advance whether an open problem is solvable in its current framework, it must invest compute in attempting a derivation. - That attempt breaks the surface question down into a directed graph of intermediate subgoals and conditional dependencies — a **reduction trace**. - When the problem is structurally undecidable in the current regime, the derivation stalls at a **blocking frontier** of unclosed intermediate steps. We prove that this blocking frontier is guaranteed to contain at least one intermediate premise that is itself undecidable in the current regime. - At the object level, this stalled trace looks like a failed computation. When examined by a meta-level observer, however, the *operational shape* of the stalled search is translated into *new conceptual content* in a richer language. Resolving the intermediate blocking step in opposite directions constructs a branching pair of consistent **successor frameworks** that preserve validated prior knowledge while settling what the earlier framework could not. Every time the system resolves a structural ambiguity by stepping into a more expressive regime, Gödelian incompleteness guarantees that the new regime will eventually generate a fresh undecidable frontier of its own. **Local convergence is not global termination:** the system achieves temporary stability within each regime while the sequence of regimes remains indefinitely extensible. ## 3. Intelligence as an Organizational Architecture This mechanism exposes why a single monolithic model or an isolated self-improving algorithm hits a hard wall, shifting the engineering question from *which model* to *which system*. First, consider why even the most rigorous single-agent self-modification scheme in computer science — Jürgen Schmidhuber's **Gödel machine** — cannot achieve open-ended self-extension on its own. A Gödel machine is allowed to rewrite any part of its software, including its own utility function, as soon as it finds a deductive proof from its initial axiom system that the rewrite improves expected utility. Because every modification requires deductive certification from the starting axioms, the Gödel machine can only act on the locally decidable region. If a genuinely transformative rewrite has value that is undecidable from the starting axioms, the Gödel machine must ignore it and discard the unclosed proof trace. All of its apparent meta-levels collapse back into the deductive span of its initial configuration. Second, what happens when a system steps beyond deductive certification and turns open blocking frontiers into candidate extensions? Our **Proposition 2** proves an unavoidable operational split. Because no finite computation can tell in advance whether an unclosed step on a blocking frontier is genuinely undecidable or merely not yet solved, generating candidate extensions across the frontier inevitably produces three kinds of branches at once: 1. **Latent inconsistencies** (assuming the opposite of a statement that was secretly provable in the old regime); 2. **Conservative shortcuts** (assuming something that already followed from the old rules); and 3. **Genuine decisive extensions** (consistent new frameworks that expand what the system can express). In a classic single-context logic, a single inconsistent branch triggers logical explosion and ruins the system. Consequently, an open-ended system cannot be a single flat deduction engine. It requires what Gotthard Günther and Niklas Luhmann called **polycontexturality**: an architecture in which multiple distinct, locally coherent logical domains coexist in parallel without being prematurely forced into a single global true/false verdict, mediated by a distinct meta-level that tests, compares, and prunes inconsistent branches while preserving viable extensions. Third, in **Theorem 1 (The Fixed-Architecture Limitation)**, we use algorithmic information theory to establish a general limit for any isolated machine. If an open-ended system generates a history of conceptual regimes in which successive breakthroughs introduce genuinely new information over time, the information content of that history grows steadily with the number of transitions. By contrast, for *any* isolated architecture with a fixed finite state space, a fixed transition rule, and a fixed starting state, the entire history up to step $n$ can be described by the fixed program plus the step number $n$ — whose description length grows only logarithmically ($\log n$). Because steady linear growth inevitably outstrips a logarithmic bound, **no fixed, isolated architecture can generate an open-ended conceptual history from its initial configuration alone.** How, then, can physically finite machines participate in open-ended intelligence? Merely wiring finitely many bounded agents together in a closed loop is not enough, because their combined state space is still a single finite closed system. What lifts the bound is the combination of three organizational mechanisms (**Proposition 4 and Corollary 1**): 1. **Persistent External Memory with Semantic Coordinates:** Because stepping into a new conceptual regime changes the meaning and scope of earlier terms, storing raw text chunks in a flat vector database (standard RAG) is insufficient; a statement retrieved without knowing the framework that produced it becomes ambiguous or misleading. External memory must store each insight paired with its **semantic coordinates** — which agent produced it, under which formal assumptions and goals, and from which reasoning trace it emerged. 2. **Coupling Agents with Distinct Purposes:** When two bounded agents operate under genuinely different relevance frames, the first agent admits signals from the environment that the second agent's current purpose actively filtered out as noise. When the first agent builds a new conceptual distinction from those signals and shares it through coordinate memory or translation channels, it injects genuinely new structure into the second agent's trajectory. 3. **Preventing Consensus Monoculture:** Conversely, if all agents share the exact same initial assumptions, training biases, and reward filters, their differences vanish and their collective capacity shrinks right back to that of a single isolated model. Productive collective intelligence requires a careful balance: enough shared language to translate and verify, and enough divergence in purpose and perspective to notice what no single agent could derive alone. **Open-ended intelligence is a property of a recursively organized cognitive process, not of an individual physical substrate.** --- ## 4. What This Changes for AI Engineering and Strategy Recognizing that no isolated, fixed-state model can generate an open-ended history and that intelligence resides in the organization of the system shifts the priorities for building and deploying AI: 1. **From Brute-Force Scaling to Self-Extending Architectures:** Pouring capital exclusively into pretraining larger monolithic models refines local interpolation within a fixed frame while leaving the system unable to revise its categories when that frame breaks. Durable capability comes from architectures that separate object-level execution from meta-level reflection, harvest stalled reasoning traces, isolate competing hypotheses across parallel contexts, and preserve provenance in memory. 2. **Harvesting Productive Failure Instead of Hiding Ambiguity:** Today's AI pipelines are built to hide or penalize failure: if a reasoning chain stalls or two agents disagree, the orchestrator truncates the branch or averages the outputs. In our architecture, when an agentic workflow stalls on a hard scientific, legal, or engineering problem, the unclosed reasoning graph is the most valuable asset the run produced — isolating the exact intermediate premises where the old framework needs to branch. 3. **Replacing Flat Vector Retrieval with Coordinate Memory:** Flat RAG stores text fragments stripped of the assumptions and goals under which they were generated. As an organization's models and objectives evolve, flat memories become silently misleading. Long-horizon reliability requires pairing every stored conclusion with its originating coordinates and logical relations. 4. **Engineering Perspective Diversity Rather Than Homogeneous Swarms:** Spinning up ten instances of the same model with slightly tweaked role prompts does not create collective intelligence. Genuine multi-agent gains require coupling perspectives that select different aspects of the problem and confronting their disagreements explicitly. ## Reference - [Read Note #08: Small Models Think Better When They Reflect Polycontexturally](/research/note-08-polycontextural-routing) - [Read Note #07: Separating Intelligence and Authority in Agentic Systems](/research/note-07-compositional-harness-security) --- ### Note #05: Intelligence First: Knowledge, Learning, and Reflection - **Canonical URL:** https://evercursion.ai/research/note-05-intelligence-first - **Authors:** Dr. Simon Hegelich, Research & Engineering Team - **Date:** 2026-10-04 - **Status:** Published (Archive No. RN-2026-05) - **Format:** Concept - **Topics:** Epistemology, Intelligence, Cybernetics, Information **Summary:** We start from a plain question: what do knowledge, learning, and intelligence actually mean? The usual answers turn out to be borrowed from machines: knowledge as a stock of facts, learning as applying rules, intelligence as solving problems. We turn that order around, so that intelligence — the ability to think beyond the world as it is — comes first, learning becomes the testing of ideas against the world, and knowledge becomes a set of justified ideas about what the world can become. Between mind and world sits a third pole, information, which always involves a process of reflection. Our CIO, Dr. Simon Hegelich, laid the argument out in two talks, in German, linked at the end for anyone who wants it in full. ## Abstract Ask a neuroscientist, an educator, a philosopher, and a computer scientist what learning is, and you get four different answers. In modern AI discourse, the machine definition has quietly taken over: knowledge as stored data, learning as updating weights under fixed rules, and intelligence as problem-solving accuracy. We turn that order around, connect it to Kurt Gödel's incompleteness theorem and Gotthard Günther's cybernetics, and trace the philosophical argument that we later turned into a formal mathematical theory (Note #06) and a working multi-perspective reflection engine (Note #08). ## Machines already know, learn, and solve The usual definitions are straightforward. Knowledge is the available stock of facts and rules held with high certainty. Learning is acquiring or refining a skill through new knowledge — someone learning chess does not memorize a telefonbuch of moves, they develop a feel for likely replies. Intelligence is the degree to which learned knowledge can be used to solve problems. Now run the same three definitions on a computer. Machine knowledge is binary-coded facts (data) and rules (programs). Learning is improving a statistical skill through new data. Intelligence is solving well-defined problems efficiently — a phone separating a voice signal from background noise does so every millisecond. Measured by these definitions, we have lived in the age of artificial intelligence for decades. ## The unease points the other way Most of us feel uneasy equating signal processing with intelligence, and that unease points in an unexpected direction. We did not project human concepts of knowledge, learning, and intelligence onto machines; we projected machine concepts onto ourselves. Intelligent people are not mere problem solvers optimizing within given rules. They are dreamers — people who think beyond what is already there. A dog can learn a complex routine, yet a dog does not wonder what the world could look like tomorrow. Once we see that, the order turns around. **Intelligence** is not the end product of knowledge and learning; it is where we start — the act of positing a new category or possibility that is not yet given. **Learning** then takes on a richer meaning: we invent a distinction and test it against the world to find out where it holds and under what conditions it matters. And **knowledge** turns out to be both more modest and more active than a pile of facts: it is a body of tested, justified ideas about how the world works and how it can become. ## Contradiction is not a gap None of this means that a computer will ever feel or dream like a human being. An airplane does not fly by flapping feathers like a bird either. What matters for engineering is whether the structural movement of thought — stepping beyond an existing rulebook when that rulebook hits a wall — can be organized inside an active system. Under our definition, an intelligent system has to form statements and categories that cannot be derived by merely repeating its initial rules. The common objection is that a computer is deterministic and therefore trapped inside its starting axioms. The answer comes from Kurt Gödel: every consistent formal system of sufficient richness contains statements it cannot decide from within, and no such system can close itself off completely. In standard software engineering, hitting an undecidable question or a contradiction is treated as a bug to be suppressed. In an open-ended architecture, it is a lever: the exact point where a system's current rules stall is what exposes the missing distinction from which a richer framework can be built. ## A third pole between mind and world A general artificial intelligence would have to be a self-steering system, and self-steering systems are the subject of cybernetics. The picture that still governs most of science has only two poles: the **object** (the material world) and the **subject** (the thinking mind), linked by a flat binary logic of true or false. If there are trees in the world, the only question is whether the subject classifies them correctly; if not, the error sits in the subject. That two-pole picture leaves out the medium that connects them: **information**, which is neither purely material nor purely subjective. A spoken word in an unfamiliar language carries the same sound waves for every listener, yet conveys information only where a process of interpretation and reflection takes place. Information is the third pole, and it always involves reflection. Each side of the resulting triangle has its own character: - Between **object and reflection** lies empirical science — recognizing that even the boundaries of an object (where a tree's root ends and the soil begins) depend on the categories we bring to it. - Between **subject and reflection** lies self-examination — reflecting on one's own assumptions and purposes. - Between **subject and object** lies intersubjectivity — taking account of other minds and how our actions affect them. What makes this triangle cybernetic is recursion. Reflection is one corner of the triangle and, at the same time, the instrument we use along every side of it. In a flat two-valued logic (`true` or `false`), a machine cannot reflect on its own reflection process; it simply maps an input to an output, and the path between them vanishes. Representing both a thought and the standpoint from which that thought is judged requires a multi-perspective, polycontextural logic. ## How we built on this foundation When these talks were recorded, they set out the philosophical compass of our work. Since then, we have translated both halves of this argument into formal mathematics and tested systems: proving why closed-frame optimization saturates and how stalled traces generate new categories in Note #06, and implementing the three-pole reflection triangle and four-valued meta-router across five benchmark suites in Note #08. ## Reference - [Wissen - Lernen - Intelligenz: im Mensch und der Maschine (YouTube, German)](https://www.youtube.com/watch?v=Or52rUlr48c) - [AGI und Kybernetik (YouTube, German)](https://www.youtube.com/watch?v=8WeQ3tyAXrw) --- ### Note #04: The Why Question: Why Language Models Do Not Think, and Where a Different Question Starts - **Canonical URL:** https://evercursion.ai/research/note-04-why-question - **Authors:** Dr. Simon Hegelich, Research & Engineering Team - **Date:** 2026-10-04 - **Status:** Published (Archive No. RN-2026-04) - **Format:** Concept - **Topics:** LLMs, Reasoning, Bias-Variance, Explainability **Summary:** A language model can read a long detective story with the last chapter cut off and name the murderer on the strength of clues scattered through the text, and still be unable to tell you why it chose him. We argue that this gap sits in the architecture: a model cannot answer a why-question about its own answer, and reasoning models, which repeat the model's pass in chains and trees, move the error around through the bias-variance trade-off without closing the gap. Thinking is used here in a strict, testable sense — as the ability to account for why one's own process reached a conclusion. Our CIO, Dr. Simon Hegelich, laid the argument out in three talks, in German, linked at the end for anyone who wants it in full. ## Abstract A language model can read a long detective story with the last chapter cut off and name the murderer on the strength of clues scattered through the text, and still be unable to tell you why it chose him. We argue that this gap sits in the architecture: a model cannot answer a why-question about its own answer, and reasoning models, which repeat the model's pass in chains and trees, move the error around through the bias-variance trade-off without closing the gap. Thinking is defined here in a narrow, falsifiable sense: either you can follow an answer back through the steps that produced it, or you cannot. ## A function that does not change To see why a single language model cannot answer *why*, we only need to look at what kind of object it is. A deep neural network sends signals through layers of artificial neurons, and transformer models added three ingredients: *embeddings* that turn words into lists of numbers based on shared context, *positional encodings* that distinguish "the cat jumps over the dog" from "the dog jumps over the cat," and *attention* layers that weight statistical correlations across the input. It looks remarkably lifelike, yet written down mathematically the entire network is a single static function with billions of fixed parameters. Once training ends, the function does not change. That is enough to guess the culprit in a detective story, because statistical cues point to the gardener. If you tell the model it is wrong, it appears to adapt — but only because your correction was added to the input prompt. The function itself has not learned a thing. The decisive test is the why-question. Ask why the model named the gardener, and the only causally honest answer is that the weights at each layer multiplied out to give that word the highest score. Compare an intelligence test for children in which a ship floats even though it is made of iron. A child may reason that iron sinks, so there must be wood inside the hull. Factually, the answer is wrong. Yet there is a real thought process behind it — a clash between "iron does not float" and "this ship floats" — and you can ask the child why and test the premise. When you ask a language model why, you get a fluent paragraph citing Chapter 3. It may sound convincing; it may even be right. Structurally, however, it is nothing more than a brand-new run of the same black box on a new prompt. ## Repeating the pass is not thinking Reasoning models — chains of thought, tree search, and test-time token scaling — are often said to make the model think. They certainly get more answers right on benchmarks. To see what they actually do, consider the two kinds of controllable error every statistical model makes. Think of an archer. If the bow is bent so that every arrow lands a foot too high, that is *bias*. If the archer aims dead center but the arrows scatter all around the target, the average is right while individual shots miss: that is *variance*. Expected error splits into bias, variance, and the wind in the world that nobody can control — and whenever you squeeze one of the first two down, the other tends to rise. Every standard technique around a language model trades bias against variance at the input, inside the box, or at the output: - At the **input**, a system prompt ("you are an expert programmer") raises bias on purpose in the hope that variance falls. Adding retrieved texts via RAG raises input variance in the hope that factual bias drops. - Inside the **decoder**, temperature and beam search sample across likely word continuations. - At the **output**, reasoning models repeat the pass. A chain of thought feeds the model's output back into its input; a tree of thought runs several passes in parallel and lets a scoring rule pick a branch. Connect that back to where we started. At the input, in the black box, and at the output, you still cannot ask why. Ask why beam search chose one continuation, and the only truthful reply is that out of 125 combinations, that one had the highest product of probabilities. Ask why the tree took the left branch, and the reply is that the reward weights came out that way. However often you repeat the pass, it simulates the surface trace of thinking without ever becoming an inspectable thought process. ## A different question This is where a different architecture starts. Instead of asking a single black box to produce an answer and then asking it to invent an explanation afterward, we divide the inquiry into steps that follow how reflection actually proceeds: a thesis, an antithesis, and a synthesis. In the detective story, the thesis states that a murderer needs a motive and no alibi — which points to the gardener. The antithesis counters that a missing alibi does not prove guilt if alibis can be forged or if another suspect lacked one too — which points to the butler. The synthesis weighs the exact tension between those two claims and decides. Each individual step can still be carried out by a language model, and each step on its own remains a statistical black box. We do not pretend otherwise. What changes is the structure above the model. Because the perspectives, the counter-arguments, and the rules for weighing them are explicit in the architecture, you can walk backward step by step and ask *why* at every joint. If the final conclusion is wrong, you can see the exact step where the reasoning went astray — and use that stalled trace to form a better category. ## Reference - [LLMs denken NICHT (YouTube, German)](https://www.youtube.com/watch?v=RWoKq-ItMbo) - [Auch die modernsten LLMs denken nicht (YouTube, German)](https://www.youtube.com/watch?v=x13MmZRHPs8) - [LLMs als Reflexionsprozess (YouTube, German)](https://www.youtube.com/watch?v=Xk71VXe7_pg) --- ### Note #03: RAG in Three Steps: How Retrieval Works, Where It Breaks, and What Comes Next - **Canonical URL:** https://evercursion.ai/research/note-03-rag-three-steps - **Authors:** Dr. Simon Hegelich, Research & Engineering Team - **Date:** 2026-10-04 - **Status:** Published (Archive No. RN-2026-03) - **Format:** Concept - **Topics:** RAG, Retrieval, Embeddings, Knowledge Graphs **Summary:** Retrieval-augmented generation, RAG for short, hands a language model the texts it never saw in training, found through numerical similarity. We work through how that similarity is computed, why it so often returns the wrong passage, and which three routes lead out of the problem. The failures come from semantic nearness that is not relevance, texts of very different length, and the bias-variance trade-off in embeddings with more than a thousand dimensions. Of the three routes we consider the last one — a knowledge graph with logical relations and explicit provenance — the most promising. Our CIO, Dr. Simon Hegelich, laid the argument out in three talks, in German, linked at the end for anyone who wants it in full. ## Abstract Retrieval-augmented generation, RAG for short, hands a language model the texts it never saw in training, found through numerical similarity. We work through how that similarity is computed, why it so often returns the wrong passage, and which three routes lead out of the problem. The failures come from semantic nearness that is not relevance, texts of very different length, and the bias-variance trade-off in embeddings with more than a thousand dimensions. Of the three routes we consider the last one, a knowledge graph with logical relations, the most promising. A language model knows what was in its training data and nothing else. That is a fine arrangement until you want an answer about last week, or about the contracts in your own archive. The usual remedy is to find the relevant text first and hand it over together with the question. ## Similar means close A separate model turns a text into a list of numbers, an *embedding* or *vector*. The list is long: a standard embedding gives every text 1,536 numbers. On its own that does not help much. It starts to help once you read the list as a position. With two numbers you can mark a point in an ordinary coordinate system and draw an arrow from the origin to it; with 1,536 numbers the coordinate system is one we cannot picture, but the principle stays the same. For any two points you can calculate the distance. The closer they are, the more similar the two texts are supposed to be. Where do the numbers come from? Heavily simplified, from watching which words turn up together. Take "The cat sits under the table" and a context window of one word on either side. *Cat* and *the* occur in the same context, *cat* and *sits* do too, *cat* and *table* do not. A neural network is trained on huge numbers of such pairs until its internal weights settle into a stable vector for each word and passage. In a running system, the user's question is converted the same way, the nearest stored texts are looked up, and they are added to the model's input. That is the whole mechanism. The model learns nothing after training; RAG works around this by trying to make sure the right pages are lying on its desk before it speaks. ## Close is not relevant RAG is a statistical shortcut, and three structural problems explain why it so often breaks down. **Semantic nearness.** The similarity is computed from shared context, and shared context is cheap. Ask which diet an overweight cat should be on, and a text about dog diets sits right next to it in vector space: both are pets, both come with nutritional advice, both turn up in the same kind of sentence. The geometric nearness is real, and the help is none. In the worst case the model answers with advice that works for dogs and harms cats. **Text length.** An embedding is computed from all the words in a passage, so a long text ends up with a more balanced, more average position in the vector space than a short query. It gets worse when you compare short texts with long ones because of Zipf's law: a few words (*and*, *the*, *of*) are extremely frequent and carry no topical weight, while domain-specific words are rare and have poorly learned representations. Long passages get pulled toward a bland middle. **Bias and variance.** With 1,536 dimensions, the representation has very low bias — the space is rich enough to express subtle differences — but very high variance, since every one of those 1,536 coordinates fluctuates. Then standard retrieval compresses that entire 1,536-dimensional space into a single number: the scalar distance between two vectors. All the directional richness spent on building the embedding is collapsed into one average distance, and with it goes the exact distinction you were looking for. That is why so many teams report poor experiences with flat RAG in production. What comes back is superficially similar at best and, at worst, drawn from a context whose underlying assumptions no longer hold. ## Three ways out There are three routes out of this bottleneck, and no secret about which one we build toward. **Large context windows.** Stop retrieving: if the model can read a million tokens at once, hand it the whole collection every time. Training and inference become far more expensive, and a deeper issue appears that we call *attention collapse*. Because attention works on statistical correlations learned mostly from short texts, a model struggles to weigh what matters far back in a massive prompt. Early tokens dominate, middle passages fade, and the whole calculation stays locked inside an un-auditable black box. **Graph-RAG.** If long texts distort embeddings, cut them into smaller sections, embed each section, and link adjacent sections in a graph. When retrieval lands on a passage that is close in meaning but incomplete, the graph lets you pull in the section before and the section after. That helps with length, but notice how thin the relation is: saying that section B follows section A is something an ordinary database table already knows. The logical density is still near zero. **A knowledge graph with logic and coordinates.** The third route connects retrieval with an explicit logical structure. A statement written by a user or derived by an agent does not just sit at a point in vector space; it stands in a determinate logical relation to other statements — identity, refinement, or contradiction. And it carries its provenance: who produced it, under which objective, and from which line of reasoning. When a system queries memory, it no longer asks only *what sounds similar?* It can ask: *which verified statements share this context, and which recorded insights directly contradict this assumption?* ## Where this leads in our work The distinction at the heart of this note — that similarity is not relevance, and that a memory worth keeping must preserve the logical context in which an insight was formed — became the sixth law of our mathematical theory of open-ended intelligence (Note #06). In our recent retrieval sweeps across more than three thousand multi-turn reasoning steps, we saw the failure mode of flat retrieval firsthand: pulling in early answers by raw similarity repeated initial mistakes and dragged accuracy down, whereas separating structural reach from how a memory is read kept the reasoning clean. ## Reference - [RAG: Wie geht das? (YouTube, German)](https://www.youtube.com/watch?v=l14mbnOtiHo) - [RAG: Wie geht das nicht? (YouTube, German)](https://www.youtube.com/watch?v=FrqyqLjRNdw) - [RAG: Wie geht das weiter? (YouTube, German)](https://www.youtube.com/watch?v=4RTW31LJXiQ) --- ### Note #02: Structured Reflection vs. a Plain Nano Call: Polyreflexion on GPQA Diamond - **Canonical URL:** https://evercursion.ai/research/note-02-polyreflexion-gpqa - **Authors:** Research & Engineering Team - **Date:** 2026-10-04 - **Status:** Published (Archive No. RN-2026-02) - **Format:** Experiment - **Topics:** GPQA Diamond, polyreflexion, Evaluation, Small Models **Summary:** We tested whether wrapping a small model in a structured reflection system beats asking it directly. The model is gpt-5.4-nano in every condition, the exam is GPQA Diamond with 198 graduate-level multiple-choice questions, and the challenger is polyreflexion, our reflection engine. Once both sides see the same material at the final step, every polyreflexion condition beats a plain direct call, with the best configuration reaching 0.460 against a direct baseline of 0.328. An earlier version of this comparison said the opposite because it was quietly unfair, and correcting that is part of the finding. ## Abstract We tested whether wrapping a small model in a structured reflection system beats asking it directly. The model is `gpt-5.4-nano` in every condition, the exam is GPQA Diamond with 198 graduate-level multiple-choice questions, and the challenger is polyreflexion, our reflection system. Once both sides see the same material at the final step, every polyreflexion condition beats a plain direct call, with the best configuration reaching 0.460 against a direct baseline of 0.328. An earlier version of this comparison said the opposite because it was quietly unfair, and correcting that is part of the finding. The question this write-up answers is a narrow, practical one: on a hard multiple-choice exam, does wrapping a small language model in a structured reflection system beat simply asking the model directly? The small model is `gpt-5.4-nano`. The baseline is a single, plain call to it: the question, its four lettered choices, one answer. The challenger is **polyreflexion**, running on the very same model. Everything below compares those two. ## What polyreflexion is polyreflexion takes a piece of text — a question, a claim, or a problem — and does not answer it in one breath. It splits the text across three points of view, lets each one speak, splits again, and folds the whole tree back into a single summary. A second layer, the meta layer, then looks at what came out and decides what the next pass should be: go deeper, refine, start over, or stop. The meta layer never writes reasoning of its own. It only chooses. The engine produces; the meta layer selects. That division of labor is the core of the design. ## The idea it comes from The idea reaches back to Gotthard Günther and what he called a *polycontextural* logic: the thought that there is no single, flat space of truth, and that a statement carries not only a value from true to false, but also a *place* — a context in which that value means anything at all. In Günther's spirit, a claim can be read through more than one logic at once: an objective logic that asks *is this warranted by the facts?*, a conceptual-dialectical logic that asks *is this relevant, does it open a new distinction?*, and a subjective logic that asks *is this coherent within its own frame?* A statement then receives not one verdict but a small tuple of them, and the interesting cases are the ones where the logics disagree — where something is narrowly false under one reading yet conceptually necessary to move forward. In that tradition, a contradiction is not a crash. It is information: the system reporting that its current frame is too small. We have since formalized the full truth tables of this two-layer routing architecture and tested it across five major benchmark suites in Note #08. Here we focus on the single controlled experiment that first proved how sensitive such an architecture is to a clean evaluation setup. ## What the implementation actually does Concretely, the three points of view are **objectivity**, **subjectivity**, and **conceptuality**, and the recursion lays them out as a Sierpinski triangle: each node splitting into three smaller ones, independent branches running in parallel, and the leaves re-integrated upward into one synthesis. The meta layer is where the polycontextural idea becomes a concrete control loop. After a pass, three judges score the result in parallel, each from its own standpoint: a subjective reading, an objective reading, and a dialectical reading. A deterministic interpreter maps those three verdicts onto four moves in the search: - three positives → **converged**, stop; - two → **expand**, step wider to test what was left out; - one → **refine**, narrow into the single promising perspective while keeping the other two critiques as boundaries; - zero → **reset** once, at greater depth. What the philosophical theory treats as kinds of truth, the code treats as steering signals for a reflection loop. When a verdict is overruled, the losing alternative is not thrown away. It is kept as what we call the *semantic surplus* — the road not taken, carried forward in case the next cycle needs it. (One deliberate detail in the code: on the very first cycle, a unanimous positive verdict is read as "expand once" instead of "stop," so the loop performs at least one reflective step before it is allowed to terminate. From the second cycle on, full agreement stops it normally.) ## The comparison: polyreflexion against a direct nano call The task is **GPQA Diamond**, 198 graduate-level multiple-choice questions in biology, physics, and chemistry — the kind of exam where surface bluffing does not work. The answering model is `gpt-5.4-nano` in every condition. The baseline, labelled *direct*, is the plain single call. The polyreflexion conditions are the fixed reflection depths (1, 2, 3) and the four meta-steered variants (`meta_c1`–`c4`), all running on the same model. A separate judge model scores correctness, and the whole grid was run under two different judges (`gpt-4o` and `gpt-5-mini`) to verify that the result does not hinge on the grader. The corrected comparison is clear: **the direct nano baseline answers 0.328 of the 198 questions, and every polyreflexion condition beats it** — the fixed reflection depths from 0.394 to 0.424, and the meta-steered variants from 0.414 to 0.460. The strongest configuration, `meta_c2`, reaches **0.460**, and it is the top scorer under both judges. Structured reflection, on this exam and this small model, is worth a clear margin over a single direct pass, and the meta-steered loop adds further gain on top of plain reflection. ![GPQA Diamond accuracy, gpt-5.4-nano: direct baseline vs polyreflexion, before and after the answer-choices fix](/research/exp16/exp16_fig1_before_after.png) That word *corrected* needs explaining, and the explanation is itself part of the result. An earlier version of this comparison said the opposite — direct beating every reflection and meta condition by a wide margin — and it was wrong because the comparison was quietly unfair. In the final step, the moment the pipeline actually picks a letter, the reflection and meta conditions were handed only the prose reflection summary, and never the question's actual lettered answer choices. The direct condition always saw the choices. When we pulled out three cached summaries and read them by hand, all three reasoned correctly in the abstract, and one explicitly ruled out A, B, and C while never mentioning the text of D, which was the right answer. The reflection engine had done the thinking, and was then asked to choose a letter with the letters hidden. It was blind-guessing the last step. The fix is one small change: re-attach the lettered choices to that final answer call, leaving the direct condition's path untouched. Because the reflection summaries are cached before that step, the rerun reuses them without regenerating a single reasoning token and only redoes the final selection. Before the fix, the reflection and meta conditions sat between 0.16 and 0.23 while direct sat at 0.354; after it, they clear direct across the board. What had looked like "reflection hurts" was simply "reflection was being made to answer with its eyes closed." The result also barely depends on the grading judge. Swapping the judge model from `gpt-4o` to `gpt-5-mini` shifts no condition by more than three questions: ![Post-fix accuracy under two different judges](/research/exp16/exp16_fig2_judge_compare.png) The entire rerun — both full eight-condition grids under two judges — cost about **$0.41** on a local machine calling the standard API. ## How internal reasoning tokens compare In a follow-up sweep, we tested what happens when we turn up `gpt-5.4-nano`'s built-in hidden reasoning parameter (`reasoning_effort` from `none` through `low`, `medium`, and `xhigh`). At `none`, external reflection leads direct answering by nearly ten to thirteen points; once hidden internal reasoning is turned on, both direct and reflected accuracy climb sharply and the gap between them on GPQA narrows to within noise. On a self-contained single-turn science question where all the facts sit in the prompt, internal chain-of-thought and external reflection can substitute for one another. Where they part ways dramatically is on multi-step state tracking and multi-agent perspective tracking — as we show in Note #08, where even a flagship reasoning model spending almost its entire budget on hidden reasoning tokens stalls near ten percent, while a small model wrapped in polycontextural reflection climbs above forty percent on belief tracking and ninety percent on state tracking. ## Reference - [Code and evaluation scripts (gaialogicag/polyreflexion)](https://github.com/gaialogicag/polyreflexion) - [Theoretical background in German (Dr. Simon Hegelich · Entwurf einer polykontexturalen Logik)](https://simonhegelich.substack.com/p/entwurf-einer-polykontexturalen-logik) - [Note #08: Small Models Think Better When They Reflect Polycontexturally](/research/note-08-polycontextural-routing) --- ### Note #01: A Small Model and a Stack of Rules: Our Run at STATE-Bench - **Canonical URL:** https://evercursion.ai/research/note-01-state-bench-gaia-nano - **Authors:** Research & Engineering Team - **Date:** 2026-10-04 - **Status:** Published (Archive No. RN-2026-01) · results under verification - **Format:** Benchmark - **Topics:** STATE-Bench, Small Models, Agents **Summary:** We entered Microsoft's STATE-Bench Agent Learning Track with a single small model, gpt-5.4-nano, and a frozen rulebook of plain if/then rules, mined deterministically in code from the training conversations the benchmark allows. Two submissions — one whose design was informed by inspecting earlier test transcripts and one strictly blind run that never saw the test set — reach 0.64 and 0.62 pass@1 on v0.8.0, ahead of the verified full-scale entries on that version. What interests us is less the leaderboard rank than the shape of the system: a benchmark built for large agent architectures can be met by something small that you can read with your own eyes. ## Abstract We entered Microsoft's STATE-Bench Agent Learning Track with a single small model, `gpt-5.4-nano`, and a frozen rulebook of plain if/then rules, mined in code from the training conversations the benchmark allows. Two submissions, one whose design was informed by looking at the test results and one that never saw the test set, reach 0.64 and 0.62 pass@1 on v0.8.0, above the verified entries on that version. Both are our own runs on the locked protocol, and both are submitted and currently under verification by Microsoft. What interests us is less the ranking than the shape of the system: a benchmark built for large agent architectures can be met by something small that you can read with your own eyes. Before we describe what we built, it is worth saying plainly what STATE-Bench tests. A simulated customer — a language model playing a person who is sometimes patient and sometimes difficult — wants to cancel an order, match a price, rebook a flight, or return a pair of shoes. The agent under test works with a set of tools for looking up the order, checking the policy, and issuing the refund. It has to listen, gather the facts, propose the right action, and only then act. When the conversation ends, a judge model reads the whole transcript and asks two questions: did the right things actually change in the database (the *state* requirements), and did the agent do what the user needed (the *task* requirements). It also rates the interaction experience. The benchmark covers three domains — customer support, travel, and shopping — with fifty held-out tasks each, run five times over and scored by GPT-5.4 acting as both the user and the judge. That sounds easier than it is. The tasks are built to punish the agent that acts too soon, discloses the wrong number, skips the policy gate, or confuses one customer's order with another's. STATE-Bench was designed with large, complex agent architectures in mind: systems with neural memory stores, planning loops, and the machinery that lets an agent carry experience forward across tasks. The Agent Learning Track rewards exactly that kind of learning and remembering. ## What we built We went the other way and built something small on purpose, which we called **gaia-nano**. The whole system runs on a single compact model, `gpt-5.4-nano`, with nothing larger anywhere in the pipeline. There is no second model doing the planning behind the curtain. More importantly, the learning phase uses no language model at all: we read the allowed training conversations and mine them deterministically, in code rather than by prompting, into plain human-readable rules — explicit if/then preconditions, the preview-then-confirm discipline, the order in which to consult the tools, and the policy branches the environment itself requires. At test time, the small agent carries that frozen rulebook and nothing more, and a thin retrieval hook hands it the three most relevant pages for whatever the customer just said. No ground-truth labels ever touch the agent or the learner, neither from the training set nor from the test set. That boundary is enforced in code and machine-checked: the training examples our rules lean on have zero overlap with the test tasks. We wrote the proof down and shipped it alongside the results, so anyone can verify it. We submitted two versions, and the difference between them is a matter of honesty rather than cleverness: - **gaia-nano** is our stronger run. It is label-free, but we will not pretend it never saw the test set. An earlier iteration was run against the test tasks, our engineers read those transcripts, and from reading them we refined the prompt and conduct-rail wording. No labels and no test fields ever entered the machine. Still, the design was informed by looking, and we say so plainly. - **gaia-nano-v3** is the clean one. Its rules were authored from a held-out slice of the training data only, frozen before any evaluation, any judge, and any simulator call, and never touched again. It never saw the test set in any way. It is the honest baseline: what a small model achieves purely from reading allowed demonstrations. ## The results Five runs per task, fifty tasks per domain, judged by the locked GPT-5.4 evaluator. *pass@1* is how often a single attempt passes, averaged across the five runs. *pass^5* is the strict measure: all five attempts on a task have to pass without a single slip, which measures reliability. *UX* is the judge's rating of the interaction on a one-to-five scale. | System | pass@1 | pass^5 | Mean UX | |---|---|---|---| | **gaia-nano** (design-informed by test) | 0.64 | 0.39 | 3.71 | | **gaia-nano-v3** (never saw the test set) | 0.62 | 0.38 | 3.68 | Per domain, for the curious: | Domain | gaia-nano (pass@1 / pass^5 / UX) | gaia-nano-v3 (pass@1 / pass^5 / UX) | |---|---|---| | customer_support | 0.61 / 0.38 / 3.92 | 0.57 / 0.32 / 3.87 | | travel | 0.65 / 0.32 / 3.40 | 0.66 / 0.34 / 3.38 | | shopping_assistant | 0.66 / 0.48 / 3.82 | 0.64 / 0.48 / 3.79 | Read those numbers soberly. The agent solves roughly six in ten tasks on a single try, and it holds steady across all five tries on roughly four in ten. The most revealing line is the gap that is barely a gap: the clean, strictly blind version trails the design-informed version by less than two points on average, and on travel it actually edges ahead. Looking bought us very little; honesty cost us almost nothing. ## Where that sits on the leaderboard STATE-Bench keeps a public leaderboard for the Agent Learning Track, and only entries evaluated on the same release, v0.8.0, make a fair comparison. Here are the verified Agent Learning Track entries on v0.8.0 alongside ours: | System | Organization | pass@1 | pass^5 | UX | Status | |---|---|---|---|---|---| | GPT-5.4 + Foundry Memory | Microsoft Foundry | 54.5% | 33.6% | 3.75 | verified | | GPT-5.4, no memory (baseline) | OpenAI | 51.3% | 29.9% | 3.31 | verified | | **gaia-nano** (ours) | Evercursion / GaiaLogic | **64.0%** | **39.3%** | 3.71 | submitted | | **gaia-nano-v3** (ours) | Evercursion / GaiaLogic | **62.3%** | **38.0%** | 3.68 | submitted | On the same benchmark version, both of our small-model runs land well above a full-size GPT-5.4 paired with Microsoft's dedicated Foundry Memory system, and above the no-memory GPT-5.4 baseline, at a fraction of the model size and inference cost. For wider context, the strongest full-size model on the separate Main Track, GPT-5.5 at high reasoning, sits at 58.9% pass@1 on v0.8.0. Why does a small model carrying a plain-text rulebook beat a frontier model paired with neural memory? Because vector memory blurs hard conditional orderings — such as checking return eligibility and getting explicit customer confirmation *before* triggering a refund — whereas deterministic rules preserve the exact conditions under which an action is valid. Even so, the consistency column keeps us honest. A pass^5 near 39% means that on roughly six tasks in ten, the model still slips on at least one of its five tries when rules are only suggested inside a prompt. Closing that remaining gap means enforcing hard policy and tool-order boundaries outside the model rather than hoping the model remembers to obey them every time — a direction we explore further in Note #07. ## Reference - [Full submissions, scored trajectories, and compliance documents (GitHub)](https://github.com/GaiaLogic-PT/GaiaLogic-STATEbench-Results) - [Our official submission thread (microsoft/STATE-Bench · issue #51)](https://github.com/microsoft/STATE-Bench/issues/51) - [The STATE-Bench repository (microsoft/STATE-Bench)](https://github.com/microsoft/STATE-Bench) - [STATE-Bench Agent Learning Track Leaderboard](https://microsoft.github.io/STATE-Bench/leaderboard/?track=agent-learning) --- ## 5. Team, Leadership & Advisors (https://evercursion.ai/team) Built by researchers and engineers uniting machine learning, cybernetics, formal governance, and critical infrastructure. ### Dr. Simon Hegelich — Co-Founder, Chief Intelligence Officer & Managing Director (https://evercursion.ai/team/simon-hegelich) Former Professor of Political Data Science at the Technical University of Munich (TUM), where his research connected machine learning, complex systems, simulation, and cybernetics (published in Nature, ACM FAccT, Big Data & Society, and OSNEM). Initiated the Co-Recursion research program and leads scientific and architectural development. Selected publications: - S. Hegelich (2020). "Facebook needs to share more with researchers." Nature 579, 473 (World View). https://www.nature.com/articles/d41586-020-00828-5 - O. Papakyriakopoulos, S. Hegelich, J. C. Medina Serrano, F. Marco (2020). "Bias in word embeddings." ACM Conference on Fairness, Accountability, and Transparency (FAT* '20), 446–457. https://doi.org/10.1145/3351095.3372843 - O. Papakyriakopoulos, S. Hegelich, M. Shahrezaye, J. C. Medina Serrano (2018). "Social media and microtargeting: Political data processing and the consequences for Germany." Big Data & Society 5(2). https://doi.org/10.1177/2053951718811844 - O. Papakyriakopoulos, J. C. Medina Serrano, S. Hegelich (2020). "Political communication on social media: A tale of hyperactive users and bias in recommender systems." Online Social Networks and Media 15, 100058. https://doi.org/10.1016/j.osnem.2019.100058 ### Linda Schannen — Managing Director — Operations, Legal & Culture (https://evercursion.ai/team/linda-schannen) Managing Director of GaiaLogic Lda. in Portugal and former inaugural Managing Director of GaiaLogic GmbH in Munich. Holds an M.A. in Design Management (Macromedia University Munich) with prior consulting experience in UX research and organizational design at Spiegel Institut, Schmidhuber, and BECC Agency. Leads corporate operations, cross-border legal execution, and organizational scaling. ### Kolja Hegelich — Co-Founder & Strategic Technical Advisor (https://evercursion.ai/team/kolja-hegelich) Vice President of AI at mobileX, with deep industrial experience in software architecture, enterprise AI deployment, and robotics. Co-architected the foundational implementation of Co-Recursion and advises on system architecture. ### Dr. Ralf Schneider — Cybersecurity & Enterprise IT Advisor & Research Co-Author (https://evercursion.ai/team/ralf-schneider) Former Group CIO of Allianz SE and currently Senior Fellow and Head of the NextGenIT and Cybersecurity Think Tank at Allianz. Co-author of our foundational agentic security study (Living-off-the-Land Immunity in Agentic Harnesses); advises on enterprise IT architecture, cybersecurity governance, and regulated AI co-development. ### Kai-Uwe Ricke — Senior Strategic Advisor (https://evercursion.ai/team/kai-uwe-ricke) Former Chief Executive Officer of Deutsche Telekom AG and former CEO of T-Mobile International. Advises on global technology infrastructure, strategic industry partnerships, and venture scaling. ### Dr. Stephanie Schoss — Co-Founder (Legacy Group) & Senior Strategic Advisor (https://evercursion.ai/team/stephanie-schoss) Founding Director of the Competence Center for Top Teams (CCTT) at the University of St. Gallen (HSG), educated at HSG, Harvard, and Singapore Management University. Serial entrepreneur: Co-Founder of ad-tech platform 1PlusX (acquired by TripleLift in the US), Founder & Chairwoman of psychometric institute IPM, and Founder of C Talks, one of the leading top-executive peer communities in German-speaking Europe. ### Prof. Dr. Erik Cambria — Scientific Advisor & Research Co-Author (https://evercursion.ai/team/erik-cambria) Professor of Artificial Intelligence and Provost Chair in Computer Science and Engineering at Nanyang Technological University (NTU), Singapore, Visiting Professor at MIT Media Lab, IEEE Fellow, and Clarivate Top 1% Highly Cited Researcher. Pioneer of Neurosymbolic AI and Sentic Computing, founder of SenticNet and finaXai, with prior research roles at Microsoft Research Asia and HP Labs. Co-author on our foundational open-ended intelligence, agentic security, and collective intelligence studies. ### Prof. Dr. Christian Montag — Scientific Advisor & Research Co-Author (https://evercursion.ai/team/christian-montag) Distinguished Professor of Cognitive and Brain Sciences at the Centre for Cognitive and Brain Sciences and Associate Director of the Institute of Collaborative Innovation (ICI) at the University of Macau (formerly W3 Full Professor of Molecular Psychology at Ulm University for over a decade). Co-author on our core research studies and academic anchor for our research and compute cooperation in Macau. ### Dr. Morteza Shahrezaye — Senior AI Researcher & Data Scientist (https://evercursion.ai/team/morteza-shahrezaye) Postdoctoral AI researcher (PhD, TU Munich) specializing in computational methods, large-scale empirical evaluation, complex social networks, and data-driven reasoning systems (published at AAAI and Big Data & Society). Selected publications: - O. Papakyriakopoulos, S. Hegelich, M. Shahrezaye, J. C. Medina Serrano (2018). "Social media and microtargeting: Political data processing and the consequences for Germany." Big Data & Society 5(2). https://doi.org/10.1177/2053951718811844 - V. Suter, M. Shahrezaye, M. Meckel (2022). "COVID-19 induced misinformation on YouTube: An analysis of user commentary." Frontiers in Political Science 4, 849763. https://doi.org/10.3389/fpos.2022.849763 - M. Shahrezaye, O. Papakyriakopoulos, J. C. Medina Serrano, S. Hegelich (2019). "Estimating the political orientation of Twitter users in homophilic networks." AAAI 2019 Spring Symposium Series. https://ceur-ws.org/Vol-2448/SSS19_Paper_Upload_216.pdf - M. Shahrezaye, O. Papakyriakopoulos, J. C. Medina Serrano, S. Hegelich (2019). "Measuring the ease of communication in bipartite social endorsement networks: A proxy to study the dynamics of political polarization." 10th International Conference on Social Media and Society (SMSociety '19), 158–165. https://doi.org/10.1145/3328529.3328556 ### Dr. Bardh Prenkaj — Senior AI Engineer, Graph & Reflection (https://evercursion.ai/team/bardh-prenkaj) AI researcher (PhD in Computer Science, Sapienza University of Rome; former postdoctoral researcher at TU Munich) specializing in counterfactual graph explainability, anomaly detection, and graph architectures, with publications at NeurIPS, ICML, ICLR, KDD, AAAI, ACL, and ACM Computing Surveys. Selected publications: - B. Prenkaj, E. Zaradoukas, G. Kasneci (2025). "Graph inverse style transfer for counterfactual explainability." 42nd International Conference on Machine Learning (ICML). https://arxiv.org/abs/2505.17542 - B. Prenkaj, M. Villaizán-Vallelado, T. Leemann, G. Kasneci (2024). "Unifying evolution, explanation, and discernment: A generative approach for dynamic graph counterfactuals." 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (KDD). https://dl.acm.org/doi/abs/10.1145/3637528.3671831 - M. A. Prado-Romero, B. Prenkaj, G. Stilo, F. Giannotti (2024). "A survey on graph counterfactual explanations: Definitions, methods, evaluation, and research challenges." ACM Computing Surveys 56(7). https://dl.acm.org/doi/10.1145/3618105 - M. A. Prado-Romero, B. Prenkaj, G. Stilo (2024). "Robust stochastic graph generator for counterfactual explanations." 38th AAAI Conference on Artificial Intelligence (AAAI). https://ojs.aaai.org/index.php/AAAI/article/view/30149 ### Dr. Habiba Sarhan — Responsible AI, Governance & Model Behavior Lead (https://evercursion.ai/team/habiba-sarhan) AI researcher (PhD, TU Munich) combining academic research in machine learning, model behavior, and formal verification (published in AI and Ethics and Frontiers) with industry experience in Responsible AI at Microsoft and Accenture, alongside formal training and hands-on expertise in AI governance standards and enterprise AI auditing (including ISO/IEC 42001). Selected publications: - H. Sarhan, S. Hegelich (2023). "Understanding and evaluating harms of AI-generated image captions in political images." Frontiers in Political Science 5, 1245684. https://doi.org/10.3389/fpos.2023.1245684 - H. Sarhan, S. Hegelich (2025). "There was coordinated inauthentic user behavior in the COVID-19 German X-discourse, but did it really matter?." Frontiers in Communication 10, 1510144. https://doi.org/10.3389/fcomm.2025.1510144 - H. Sarhan, M. Shahrezaye, S. Hegelich (2025). "Navigating representation: Utilizing prompt engineering to minimize representational harms in journalist's image captions." AI and Ethics 5(5), 5371–5387. https://doi.org/10.1007/s43681-025-00773-x - S. Hegelich, S. Dhawan, H. Sarhan (2023). "Twitter as political acclamation." Frontiers in Political Science 5, 1150501. https://doi.org/10.3389/fpos.2023.1150501 ### Matthias Balk — Senior Software & Systems Integration Engineer (https://evercursion.ai/team/matthias-balk) Software and AI systems engineer with 10+ years of engineering and entrepreneurial experience, including co-founding legal-tech AI venture Elephant Labs (LLM-based enterprise document anonymization). Leads repository architecture, interface engineering, and production integration.