A Pathway from Stateless Foundation Models to a Stateful DCA-Brain

How the Distributed Cognitive Architecture (DCA) turns stateless Foundation Models into a stateful, self-improving system — a white paper for technical leaders.

Welf Wustlich · CTO, PLANET AI · Rostock, Germany · www.planet-ai.de

In one paragraph. A Foundation Model is a core component of the DCA-Brain — as it is in every agentic AI flow — but only a component. AGI needs four capabilities no Foundation Model has on its own: Teamwork, Memory, Convergence, and Learning from Feedback. DCA supplies all four as a stateful layer around any model — biologically grounded (P0), formally proven to converge (P1), and already the winner of the ICDAR 2026 DocVQA world competition. Proven, not promised.

1 · The model is not the product

For three years the industry ran one experiment: make the model bigger. It worked, until it started not to. Apple Research's The Illusion of Thinking (2025) showed reasoning models solving easy problems reliably but collapsing past moderate complexity — exactly where adaptive control, abstraction, and self-reflection are required. More parameters do not buy those. You cannot make a dictionary intelligent by making it thicker.

The gap is not a training problem; it is a structural one. A transformer forward pass is brilliant in the instant and amnesiac between instants. Everything it "is" from one call to the next has to be written back into its input, or it is gone. To turn that stateless engine into something that solves a real, multi-step, multi-source task, you have to build a system around it — one that holds state, decides what to remember and retrieve, knows when it is done, and gets better with use. That system is the product. The model is a component of it.

That is the bet DCA makes — and, unlike a slide-deck claim, it is backed by two results that can be checked: a biological account of why the architecture takes its form (P0), a formal theory of what it guarantees (P1), and an external, juried proof that it works at scale (DocVQA 2026).

2 · The four missing capabilities

The Foundation Model supplies the raw flow — the World Model (WM). Four capabilities have to be built around it, and they are structural, not a matter of scale:

1. Teamwork. A single model works one problem in one context. It cannot spin up specialists, let them work in parallel, and converge their findings into one answer.
2. Memory. Its context evaporates when the call returns. Facts, skills, and failures need a home that persists and compounds across tasks.
3. Convergence. A forward pass is not a loop. Without recurrence the system cannot iterate to a stable answer — nor know, on a formal signal, when it is done.
4. Learning from Feedback. The model is frozen after training. It cannot get better from its own successes and failures.

DCA supplies all four with one architecture — and it did not invent that architecture from engineering first principles. It read it off the neocortex.

3 · Blueprint from the neocortex (P0)

The Foundations paper (P0) makes one point that matters here: DCA is not an ad-hoc bag of tricks — its four capabilities are the ones the brain already uses. In brief:

• Teamwork. The brain is not one big model but many small, near-identical units, each forming its own view and voting to a consensus. Intelligence is a team from the start — DCA's many-agents-one-brain composition (§5).
• Memory. It holds memory on three time-scales — short-term, episodic, long-term — steered by attention (what to hold) and expectation (what to predict, and the error when it is wrong). That is DCA's L0/L1/L2 (§4), one to one.
• Reference frames. Knowledge lives in reusable frames — the same machinery for a coffee cup, a theorem, and a codebase — which give it structure and give the agent its orientation.
• What / Where. Separating what something is from where it sits is what lets knowledge generalize beyond the case it was learned on.

The takeaway is not the neuroscience. It is that every capability has a principled reason to exist and a working precedent in the one system we know is generally intelligent — a far more durable footing than "it helped on our benchmark." The pillar-by-pillar argument is P0's; this white paper borrows only the conclusion.

4 · The building block: the WMC-Agent

The building block is the WMC-Agent — World Model · Memory Controller · Dynamic. A frozen Foundation Model supplies the flow (it turns context into output); a runtime-adaptive Memory Controller supplies the topology and navigation (it decides what to remember, what to retrieve, and when the loop is done). A static model is not an agent; the coupling is.

%%{ init: { "flowchart": { "curve": "basis" } } }%%
flowchart LR
    classDef fm fill:#1e3a5f,stroke:#1e3a5f,color:#fff,stroke-width:2px
    classDef memory fill:#06b6d4,stroke:#06b6d4,color:#fff,stroke-width:2px
    classDef channel fill:#67e8f9,stroke:#67e8f9,color:#1e293b,stroke-width:2px
    classDef servo fill:#8b5cf6,stroke:#8b5cf6,color:#fff,stroke-width:2px
    subgraph AGENT ["WMC-Agent"]
        direction TB
        FM(["Foundation Model"]):::fm
        MC(["Memory Controller"]):::memory
        MC -->|Context| FM
        FM -->|Task / Answer| MC
    end
    style AGENT fill:none,stroke:#004bff,stroke-width:2px,stroke-dasharray:5 5,color:#8fe0f5
    MC --> L0(["L0 — Working Memory"]):::channel
    MC -->|Consolidation| L1(["L1 — Episodic Memory"]):::channel
    MC --> L2(["L2 — Semantic Memory"]):::channel
    FM --> SV(["Servo"]):::servo
    

The Memory Controller exposes three memory channels on graded time-scales: L0 working memory (volatile, the current task), L1 episodic memory (compressed past experiences with their expectations; persists across sessions and triggers learning), and L2 semantic memory (documents, knowledge graph, optional adapters; near-permanent). The agent is embodied through Servos: a Servo is its sensorimotor layer — a concrete workspace such as a repository, a browser, a database, or a machine that it perceives and acts in. Each Servo exposes tools and skills; each action produces a side effect, the side effect becomes a perception, and the perception a prediction-error that drives the loop. Embodiment, in DCA, is not a metaphor — it is whatever the Servo connects to.

The loop is the heartbeat of the whole architecture — one repeating transaction: Predict → Act → Observe → Surprise → Learn. The agent forms an expectation, acts (in a DCA everything is a tool-call — a sub-agent, even the final answer), observes the result, and measures the surprise: its distance decides whether to learn, its valence decides what — a positive surprise becomes a rule or a skill, a negative one becomes negative knowledge, written to memory or, once a pattern is stable, trained into an adapter.

5 · Many agents, one brain: fractal composition

The atomic agent is the cell, not the organism. WMC-Agents compose fractally: an Orchestrator delegates to sub-orchestrators and worker agents — and every node is itself a complete WMC-Agent with its own model, memory, and loop. Many Foundation Models, each wrapped in a Memory Controller, compose into one brain — the way thousands of cortical columns compose into one cortex (§3).

%%{ init: { "flowchart": { "curve": "basis" } } }%%
flowchart TB
    classDef orchestrator fill:#e91e8a,stroke:#b0156b,color:#fff,stroke-width:2px
    classDef agent fill:#004bff,stroke:#004bff,color:#fff,stroke-width:2px
    classDef tool fill:#9e9e9e,stroke:#616161,color:#fff,stroke-width:1px
    classDef servo fill:#8b5cf6,stroke:#7c3aed,color:#fff,stroke-width:2px
    ORCH(["Orchestrator"]):::orchestrator
    ORCH --> A1(["Researcher"]):::agent
    ORCH --> A2(["Coder"]):::agent
    ORCH --> O1(["Sub-Orchestrator 1"]):::orchestrator
    A1 --> S1(["Web Servo"]):::servo
    A1 --> T1b(["Doc Reader"]):::tool
    A2 --> S2(["Repo Servo"]):::servo
    A2 --> T2b(["Tests"]):::tool
    O1 --> B1(["Domain Expert"]):::agent
    O1 --> B2(["Validator"]):::agent
    O1 --> O2(["Sub-Orchestrator 2"]):::orchestrator
    B1 --> S3(["Knowledge Servo"]):::servo
    B2 --> TB2a(["Rule Engine"]):::tool
    O2 --> C1(["Query Writer"]):::agent
    C1 --> S4(["DB Servo"]):::servo
    

Two properties make this powerful. Position independence: a sub-sub-orchestrator implements the same interface as the root and does not know its own depth — so the same convergence machinery, memory channels, and retrieval policy apply at every level. Dynamic emergence: the hierarchy is not configured in advance — it grows on demand from task decomposition and folds back when done. A fact lookup is one agent; a multi-domain analysis spins up three levels of specialists and collapses them afterward. The protocol between agents is not a proprietary bus — it is language itself (natural language, or JSON where a schema helps). The orchestrator talks to its sub-agents exactly the way a user talks to the orchestrator. That uniformity is what makes the whole thing fractal — and simple.

6 · Proven to converge (P1)

Most agent frameworks are heuristic: they iterate until a budget runs out and hope the answer is good. They are silent on whether their loops converge, terminate, or make progress in any provable sense. The Theory paper (P1) is DCA's answer, and it is the part that turns an architecture into a science.

• A stable answer is an attractor. P1 formalizes the coupled World Model ↔ Memory loop as a dynamical system and proves that, under stated conditions, its trajectories converge to a co-emergent attractor — a fixed point that neither the model nor the memory defines alone. Memory supplies the topology of the landscape; the model supplies the flow; the controller navigates. Answering becomes settling into a basin, not sampling and hoping.
• Recurrence ⊕ Tree. A raw transformer, iterated naively, does not converge — each step is a fresh pass with no damping. A classical recurrent net damps but cannot reach the model's reasoning power. P1 shows DCA is the hybrid: tree-style inference within a step, recurrence across steps, with the memory hierarchy holding what recurrence would forget.
• Guarantees on observables, not internals. Because an LLM is stochastic, non-Lipschitz, and opaque, P1 places its axioms not on the model's weights but on the observable convergence signals it emits — embedding drift, completion scores, retrieval saturation, consensus. The guarantees therefore apply to any Foundation Model and survive every model release.
• Three guarantees no agent framework offers: Convergence (the loop settles on a stable answer), Termination (it stops on a formal observable signal, not a timeout), and Quality (convergence implies the task is actually done).

P1 also places DCA in a real scientific lineage — the semantic attractor dynamics generalize Neural Gas (Martinetz & Schulten, 1991) from topological to semantic embedding spaces. This is not a framework that appeared with the LLM era; it is a thirty-year idea meeting the component that finally makes it work.

7 · The proof: winning DocVQA 2026

Theory earns its keep when it wins in the open. At ICDAR 2026, a DCA system placed first — the official winner of the >35B-parameter category of the DocVQA 2026 competition at the CVC Robust Reading Competition, the field's canonical, externally-juried benchmark for reasoning over documents.

The result is decisive precisely because the benchmark is hard in the right way. DocVQA 2026 — Multimodal Reasoning over Documents in Multiple Domains — spans eight heterogeneous domains (business reports, scientific papers, slides, posters, maps, comics, infographics, engineering drawings) and asks questions that require reasoning across multiple sources of evidence, not simple extraction. Our submission reached 60.00 % accuracy — a +20-point margin over the strongest frontier-model baseline (~40 %) — and the report attributes roughly +7 points to deterministic text extraction and +13 points to DCA's orchestration. In other words, most of the win came from architecture, not from a bigger model. The system orchestrated five different models at once — Gemini 3.1 Pro, Gemini 2.5 Pro, Claude Sonnet 4, Qwen 3.5, Claude Opus 4.6 — under a single Memory Controller, which is model-agnosticism demonstrated, not promised. (Planet AI brings ten years of document-AI R&D and eight prior ICDAR/ICFHR competition wins behind this.)

This is the existence proof that the formal apparatus of P1 and the biological design of P0 survive the move from paper to a running competition pipeline at scale.

8 · The same four, now verifiable — software and science

Documents have no oracle: an answer can only be plausible. Engineering and science are different — they carry a source of truth. A compiler and a test suite verify software; a proof checker verifies mathematics; a lab assay or a reference database verifies a scientific result — a DNA analysis, say. Wherever such a source exists, an answer is not merely plausible; it can be verified.

Reaching those domains is an extension, not a rewrite: the same graph that stores documents semantically runs as a logical, verifiable one wherever a source of truth exists — the same nodes and edges, now with a truth status (verified / open / defeasible), and verification is just another tool-call whose verdict feeds the loop. Two things follow for free: a result can be stated as a contract before it is built (a signature, a spec, a theorem statement) that other work depends on while its implementation is open; and every verdict carries a strength — a type-check is weaker than a test suite, weaker than a formal proof.

With a source of truth in reach, each capability turns rigorous: Teamwork builds on verified components, Memory stores verified facts, rules, and skills (and the failures, so they are not retried), Convergence terminates on a real verdict rather than an estimate, and Learning from Feedback takes pass/fail as its sharpest signal. The further a task sits toward the verified end, the more autonomously the system can run.

9 · The strategic bet: ride the wave, own the moat

For a technical leader the architecture matters, but the economics decide. Three points:

DCA rides the wave instead of racing it. The Foundation Model is a swappable component. A better model → automatically a better DCA; a cheaper, faster model → automatically a cheaper, faster DCA. Every dollar the world pours into Foundation Models makes DCA better — at no cost to us. Model-swappability is an architectural principle, not a migration project; there is no lock-in and no race to own the biggest model.

Most of the field is optimizing the wrong part of the stack:

Governed by construction. DCA's state is transparent, auditable, and provenance-tracked — each memory entry can carry its contributor origin, turning a shared substrate from an unbounded attack surface into a traceable, quarantinable one. Combined with formal termination and model-agnosticism, that is exactly what regulated, multi-vendor, production settings require and what opaque single-vendor scaffolding cannot offer. Adoption is incremental: DCA wraps existing transformer systems rather than replacing them.

10 · Why now

The window is open, and the logic is short:

1. The frontier's recent gains come from the harness, not the model. The two landmark jumps of the past year came from the labs themselves — and from the harness, not a bigger model: OpenAI on ARC-AGI-3, where the same model leapt to near-perfect once its reasoning state was preserved across calls; and Anthropic, formalizing Fermat's Last Theorem end-to-end with a fleet of agents sharing a structured proof state. Same models — a different harness.
2. But every harness today is a heuristic. Claude Code, DeepSeek's harness, the coding- and proof-harnesses — each is a clever point-solution that reinvents one piece (memory here, verification there, a planning loop elsewhere). None is a general theory; all are silent on convergence.
3. DCA is the framework that covers them all. Each of those harnesses is a special case of Teamwork + Memory + Convergence + Learning from Feedback — the four capabilities, done ad-hoc. DCA supplies them once, generally, with guarantees, on any model.
4. Generalizing the harness compounds. When the four reinforce one another instead of being bolted on singly, capability multiplies rather than adds — an exponential step in what the system can attempt.
5. In this phase, speed is the advantage. The gains have moved to the harness and no one has generalized it yet. Arriving early with the framework — not another point-solution — secures a lead that compounds.

11 · The pathway, in one line

Left alone, a Foundation Model computes and forgets. A DCA-Brain wraps it in a loop that keeps a self-correcting state alive over time. The pathway from one to the other reads as a sequence of verbs — give the model a memory; give the memory a structure; give the structure a source of truth; and give the truth to more than one mind.

Intelligence was never in the model. Foundation Model + Teamwork + Memory + Convergence + Learning from Feedback = AGI — the first term already exists; DCA is the rest, and it is buildable now.