Anatomy of a Seed

What a Seed actually is

A Seed is not a chatbot and not a fine-tune. It's a small, self-contained intelligence unit made of four coupled parts: a verified knowledge graph, a four-layer memory system, a set of autonomous graph agents, and a Tiny LLM distilled from everything the graph already knows. Together they form a system that ingests, verifies, remembers, reasons, and — critically — forgets, without ever needing to retrain a foundation model.

The Seed Core coordinates all four. When you ask a question, the Core plans the reasoning, pulls facts from the graph, checks them against memory, and only then hands the question to the Tiny LLM for phrasing. The model is never the source of truth. The graph is.

Stage 1 — Ingest

Every Seed starts empty. You feed it URLs, documents, pasted text, or agent transcripts. Ingestion normalises the input into a stream of candidate passages, timestamps them, and records their origin. Provenance is a first-class field: every fact that ever enters a Seed can be traced back to the exact chunk it came from.

This is also where SSRF guards, size caps, and per-plan quotas apply. Free Seeds are capped so runaway crawls never surprise you; owned Seeds are effectively unlimited.

Stage 2 — Extract

An extraction pass turns each passage into atomic facts — single, self-contained claims like "Battery X uses lithium iron phosphate chemistry". Atomicity matters: a fact you can't state in one sentence is a fact you can't verify, and a fact you can't verify is a fact that shouldn't enter memory.

Each candidate fact carries a topic tag, a confidence score, and a short source excerpt. Nothing is stored yet.

Stage 3 — Verify

Verification is where Seedthink diverges from ordinary RAG. A candidate fact is checked for: confidence from the extractor, agreement with the passage it came from, agreement with facts already in the Seed, and — for owned Seeds — cross-model consensus. A fact only becomes verified when it clears the threshold. Below-threshold facts are kept as candidates so the Verify workspace can surface them for you to promote, edit, or reject.

When two verified facts contradict, the older one is not silently overwritten — it is versioned, marked superseded, and kept for audit. This is the mechanism behind The Forget Principle.

Stage 4 — Embed & Deduplicate

Every verified fact is embedded into a shared vector space. Before it lands, the Core runs a nearest-neighbour search against the Seed's existing memory. If a very similar fact already exists, the new confidence is merged into the old row instead of creating a duplicate. Repetition becomes evidence, not clutter.

Stage 5 — Graph

Facts don't just sit in a vector store. Entity resolution ties mentions of the same thing together, and edge typing records how facts relate — causes, contradicts, part_of, derived_from. What you end up with is a real knowledge graph, not a bag of chunks.

Retrieval then becomes traversal. When you ask a multi-hop question, the Core walks edges rather than hoping cosine similarity found the right passage. This is why Seeds resist hallucination on questions where vector-only RAG collapses.

Stage 6 — Four-layer memory

The graph is long-term semantic memory. On top of it sit three more layers the Core juggles per conversation:

• Working memory — the current turn's context, retrieved facts, and scratchpad reasoning.
• Episodic memory — the ordered history of what this Seed has done and been told, so it can reference "the paper we discussed on Tuesday".
• Semantic memory — the verified graph itself.
• Model memory — what the Tiny LLM has already internalised through distillation, so common patterns don't need to be re-retrieved on every call.

Reasoning — how a question becomes an answer

When a question arrives, the Intelligence Router picks the cheapest path that can answer it. Simple recall stays in the Tiny LLM. Anything requiring facts hits the graph first: the Core embeds the question, retrieves grounding facts above a similarity threshold, walks the graph for multi-hop context, and only then asks the model to phrase the answer using those facts.

Every response carries a trace: which facts were used, which edges were traversed, which memory layer contributed. That trace is what makes a Seed's reasoning auditable — and what makes the Reasoning Rewards system able to pay contributors when their facts are used.

Distillation — how the model actually grows

Periodically, the Distillation Engine takes the highest-confidence slice of a Seed's graph and turns it into training pairs for a small, specialised model. This is the "Tiny LLM" — a compact transformer that inherits the Seed's domain fluency without carrying the whole graph in weights.

Because the base is small, distillation is cheap and repeatable. A growing Seed can ship a new model version every week; the graph remains the source of truth, and the model is a fast, portable projection of it. Ship the model, own the graph.

Forgetting — the release valve

Facts decay unless something reinforces them: fresh sources, a usage hit at query time, or a manual re-verification. Facts that fall below the retention threshold are marked archived — hidden from reasoning, kept for audit. When new information contradicts an old fact, the old one is superseded rather than deleted. Nothing is ever silently lost, and the current version of the graph never carries stale claims into reasoning.

The autonomous layer — Graph Agents

While you sleep, three background agents keep the Seed healthy:

• Gap Agent — spots open questions the graph can't answer yet and surfaces them for you to teach.
• Contradiction Agent — flags newly-ingested facts that conflict with existing ones, so you can adjudicate.
• Quality Agent — recomputes confidence, trims orphan nodes, and schedules the next distillation.

These agents are why a Seed keeps improving even on days you don't touch it.

Measuring it — VII, KRS, KCI

A Seed's growth is quantified continuously. The Verified Intelligence Index (VII) tracks how much of the graph is verified vs. candidate. The Knowledge Retention Score (KRS) measures how well distilled models recall facts under adversarial phrasing. The Knowledge Coverage Index (KCI) tracks how much of the Seed's stated domain is actually populated. Together they replace vibes with numbers — see Measuring Verified Intelligence.

What you do, end to end

The Build Intelligence journey inside every Seed maps 1:1 to the pipeline above. You plant a Seed, ingest knowledge, verify what came in, teach the gaps, review reasoning traces, distill a model version, and finally publish or query it — via the web chat, the REST API, or an MCP-connected agent like Claude or ChatGPT.

That's the whole loop. Ingest, verify, graph, distill, reason, forget, improve. Every pass makes the next one cheaper and the answers sharper. That is what we mean by the intelligence that grows.