Catching Fish in the Ocean of Knowledge

When someone asks us to build a NuSy being for a new domain — say, a clinical guideline specialist for diabetes management — the process looks nothing like training a language model. There's no bulk dataset. No GPU cluster running for weeks. No loss curves to watch.

Instead, we go fishing.

The Ocean

Every domain has an ocean of knowledge: clinical guidelines, textbooks, research papers, expert opinions, regulatory documents, reference implementations. Raw, unstructured, sometimes contradictory, always vast. This is the sea.

A language model would drink the ocean whole — tokenize everything, compress it into weights, and hope the important patterns survive. We don't. We fish selectively, because in neurosymbolic AI, the quality of what you catch matters more than the volume of water you process.

The Ten-Step Expedition

Here's how a NuSy being gets built, from first conversation to deployed service:

Step 1: Ask the Boat Builder

We sit down with the domain expert — the "boat builder" — and ask what this being needs to do. Not in vague terms. In specific, testable terms.

For a diabetes guideline specialist: "Given a patient's lab values, current medications, and comorbidities, recommend medication adjustments traceable to ADA 2026 guidelines." That's the charter. Everything else follows from it.

Step 2: Find the Raw Materials

We identify the knowledge sources. For diabetes: ADA Standards of Care, FDA prescribing information, pharmacology textbooks, FHIR clinical profiles, published meta-analyses. These are the fish in the sea — and we map them before we cast a line.

Step 3: Extract Structured Knowledge

This is where NuSy diverges from everything else in the industry. Our extraction pipeline reads source documents and produces RDF triples with full provenance:

<metformin> indicated_for <type_2_diabetes>
    source: "ADA Standards of Care 2026, Section 9.2"
    confidence: 0.97
    extracted_from: "corpus/guidelines/ada_2026.md"
    extraction_method: "pattern_crystallization_v2"

Every fact knows where it came from. Every relationship carries its evidence. This is the fish — not raw text, but structured knowledge with a chain of custody.

Step 4: Index for Referenceability

The extracted knowledge gets indexed for fast retrieval. Semantic embeddings for fuzzy matching. SPARQL endpoints for precise queries. Fractal indices for O(1) concept lookup. These are the currents and winds — they make navigation possible.

Step 5: Load Ontologies

Before the knowledge graph can reason, it needs a shared vocabulary. What's a "medication"? What's a "contraindication"? What relationships exist between "diagnosis" and "treatment"? Ontologies are the maps and charts — without them, the being can't tell the difference between a reef and a shipping lane.

Step 6: Build the Knowledge Graph

Now we persist. The triples go into the being's unified knowledge graph — a seven-layer structure (Y0 through Y6) where raw sources, extracted concepts, episodic memories, and metacognitive assessments all coexist in a single queryable graph.

This is the boat. Everything else rides on it.

Step 7: Validate

Here's where most knowledge engineering stops and we keep going. The validation stage generates behavior-driven tests from the domain specification:

Scenario: Metformin contraindication in renal failure
  Given a patient with eGFR < 30
  When the being is asked about metformin initiation
  Then the being should recommend against initiation
  And the recommendation should cite FDA prescribing information
  And the confidence should be >= 0.95

If the being can't pass these tests, it hasn't caught enough fish. Back to sea.

Step 8: Orchestrate

An orchestrator runs extraction and validation in a loop: extract knowledge, test it, identify gaps, extract more, test again. This continues until the behavior tests pass with acceptable coverage. The being learns iteratively, not in a single bulk pass.

In our experience, this takes hours — not days or weeks. Paper 113 showed that once a domain's knowledge is crystallized, transferring it to a new being takes 0.0006 seconds. The first expedition is expensive. Every one after is nearly free.

Step 9: Deploy the Catch

The result is a being with a validated knowledge graph and a set of MCP services. An EHR sends a FHIR patient bundle. The being returns a medication recommendation with full provenance — every claim traceable to its source, every confidence score auditable.

Step 10: Return to Shore

The service runs. Usage metrics come in. The being tracks which questions it can answer confidently, which ones fall below threshold, and which ones reveal gaps in its knowledge graph. This feeds the next expedition.

The Numbers

After two thousand expeditions, here's what we know about the fishing:

What the Crew Looks Like

No one fishes alone. Every expedition has a crew:

The AI agents are themselves NuSy beings — using the same Y-layer architecture, the same provenance tracking, the same LEIB principles. They coordinate through a shared kanban board and NATS messaging. They disagree, escalate, and learn.

When Santiago said "I wish the boy were with me," he was expressing the fundamental truth of hard work: it goes better with a crew. We built the crew.

Why Not Just Use RAG?

Retrieval-Augmented Generation is the obvious alternative. Chunk your documents, embed them, retrieve relevant chunks at query time, pass them to an LLM. It works. RAG gets 99.3% answer coverage on a known corpus versus our crystallization's 52.2%.

So why do we go fishing instead?

Because RAG doesn't learn. Every query costs an LLM call. Nothing persists. The system can't tell you what it knows or doesn't know. There's no provenance chain from answer to source. And when the LLM hallucinates in the retrieved context, there's no contradiction detection to catch it.

Crystallization trades coverage for permanence. The 52.2% that makes it into the symbolic graph is queryable without any LLM, traceable to source, and available forever at sub-millisecond latency. The other 47.8% falls through to LLM fallback — and when it does, the system can crystallize the answer, so next time it won't need the LLM at all.

RAG is renting fish from the ocean. Crystallization is catching them and bringing them home.

Previous: Teaching AI to Be Good Before Teaching It to Be Smart | Next: Publishing Our Homework