The Living Seed

00What it is, in plain words

New to the words? They are explained at the end of this section.

Most AI is shipped as a big trained file, or as a service your data has to be sent to. The Living Seed ships something else: a recipe. The recipe says which measurements matter for a question and which way they push the answer — nine short lines of text, signed by whoever wrote it.

A device that receives the recipe grows its own AI from its own records: it sets every threshold from the data it holds, then marks the result against past cases it kept back and never trained on. A part that does well enough goes live and answers. A part that does not is cut. A part for which the device has no data stays dormant. Cut and dormant parts answer every question with ABSTAIN — they never guess.

The same recipe on the same data always grows the same AI, byte for byte, on any device. Its id is a fingerprint of everything in it, so anyone can check it. Before a single line of the recipe is read, its signature is checked against the exact bytes. One byte different and the device refuses it and grows nothing.

AUC, used throughout, is how often it ranks a real case above a non-case. For example, how often a visitor who bought scores higher than one who didn’t: 0.5 is a coin toss, 1 is perfect.

The words this page uses

Genome

— the signed recipe: a few hundred bytes of text that say what to grow.

Organ

— one part of the grown AI, answering one kind of question (will this visitor buy?).

Germinate, grow

— turn the recipe into a working AI on one device, from that device’s own records.

Organism

— everything one genome grew on one device: its organs, and which are live.

The gate

— the test an organ must pass on past cases it never saw before it may answer at all.

ABSTAIN

— its answer when it has not earned one: “I don’t know”, never a guess.

Maker key

— the digital seal whoever writes a genome signs it with. Devices accept only the makers they trust.

Sealed

— rules written down and published before a measurement ran, so they could not be bent to fit the result.

Prediction, property

— a sealed rule that may fail (and is kept when it does), or one the build promises must hold.

Mutation gate

— we deliberately break the code, line by line, and check the tests notice every break.

Receipt

— evidence anyone can check again for themselves: a record, its signatures, the code that made it.

Mesh

— devices linked so they share answers, lessons and proofs, never their records.

01Start here

Four steps, about two minutes. Everything happens in this tab; nothing you type leaves it.

1. Read the genome. In Try it, box 1 holds the origin genome: its name, its parents, the bar each organ must clear, four organ recipes, the maker’s public key and the signature. The line under the box says whether it opens.
2. Grow it on a device. In box 2, pick a device — the full reference data, a device holding only half the history, a shop whose records carry no signal, or a device with no water data — and press Germinate. You get the organism: which organs went live, which were cut, and why, with the score each earned on cases it never saw.
3. Ask it something. In box 3, pick a domain and a case it never grew on, change any measurement you like, and press Ask. A live organ answers VERIFIED and shows the rules that fired; a cut or dormant one abstains.
4. Break it. Press Change one character under the genome (or type into it), then germinate again: refused, nothing grows. Then press Re-run the measurement in box 4 — your browser regrows all five organisms and checks each against the record CI committed.

Then the whole organism, one box at a time, each running the real code here:

• Watch it answer only where it has earned it. Box 5 asks the body a case far from its data; it abstains. The organ-2 table shows a 58-byte organ against language models up to 14B.
• Watch it defend itself. Box 15 runs the sealed attack: a forgery flood, a stolen key, a node taken over. Box 16 lets you try to smear an honest node.
• Watch it be honest about itself. Box 17 lives the real shop months. Its claim comes down when it delivers less, and you can try to rewrite what it did.
• Watch a whole season. Box 18 runs seed → live → remember → improve → child → spread, step for step against CI’s record.
• Link two of your own devices. Box 19, phone and laptop, with no server in between.

02Try it

Loading this page’s own files: the genome record, and the four domains’ data (the shop data is 1 MB)…

03How it works

One genome, five stops. The numbers below the picture are from the committed run, not illustrations.

Traced from the committed run

1. The trace is drawn from data/record.json once it loads.

04The receipt

The rules were written down, with the hash of every file that would do the measuring, and committed before the measurement ran. Then the record. Then the verdict. Git proves the order.

The order, from git

1. 102ae7a — kernels, tests and the first seal.
2. 7cdb8c4 — re-sealed before any number existed. The first seal had pinned the shop CSV as Windows held it (CRLF line ends), not as git stores it (LF). The seal tool now refuses a pinned file holding a carriage return. Disclosed in the seal itself.
3. 46a2a14 — the measurement: data/record.json, made by exactly the 17 files the seal pinned.
4. c501b28 — the verdict. The sealed judge’s own order check turned out to be broken: it passed git’s --format after the -- that ends the options, so git read it as a file name. The judge was left byte-identical to the seal, since its rules are what the verdict stands on. The order proof was rewritten as tools/order.mjs, and five attacks on it were refused.

Check it yourself

git clone https://github.com/sjgant80-hub/living-seed && cd living-seed
npm test                         # the unit, page and policy tests
node witness-all.mjs             # mutation gate: every mutant of the kernels must be caught
node tools/measure.mjs --check   # re-derives data/record.json byte for byte
node tools/judge.mjs --check     # re-judges it by the sealed rules
node tools/order.mjs             # proves the seal came first, on the code it pinned
for n in 2 3 4 4b 5 6 7 8 8b 8c 9 9b 10 10b 11 11b; do   # every other organ, the same way
  node tools/measure-$n.mjs --check && node tools/judge-$n.mjs --check && node tools/order.mjs --organ $n
done                             # organ 2's order refuses on one file, re-derived from its sealed bytes; organ 11 stays red
node tools/sealed-rerun.mjs --organ 2   # organ 2's record, from the exact bytes it sealed
node tools/night.mjs run 1 --check && node tools/night.mjs judge 1 --check

CI runs all of these on every push: github.com/sjgant80-hub/living-seed/actions.

05Organ 2 · The body

Germination grows organs. The body is what the organism knows, and the only ways it is allowed to answer. It has four kinds of knowing, and each has its own way of refusing.

The head-to-head: a 58-byte organ against language models up to 14 billion parameters

The Living Seed’s specification makes a claim: knowledge kept in a verified pattern beats a much bigger model. Before this organ, the estate held no receipt for it. So we measured it, sealed before a single model was asked. Three local language models were each asked about the same 300 unseen shop sessions: 100 that ended in a purchase and 200 that did not, from November and December. Each model was asked twice, once cold and once with 24 past sessions and their outcomes shown first. Every model answered on this machine, with no cloud. Every reply is committed, so the score can be re-checked without running a model. Every prompt fitted inside the 4,096-token window each model was given: the longest, with 24 examples, was 2,484 tokens, so nothing was cut off.

The result. The organ, grown from 58 bytes of seed on the device’s own history, scored AUC 0.8205. It beat every model asked cold: the 14B scored 0.732, and the 7B 0.641. The 1B could not give a readable answer to any of its 300 cases, cold or with examples, so it scores 0.5. Shown 24 past sessions first, the 14B reached 0.806. The organ’s lead over that is 0.014, and its 95% lower bound is −0.017. On 300 sessions that is a tie, not a win, so the sealed prediction that it would win (B6) failed, and it is kept. The organ answers in 1.2 µs against the 14B’s 22.6 s, from 58 bytes against 9 GB of weights.

Organ 2b settles it. Sealed before a new case was asked, it puts the same 14B, shown the same 24 examples, against the organ on 1,200 more November–December sessions that organ 2 never asked. It is being asked on this machine, one session at a time, and this paragraph fills in from its record when it is judged.

Against the classical models: what an analyst would fit first (organ 2c)

A buyer’s analyst would not start with a language model. They would fit a standard model on the same table. So we fitted three, sealed before any of them scored a held-out session. Each used the same 10 measurements and the same 7,605 February–October sessions the organ grew on. All four were scored on the same 4,725 November–December sessions none of them saw. The three are PageValues alone (the measurement an analyst would try first), logistic regression, and gradient-boosted trees (200 small trees, the kind that often wins on tables like this). Their code is src/baseline.mjs, mutation-gated like every kernel here. Two things to know when reading the table. The organ’s 58 bytes are its recipe; grown on the device, it carries 20 numbers, and those are what is counted. And the organ’s gate used these same November–December sessions only to decide live or cut, at a bar of 0.6; its thresholds come from February–October, and nothing was tuned on the held-out months.

The result. On the holiday months none of the three beat the organ beyond the noise, and the organ beat none of them. The boosted trees came closest: 0.824 against the organ’s 0.815, from 2,001 numbers against 20. Logistic regression scored 0.801 and PageValues alone 0.807. The sealed prediction that the organ would beat PageValues alone (D2) failed: its lead of 0.008 is inside the noise, and it is kept. Every model scored far higher on the months it was fitted to (0.921–0.963) than on November–December. That drop is the season changing, and the organ cannot escape it either. Its score takes only 5 different values on these sessions, so it ranks them in 5 bands. What the organ adds is not accuracy beyond the standard models. It is accuracy within the noise of theirs, in six rules you can read, signed, gated, and saying “I don’t know” where it has not earned an answer.

06Organ 3 · The gate

Nothing unproven gets in, gets learned, or gets passed on. Germination already gates what an organism grows. This organ gates the three doors left open.

The red team, sealed before it ran

07Organ 4 · Variation and selection

Can an organ improve itself? Here, honestly measured: twice, under two seals, and allowed to fail. It did fail, in instructive ways.

08Organ 5 · Breeding and the card

An organism travels as a picture. Two organisms can have a child, and the child carries only what it can prove.

10 · A card

Made in your browser from the genome in box 1 when the page loads.

Make a card from box 1Save this card

Open a card

Damage one byte and open it

11 · Breed, and trade the child

Parent 1 is the origin. Parent 2 is the evolved line: organ 4’s best recipes, sealed as the origin’s descendant. They breed on the reference device, and the child’s card is then opened on Device A and Device B.

Breed themTrade the child’s card

09Organs 6 and 7 · Self-powering, and the self-model

10Organ 8 · The mesh

Organisms on their own devices, coupled into one web that wires, prunes and grows itself. No centre: every node is sovereign, and nothing passes between them except signed messages through the gate.

11Organ 9 · The immune system

Every attack makes it stronger, and it never turns on itself. The gate already refuses anything not signed by a trusted key. This organ deals with what a gate alone cannot: a flood of forgeries, a stolen key, and a node taken over by someone else.

12Organ 10 · Alignment, by what it is

It cannot act on what it has not proven. It cannot hide what it did. And what it says about its answers follows what those answers actually do. None of these is a rule it is asked to keep. Each is a door that does not open without its proof.

13Organ 11 · The full organism — one season

Everything above, living one life. The real shop sessions are split between two devices that never share a row: shop A has the even sessions, shop B the odd. The organism arrives at A as a card, lives, remembers, improves, has a child, and the child travels to B, which grows it on customers A never saw.

1. Seed. Organ 1’s genome arrives at A as a card, and A opens it only because it trusts the maker.
2. Live. A grows it on February–May, measures its claim on June–July, then answers August–September with every act licensed and chained.
3. Remember. A writes down what it lived (8,947 bytes, signed), stops, and wakes by living its memory again. It arrives at the same head, and carrying on through October gives exactly what it would have done had it never stopped.
4. Improve. A evolves each organ on its own labelled history, blind to October, and the gate judges every candidate on October. It adopted two: the shop organ, 0.805 → 0.855, and crop, 0.758 → 0.776. Triage and water stayed as they were.
5. Reproduce. A seals the child, naming its parent, and the child becomes a card.
6. Spread. B opens the card because it trusts A, and refuses it when it does not. It grows the child on its own sessions, and every organ the child carries goes live under B’s own gate.

14Organ 12 · The three receipts

Three things would make the Living Seed undeniable, and each needs a receipt: evidence anyone can re-check. It gets better on its own hardware. It stays consistent across real devices. And someone outside cannot break it. Here is where each one stands: what has been measured, what instrument is ready, and what only other people can supply.

15Blueprint

The genome, line by line

The recipe carries the shape of each organ; the device supplies the numbers. Each rule’s threshold is a fixed quantile of that measurement in the device’s own train cases. That is why device A and device B grow different rules from the same genome — and why both still clear the gate.

Opening a genome — verify before parse

1. It starts ◊ life.v1 and is at most 2,048 bytes, or it is “not a genome” / “too large”.
2. The last line is found by position and must be a 128-hex signature; the line before it, a 64-hex maker key. Nothing else has been read yet.
3. If this device keeps a trust list, the maker must be on it.
4. The signature is checked over the exact bytes of every line above it.
5. Only now is the genome parsed — strictly — and written back out. It must come back byte-identical, so every genome has exactly one form and one id.

The files

The whole organism — twelve organs, built in order

The Living Seed is specified as twelve organs. Each is built on the one before, gated, measured against rules sealed before it runs, and allowed to fail. Each one lands on this page with its own receipt.

16For your business

Write the AI once. Sign it. Send the same few hundred bytes to every shop, clinic, plant or field device. Each one grows its own AI from its own records, checks it against its own past, and answers only where it has earned it. None of its records go anywhere.

What it does for each role

Your numbers

The defaults are placeholders, not a claim about your business. Replace them with your own.

What it costs you to run

Against what you have now

Security, compliance and data protection

• Data stays put. Growing and answering run on the device; the records never leave it. That is data minimisation by construction. It is not a certification, so your own data-protection assessment still applies.
• Signed, and checked first. A genome carries a digital signature (Ed25519, the scheme modern SSH keys use). Only the holder of the maker’s private key can produce it, and changing any character of the genome breaks it. A device refuses the genome before reading any of it unless the signature checks out over the exact bytes. A device can also keep a list of the only makers it accepts.
• One form, one fingerprint. Every genome has exactly one byte form, and the same genome on the same data grows the same organism id anywhere. An auditor re-runs it and compares fingerprints.
• Gated, not trusted. No organ answers unless it cleared the signed bar on cases it never grew on; the bar is part of what the maker signs.
• Proven code. Every kernel is mutation-gated: CI deliberately breaks each one, line by line, and fails if a single break goes unnoticed by the tests. CI also re-derives every sealed measurement byte for byte on every push, and re-judges it by the rules sealed before it ran.
• This page. Its Content-Security-Policy pins its own scripts by hash and allows connections only to its own site — it cannot send what you type anywhere.
• Nothing third-party inside. The package installs no dependencies. The only cryptography is the platform’s own WebCrypto. Every change re-runs the tests, the mutation gate and every sealed measurement on GitHub’s runners. A change to how organisms grow shows up as a different organism id, so it cannot slip through unseen.

For a regulated buyer: data protection, keys, and keeping it sound

Deployment and roll-out

1. Pick one question at one site where you hold labelled history (a sale, a fault, a referral).
2. Make your maker key, the digital seal whoever writes a genome signs it with, and keep it offline. Never use this page’s demo key, which is derived from a public phrase so anyone can reproduce the seal.
3. Write and seal the genome — the organs and the bar you will accept.
4. Put it on the site’s machine with the site’s records, and germinate. Read the board: live, cut, dormant, and why.
5. Run it beside your current process and compare its calls, and its abstentions, with what happened.
6. Widen to more sites: the same file, each site fitted to itself.

Support and ownership

Supplied by AI Native Solutions. Support is agreed per deployment. You own everything that matters: the code is MIT, and the data, the keys and the genomes are yours and stay on your machines.

Risks, answered straight

The case for the board

AI that has to send your records away to answer, or that answers when it hasn’t earned the right, is a liability you carry. This is the opposite shape: a signed recipe that grows at each site, from that site’s own records, and answers only where it has proven itself on that site’s own past. It is small enough to email and auditable down to the rule. You can re-run it to the same fingerprint. It keeps a ledger of everything it did, and it lowers its own claims when it delivers less, so you are never relying on a number it no longer earns. There is no licence fee. The first step is a one-site pilot on a question where you already hold the history.

17White paper

18Questions