// Lindwurm · Research program
Lindwurm — our research program
A neuro-symbolic reasoning engine on a biologically inspired substrate.
Lindwurm learns new skills from a handful of examples — not from oceans of data. It reasons through a compact set of logical primitives, running on a neural fabric that processes the world the way nervous systems do: as continuous signals — filtered, modulated, and self-regulating.
Measured on public benchmarks. Built for independent audit. Committed to civilian use only.
Scaling alone is hitting a wall — the next step is efficiency
Today's frontier AI improves mostly by getting bigger: more parameters, more data, more compute. On tasks that demand genuinely novel reasoning — where memorization cannot substitute — the returns of scale are diminishing, and the largest systems still struggle. The real bottleneck is not compute. It is the capacity to generalize from minimal evidence. Lindwurm attacks exactly that bottleneck: sample efficiency and adaptive reasoning as first-order engineering goals — not as side effects of size.
Two layers, one system
The reasoning layer
A compact set of elementary logical and structural operations — the primitives from which task-specific skills are composed. Because skills are built from inspectable primitives, every conclusion can be traced, explained, and independently audited.
The substrate
Underneath, Lindwurm is not a conventional deep network. It is a fabric of processing regions — some specialized, some general — that exchange continuous-valued signals rather than binary activations. Incoming data is treated as a continuous quantity and discretized adaptively, in the spirit of finite-element analysis: the resolution is not fixed in advance but set by dynamic, autonomous input filters, much as sensory organs pre-filter the world for a nervous system.
Modulated connectivity
Regions do not merely activate one another. A proprietary neurotransmitter-inspired modulation model governs how strongly, how long, and in what context signals propagate — giving the network state, plasticity, and context-dependence that point-to-point architectures lack.
The homeostatic learning loop
A feedback-driven controller continuously strengthens or weakens pathways based on solution fitness. Learning happens at inference time — from the examples in front of the system. This is what makes few-shot skill acquisition possible, and what keeps the system stable while it adapts.
Native inputs today: raw images and event/impulse streams. Widening the input and output horizon is an explicit part of the research program.
Two examples — and the rule is found
A concrete illustration, in the style of ARC-class reasoning tasks. The engine is shown one or two demonstration pairs of a visual transformation and must infer the rule behind them. That rule can be a single operation — reflection across a vertical axis — or several composed at once, adding a translation or a colour swap. The homeostatic learning loop settles on whichever combination the examples actually support, activating and inhibiting each candidate operation as the evidence dictates. It then applies the inferred rule to a task it has never seen. That is the core claim of the program, made visible: rules, not memorized patterns — from a handful of examples.
Demonstrations
Inferred rule
- Reflection across a vertical axisactive
- Translationoff
- Colour swapoff
- Reflection across a vertical axisoff
- Translationactive
- Colour swapactive
- Reflection across a vertical axisactive
- Translationactive
- Colour swapactive
New task
The same rule, applied to an input it has never seen.
More worked examples
The same few-shot idea across other families of the test programme: infer the rule from a handful of examples, then produce the answer — never pick it from a list.
Raven's Matrices
Matrix completion
A 3×3 matrix with the bottom-right panel missing. The engine infers the rule and generates that panel (amber) — no option list. The progression changes each scene.
Bongard-LOGO
Concept sort
filled vs. outline
one vs. many
large vs. small
Left: the hidden concept holds; right: it does not. The query lands on the side it belongs to. The concept changes each scene.
Winograd Schema
Coreference
The trophy did not fit in the suitcase because it was too large.
referent generated directly — no option list
The trophy did not fit in the suitcase because it was too small.
referent generated directly — no option list
The councilmen refused the demonstrators a permit because they feared violence.
referent generated directly — no option list
A highlighted pronoun resolves to one of two entities. Swapping the trigger word flips the answer — the referent is generated, not chosen.
From code to genome
The performance-critical core runs in C and Fortran. The next generation goes further: the network's structure and dynamics are written in a purpose-built description language that encodes the system natively — much as a genome encodes an organism — and is executed by an interpreter engine that exposes commodity hardware as a resource to the neural fabric.
We evaluated existing neuromorphic hardware platforms and chose not to build on them: our connectivity and modulation model goes beyond the assumptions of spiking-network architectures, and mapping onto them would mean giving that up. Commodity hardware today; dedicated silicon is a long-term option, not a dependency.
What we know — and what we don't yet
The core reasoning engine is operational in controlled settings. That is the foundation, not the finish line. The research program is built around four open questions:
Generalization
Few-shot skill acquisition works on the task families we developed our methodology on. Does it hold on task families the system has never seen? This is the central question — and the central risk.
Scaling the substrate
In structural complexity, the current fabric is comparable to a simple biological nervous system — roughly at the level of an insect. The program targets substantially richer structure, at the level of a reptile nervous system. Whether the homeostatic learning loop stays stable at that scale is an open research question.
Measuring what matters
No established benchmark exists for this class of system. Public suites — spanning visual-abstract reasoning (ConceptARC, ARC-AGI, RAVEN) and language, knowledge and mathematics (MMLU, GPQA, HellaSwag, Winograd Schema, ARC, AIME / AMC 12) — are necessary but not sufficient: they measure task success, not sample efficiency or compute per result. We treat them as proxies — and we are developing a complementary, reproducible evaluation methodology, built for independent audit, as an explicit research deliverable.
The input/output horizon
Today the system natively ingests images and impulse streams. Extending to further modalities — without retraining from scratch — is the fourth open front.
Honest risk assessment
A research program that names no risks isn't being honest. Ours has four, each with a mitigation we budget for:
The learning loop may destabilize at scale.
The homeostatic controller is proven at current size; full-width stability is an open question. Mitigation: phased scale-up with continuous internal metrics — months 4–9 of the program are explicitly budgeted for hardening.
Benchmark scores may plateau below target.
If they do, low scores are treated as diagnostic input, not failure: the closed feedback loop tells us precisely where to improve. Honest, independently verified measurement matters more than hitting a number on the first pass.
Compute costs may overrun.
Full-width evaluation needs serious GPU capacity. Mitigation: funded compute plus free research allocations (EuroHPC and research-cloud programs) to extend the runway.
Knowledge concentrates in few heads.
A real risk in a small founding team. Mitigation: documentation-first development from month one, knowledge deliberately distributed, and new collaborators planned at incorporation.
These risks are addressed within a defined framework of legal requirements and standards — see Standards & Compliance.
How we measure
We measure with Alois, our evaluation framework for this class of system — procedurally generated, contamination-free tasks, efficiency-weighted in the Alois Index. Program results are reported along three axes: sample efficiency, generalization, and compute per task.
Three axes, published for every result: sample efficiency — how many examples a new skill requires; generalization — performance on unseen task families; compute per task — result quality relative to resources consumed.
Three tiers of verification: public datasets (ConceptARC, ARC-AGI, RAVEN, MMLU, GPQA, AIME and more) — prediction-upload leaderboards with independent scoring — controlled API access for independent auditors.
The disciplines behind the program
Lindwurm sits at the intersection of four research threads we cultivate: formal methods — model checking and formal logic, where testing isn't enough; explainable anomaly detection — low false-positive learning on data streams; privacy-preserving computation — privacy as an engineering constraint, not an afterthought; and decision & ethics models — formalizing proportionality: where the threshold lies, and what evidence is needed to cross it.
A research thesis worth testing
Behind the engineering sits a scientific hypothesis: that intelligent, adaptive systems fundamentally depend on self-maintaining, homeostatic cores — not on static, frozen computation. This is a claim, not a belief; the program exists to test it with rigorous, independently verifiable measurement. The funded 16 months are the first disciplined test of that thesis. Success is defined the only way that counts: third-party-verifiable results, reproducible benchmarks, documented method.
Research program & FAQ
The 16-month program timeline and answers to the questions we're asked most — on a page of their own.
Lindwurm is developed for civilian applications only — a design requirement, not a policy.
A hard problem, a pilot domain, a collaboration?
Bring us a reasoning problem where a handful of examples and auditable decisions matter.