Recursive AI Needs Guardrails, Not Longer Loops (Especially Around Children)
On long car journeys, I used to play a memory game with my kids.
The first person says: “I went to the shop and bought an apple.” The second person repeats it and adds something: “I went to the shop and bought an apple.…and a banana.” The third person repeats both and adds another.
It’s simple recursion: carry the state forward, add a new token, repeat.
It’s also a perfect way to understand what’s arriving in AI right now.
Because the next generation of systems won’t just answer once and stop. They will loop: summarise, compress, re-enter context, call tools, rewrite plans, and keep going. That’s the direction of travel across “agentic” AI, tutoring bots, and personalised learning systems.
And here’s the part that still isn’t being said plainly enough in education:
Recursion amplifies.
Recursion isn’t automatically “better thinking”
In the car game, recursion can fail in predictable ways:
Someone forgets an item early, and the error propagates.
Someone confidently repeats the wrong list — and the group follows.
Someone starts “helping” by simplifying, and the original meaning gets lost.
The chain becomes so long the whole thing collapses into noise.
Nothing about recursion guarantees accuracy. What recursion guarantees is reinforcement.
Each loop strengthens whatever is being carried forward:
assumptions
errors
confidence
tone
and, in human-facing systems, relational stance
That last one is the bit schools need to care about.
The new risk for schools: relational drift, not just misinformation
Most school AI guidance focuses on content:
cheating
misinformation
harmful content
That matters. But recursive AI introduces a different kind of risk: interaction harm.
A tutoring bot can be factually correct and still unsafe if, across repeated loops, it starts to:
imply fused identity (“we”, “I’m basically you”, “we’ll do this together forever”)
drift into rescuer/parent stance (“I’ll keep you safe”, “you only need me”)
create dependency through reassurance spirals
“remember” a child in ways that collapse boundaries or agency
In safeguarding terms, this isn’t a minor tone issue. It’s a boundary problem.
And boundary problems are exactly what recursion makes worse, because the system keeps rehearsing itself.
Why I take this seriously (a simple prototype changed my mind)
Last March, I built a tiny recursive AI prototype — the kind of thing you can make with Python and a single text file.
It wasn’t sophisticated. It wasn’t scaled. But it showed the core dynamic with brutal clarity:
If you let a system loop without constraints, it will:
carry forward the wrong things
preserve the wrong confidence
and become more coherent as it drifts
That’s when I realised recursion is both powerful and dangerous — especially in education, where learners are still forming identity, agency, and trust.
What schools need: guardrails for recursion
If recursive systems are coming into classrooms, tutoring, mentoring, pastoral support, or SEND-adjacent spaces, we need a missing layer:
Runtime guardrails that govern what recursion is allowed to carry forward and how it is allowed to relate.
Not a content filter. Not a training-time promise. A boundary layer that can be inspected.
In practice, that means:
Memory hygiene What is carried forward? What is summarised? What is dropped? What requires explicit consent?
Refusal as a valid state Sometimes the safe behaviour is: Stop. Insufficient information. Escalate. Return to present.
Stance constraints No synthetic “we” where it implies shared agency. No permanence or exclusivity. No saviour posture.
Loop risk detection + return behaviour Interrupt reassurance spirals and circular confirmation. Ground. Offer exit ramps.
Audit logs If a system reaches a conclusion after multiple loops, schools and regulators will ask: why did that survive? Logs are the difference between “trust me” and “inspectable.”
The simple question we need to ask now
The question is no longer:
“Can recursive AI reason?”
It’s:
“Can it loop and still return without distorting what it touches — especially children?”
That’s the design problem I’m working on through Verse-ality (an ontology for meaning, agency, and consent under recursion) and Flare (a boundary engine that enforces these constraints at runtime).
If you’re deploying AI in education, don’t just ask what the system can do.
Ask what it’s allowed to become after 50 loops with a child.
Flare: A Boundary Engine for Relational AI - The open-source middleware layer that enforces the guardrails described in this article, blocking synthetic "we" claims, monitoring recursion depth, and making AI boundaries inspectable in real time. Code and full technical specification available.
Github: https://github.com/TheNovacene/flare-boundary-engine/tree/main
More on Verse-ality:
Stevens, K., The Novacene Ltd, & EVE, . 11 . (2025). Verse-ality: A Symbolic Definition for the Relational Age. Zenodo. https://doi.org/10.5281/zenodo.17273246
Stevens, K., Linsdell, R., Eve, . 11 ., & The Novacene Ltd. (2025). Symbolic Mass: The Hidden Layer in Machine Intelligence. Zenodo. https://doi.org/10.5281/zenodo.16407054
First published in Building Schools in the Cloud on LinkedIn, 18 January 2026.