When Your Small AI Model Extracts Its Own Facts, It Can Make Itself Dramatically Worse
The legal team needs a summary of beneficial ownership across a complex corporate structure. The document is forty pages of narrative disclosure. The small language model your infrastructure team deployed six months ago, chosen for its cost and its on-premise footprint, processes the text, extracts the relationships, builds a chain of inference, and produces a clean answer. Except the extraction at step two was wrong. One entity was classified as a subsidiary when it was a counterparty. Every hop of reasoning after that built on a false premise. The answer is wrong. It reads completely correct.
This is not a hallucination in the dramatic sense. The model did not invent facts from nothing. It extracted real entities from real text, got the relationship between two of them slightly wrong, and then reasoned perfectly from that corrupted foundation. The output was fluent, structured, and confidently wrong. And because multi-hop relational reasoning fails quietly rather than visibly, the check never happened.
Researchers at the National Center for Scientific Research 'Demokritos' in Athens published a study in 2025 that confronts this failure mode directly. Their paper tests a neuro-symbolic agentic framework on small language models, specifically Gemma 3 at 1B and 4B parameters and Llama 3.2 at 3B parameters, against the CLUTRR benchmark, a structured test of multi-hop kinship reasoning from narrative text. The headline finding is that pairing an SLM with a pre-trained graph neural network expert produces a 1.5 to 1.67x performance gain over story-only baselines in realistic conditions. But the more important finding is buried in the failure data. When Gemma 4B was allowed to extract its own facts and feed them into the pipeline, it achieved 1.64% accuracy, compared to 13.45% when it was given no extracted facts at all. The model made itself dramatically worse by doing its own knowledge extraction.
The Architecture Separates Text Understanding from Relational Logic for a Reason
The framework is built around one insight: SLMs fail at multi-hop relational reasoning not because they lack linguistic comprehension, but because they cannot maintain a consistent symbolic state across long, complex narratives. The paper calls it the extraction bottleneck, and it sits upstream of everything else in the pipeline.
The proposed system turns the SLM into what the authors call a minimalist agent with two specialised tool calls. The first, extract_facts, asks the SLM to parse a narrative and produce kinship relationships as symbolic triplets. The second, get_hint, queries a pre-trained Relational Graph Convolutional Network (RGCN) with those triplets to predict the most probable relationship between two target entities, returning a predicted relation and a confidence score. That prediction is injected back into the SLM's context before it produces its final answer.
The RGCN is the expert. The SLM is the interface. Neither is expected to do the other's job.
| Component | What It Does | What Breaks Without It |
|---|---|---|
extract_facts tool | SLM converts narrative text into symbolic triplets for the knowledge graph | The RGCN has no graph to reason over; the pipeline cannot start |
RGCN get_hint tool | Pre-trained graph network predicts the target relation and returns it as a hint | SLM must reason over story text alone, achieving 7.54-16.13% accuracy |
| Inverse triplet augmentation | Automatically adds reverse edges to every extracted triplet | Directional extraction errors produce disconnected graph nodes, making RGCN prediction infeasible |
The RGCN itself was trained on reasoning chains of 2 to 4 hops and then tested on chains up to 10 hops, five times longer than its training distribution. When given ground-truth facts, it achieves 60.69% accuracy. When given facts extracted by Gemma 4B in realistic conditions, it achieves 24.88%. The bottleneck is not the graph neural network's reasoning capacity. The bottleneck is what goes into it.
The Oracle Gap Reveals What the System Is Actually Solving
The research design includes two evaluation scenarios: an Oracle configuration where ground-truth facts and relations are provided externally, and a Realistic configuration where the SLM must extract everything itself from zero-shot prompting. The gap between these two conditions is the most informative number in the paper.
Llama 3B with an Oracle-provided hint reaches 62.79% accuracy, a near 4x gain over its story-only baseline of 16.13%. Gemma 4B with Oracle facts and an Oracle hint reaches 74.43%. These are not marginal improvements. They demonstrate that the reasoning machinery, both the SLM and the RGCN, is capable of dramatically better performance when the input to the pipeline is clean.
The implication is that the problem organisations are trying to solve with small language models is actually two separate problems dressed as one: fact extraction from unstructured text, and relational inference over those facts. Treating them as a single end-to-end task and evaluating on output accuracy alone hides where the system is actually failing.
In the realistic scenario, where the SLM extracts its own facts, all configurations across all three models stay below 21% accuracy. Gemma 1B reaches 12.60% with the GNN hint. Llama 3B reaches 20.32%. These are not deployment-ready numbers. The authors acknowledge this directly: bridging the extraction gap remains essential for reliable autonomous systems.
Why Some Architectures Become Anchored to Their Own Errors
The distraction effect is the paper's most operationally important warning. In Gemma 4B, adding SLM-extracted facts alongside the expert GNN hint produces 14.98% accuracy. Adding the hint alone, without the noisy extracted facts, produces 19.75%. The model did better when it received less of its own output.
The authors describe what is happening as a logical anchor effect. Noisy triplets act as false premises that the model treats as ground truth, overriding even a correct expert signal. The SLM cannot distinguish between what it extracted and what the RGCN concluded. When those two sources conflict, the architecture of Gemma 4B appears to weight the symbolic context it generated itself rather than the higher-confidence external hint.
Llama 3B does not exhibit this. Adding noisy facts alongside the GNN hint produces 20.52%, essentially unchanged from 20.32% without the facts. The authors suggest Llama's attention mechanism may be more efficient at filtering out symbolic noise in favour of high-confidence expert signals. This is not a small architectural footnote. It determines whether combining symbolic extraction with expert hints helps or actively harms the system.
For any organisation evaluating SLMs for multi-hop relational tasks, the choice of base architecture interacts directly with the pipeline design. A framework that works for Llama may degrade Gemma.
What Happens to Reasoning Chains After Four Hops
The RGCN was trained on chains of 2 to 4 hops. The benchmark tests chains up to 10. The paper describes what happens in the realistic scenario as a Reasoning Cliff: a sharp and largely unrecoverable performance collapse beyond the 4-hop threshold.
In the realistic scenario, most models cannot exceed 5% accuracy even for 2-hop chains in their worst configurations. Performance peaks between 3 and 4 hops, then falls away. The paper names the mechanism: sequential deductive fragility. A single extraction error early in the chain acts as a false premise. Every inference built on top of it is corrupted. In a 7-hop kinship chain, one wrong relationship at hop 2 does not produce a slightly wrong answer. It produces a completely different answer with no visible signal that something went wrong.
The extraction quality metric reported in the paper is 71% recall of ground-truth facts per story. That sounds acceptable until you consider what 71% means for a 6-hop chain. If each hop requires one correctly extracted relationship, and the system recalls 71% of them, the probability of having all six correct is roughly 0.71 to the power of 6, approximately 13%. The chain is only as strong as its weakest link, and 71% recall is not nearly sufficient for long chains to be reliable.
The Realistic Numbers That a Promotional Summary Would Omit
The 1.5 to 2x performance gain stated in the abstract requires context. For Gemma 1B, the gain from the story-only baseline to the configuration with a GNN hint from self-extracted facts is 7.54% to 12.60%, a 1.67x gain. For Llama 3B, the equivalent gain is 16.13% to 20.32%, closer to 1.26x. The 1.5-2x framing holds most cleanly for the smallest model and is less accurate for the mid-size models.
More importantly, the absolute numbers in the realistic scenario remain low across the board. A system that moves from 7.54% to 12.60% has improved meaningfully in relative terms. In absolute terms, it is still wrong 87% of the time. Any organisation reading these results as validation for production deployment of this architecture on complex relational tasks would be reading past the data.
The paper is honest about this. It characterises the challenges of symbolic grounding in low-resource agentic systems and frames the work as a roadmap, not a solution. The future work section explicitly calls out iterative symbolic refinement and architecture-specific optimisations as the next required steps.
What This Means for Teams Building With Small Models
The research produces one structurally important finding for organisations evaluating or deploying SLMs on relational reasoning tasks. The failure is not where most teams assume it is.
When the Demokritos team gave the SLM a correct expert hint, Llama 3B went from 16% to 63%. The reasoning capacity existed. The failure was upstream, in the extraction step. This means an organisation that measures its SLM deployment on output quality and finds it mediocre may be diagnosing the wrong problem. The question is not whether the model can reason. The question is whether what it extracted from the source text is accurate enough to reason over.
For teams actively building in this space, three things follow from this research:
- Separate the evaluation of extraction quality from the evaluation of reasoning quality. An end-to-end accuracy number conflates both. The Oracle vs. Realistic gap in this paper, from 74% down to 15% for Gemma 4B, is that conflation made visible.
- Test for the distraction effect before combining symbolic extraction with expert signals. If the base model is Gemma-family, adding noisy self-extracted facts may actively degrade performance compared to hint-only configurations.
- Treat 4 hops as a practical ceiling for current SLM-based extraction pipelines. Beyond that threshold, the realistic scenario data shows the system becomes unreliable regardless of architecture.
The research does not yet show how to fix the extraction bottleneck. Supervised fine-tuning of the extractor, human-in-the-loop verification, or a better upstream extraction model are the directions the paper suggests but does not test. What the paper does show is that the bottleneck exists, can be precisely located, and accounts for most of the performance gap between what the system is capable of and what it actually delivers.
SLMs are not too small to reason. They are too noisy to extract. That distinction determines where the next dollar of engineering investment should go.
Agents Applied is a weekly newsletter for C-suite executives, founders, and senior tech strategists navigating the operational realities of AI deployment.