148,000 to 197,000 knowledge triples in 8 hours. That's a +33% knowledge growth rate during a single autonomous tutoring session — and not one of those triples was written by the LLM.

That distinction is precise, and worth being precise about: an LLM is in the loop, as a search assistant that points at the right passage. What it never does is author the triple. The extraction that turns a passage into (subject, predicate, object) is deterministic pattern-matching, and the resulting triple's warrant traces to the source sentence rather than to a model's say-so.

The being encountered questions it couldn't answer, found the answers in its own source prose, crystallized them into permanent RDF triples, and used those triples to answer subsequent questions. All without calling a generative model for extraction. We published the full study in Paper 104.

The Gap-Detect-Crystallize-Retrieve Loop

Here's what happens during a live conversation when the being hits a knowledge gap:

1. Gap detection. A student asks about photosynthesis. The being queries its knowledge graph — no match, or confidence too low. There's a gap.

2. Prose lookup. The being checks its Y0 layer — the raw source documents it has studied. A lightweight LLM pass confirms whether the source prose can answer this question and identifies the relevant passage. The LLM is a search assistant here, not a knowledge source.

3. Crystallization. Deterministic pattern extraction converts the source prose into subject-predicate-object triples. No generative model. Domain-specific extraction patterns — loaded from config, not hardcoded — pull structured knowledge from the text. 97.6% extraction precision with zero LLM calls.

4. Retrieval. The newly crystallized triple is committed to the graph with full provenance. Next time someone asks about photosynthesis, the being answers from the graph in milliseconds — no LLM, no gap.

This loop runs during conversation. The being learns while it talks.

Why Deterministic Extraction Matters

The obvious approach to knowledge extraction is: ask the LLM to extract triples from the text. We explicitly rejected this.

If you use an LLM to extract knowledge, you're baking hallucination risk into your knowledge graph. The LLM might misread a passage, add information that isn't there, or conflate two entities. Once that's stored as a triple, every subsequent query that hits it returns a hallucination — but with the full authority of "the knowledge graph said so."

Our extraction uses deterministic patterns. A medical being has patterns like "if the text says 'X is contraindicated in Y', extract (X, contraindicated_in, Y)." These patterns are domain-specific, loaded from config, and validated against the ontology. The result: 97.6% precision, with no generative model authoring any part of the triple.

There is a floor underneath this that matters more than the precision number. Knowledge produced this way is stamped with how it was produced, and a crystallized triple is barred from the system's highest evidential tier no matter how good the extraction gets. It can be cited; it cannot be treated as proven. The rule holds even when the extraction is fully deterministic, because determinism over a passage an LLM selected is not the same as determinism over a passage a human wrote — and a system that cannot tell those apart is one guess away from laundering one into the other.

The 2.4% error rate comes from ambiguous phrasing in source text, not from model confabulation. Those failures are detectable and fixable.

The 8-Hour Run

We ran a being autonomously for 8 hours in a tutoring scenario with a human student. The numbers:

The being started with gaps. As the session progressed, questions that were previously unanswerable became answerable. Not because we fine-tuned a model or updated a prompt — because the knowledge graph grew from source prose, permanently.

The key metric is the zero. Once knowledge is crystallized, retrieving it requires zero generative inference. The graph answers directly. That's milliseconds per query, no GPU, no API cost, no hallucination risk.

Learning From Sources, Not From Self

This is the design choice that matters most: the being learns from source documents, not from its own output.

Every triple traces back to a specific passage in the being's library. If the library doesn't have the answer, no knowledge is created. The being says "I don't know" — and that's the correct behavior.

We've seen systems that let AI agents learn from their own conversational output. That's how you get epistemic drift — the agent gradually becomes more confident about things it made up, because its past confident statements become "sources." It's the AI equivalent of citing yourself.

NuSy crystallization only goes one direction: source prose → structured knowledge → graph. Never the reverse. The graph grows, but only from verified, human-authored source material.

What This Enables

A being that learns during conversation is fundamentally different from a chatbot with memory. It's not recalling past conversations — it's converting source knowledge into permanent, queryable, provenance-tracked structure in real time.

For domains like clinical decision support, tutoring, and technical assistance, this means the system gets better at its job the more you use it — and you can audit exactly how it got better, because every new triple has a chain of provenance back to source text.

Read the full paper: Continuous Learning in Neurosymbolic AI — Zenodo