Fork Seed is a generalised replication mechanism.

I Definition · four invariants

A pattern is a replication mechanism when it satisfies all four:

II The peer group

The honest company a replication mechanism keeps. The list is not exhaustive; Fork Seed belongs in it because it satisfies the four invariants — not because it is grand.

III What's actually new

Three of those invariants have overlapping prior art. The fourth difference is where Fork Seed does something the others do not.

git replicates source. Docker replicates environments. PDF replicates documents. None of them replicate the build engine inside the artifact. A git clone gives you the code but not the compiler. A Docker pull gives you the running environment but not the Dockerfile + registry + CI that produced it. A PDF gives you the document but not the typesetter.

Fork Seed ships substrate + instance + the machinery to produce more instances in one file. The closest prior art is the Smalltalk image (Xerox PARC, 1976-80): a memory snapshot containing the running system, the dev tools, and the ability to fork into a new image. Smalltalk needed a VM. Fork Seed treats the open web as the VM. That is the only meaningful difference, and it is the difference that makes it travel.

So the precise claim is not "Fork Seed is unprecedented." It is: Fork Seed is the Smalltalk image rendered in the substrate that won (the browser). The substrate that is already installed on every device on Earth.

IV The SEED schema

A conforming seed exports a single top-level constant. Minimum shape:

const SEED_DEFAULT = {
  manifest: {
    name: 'hr-firm',                // kebab-case identity
    vertical: 'HR · payroll · employment',
    version: '2.0.0',
    prime: 1049,                  // spine-clean mod 127 (constraints private)
    level: 0,                     // 0 = vertical, 1 = domain, 2 = behaviour…
    meshChannel: 'fall-hr',        // BroadcastChannel name
    bundleRoles: ['anchor', 'onboard', 'paper', 'practice'],
    licence: 'MIT',
    seal: '◊·κ=1'
  },
  baseTools: [...],               // the wedge contents (level 0) or frameworks (level 1+)
  buildPromptSystem: `...`          // system prompt for the cascade
};

Adjacent invariants the seed file must also contain (not part of SEED_DEFAULT itself, but mandatory for the seed to satisfy the four invariants):

• The build engine — an 8-provider cascade (WebLLM → ollama / LM Studio → Groq / OpenRouter / Google / Cerebras → Anthropic) that turns a plain-English description into a working tool
• The Fork Seed packager — a jsLiteral serializer that rewrites SEED_DEFAULT in place and downloads the mutated child as a new HTML file
• The audit chain — prevHash + SHA-256 on every state mutation, head persisted in IDB
• The mesh layer — a per-vertical BroadcastChannel for local sync plus a global fall-signal channel for hello-broadcast on boot
• The sovereignty contract — one HTML file, IDB primary, MIT, no telemetry, no external dependencies (the WebLLM ESM import is the one allowed exception)

V The fork protocol

How a parent seed produces a child seed. The protocol is six steps and runs entirely in the browser, no server.

VI Five consequences of being a replication mechanism

1 · The estate is a population, not a portfolio

A portfolio has products. A population has frequencies. The 11 verticals shipped today are the first generation. What gets forked the most over the next 12 months is what survives. The metric stops being "did I ship X" and becomes "what is the distribution of forks across the lineage". That is biology, not retail.

2 · Derivatives are not owned

MIT + self-contained + no phone-home means anyone with a browser can fork a seed for their local context and ship it as theirs. That is not a flaw — it is the property that makes it a replication mechanism rather than a license-controlled product. Wealth accrues to the fitness of the substrate to keep being forked, not to the lineage's root.

3 · Mutation is at the source, not the binary

A binary-only replicator (Docker image, compiled exe) can be re-distributed but not edited. A source-level replicator (git repo, your seed) can be mutated. Mutation is what lets a pattern adapt to substrates it was never designed for. Compliance Seed → Education Seed → Civic Seed is the natural drift any source-level replicator undergoes once released.

4 · The audit chain is mitochondrial DNA

Every mutation hashes its predecessor. Lineage is verifiable without a central authority. Two forks that claim common ancestry can prove it cryptographically. Small property, structurally important: traceable lineage in a system with no central registry.

5 · The build engine + cascade is the ribosome

A genome is inert without the machinery that transcribes it into proteins. A seed is inert without the cascade that turns "build me a tool that does X" into a working HTML file. Both genome and seed are declarative; both ribosome and cascade are mechanical; both organisms and seeds carry both inside the daughter after replication.

VII Reference implementations

The seeds below conform to this spec. Each is a single HTML file containing SEED_DEFAULT + the four adjacent invariants. Save any of them; you have the spec running in your hand.

See the full estate (11 vertical seeds + 3 root seeds across L1/L2/L3 + sovereignty tools) →

VIII What this is not

• Not a framework. Frameworks demand you write code in their idioms. A seed is a single HTML file; you can read every line.
• Not a platform. Platforms own the substrate. The substrate Fork Seed runs on is the open web; no one owns that.
• Not a no-code tool. The build engine generates code that is itself the deliverable. The cascade is a code-writer, not a code-hider.
• Not a SaaS. There is no server. There is not subscription-based. There is no remote state. Save the file; you have it forever.
• Not a portfolio. A portfolio has products. The estate has a population — see Consequence 1.

IX What is intentionally out of scope

The four invariants impose a hard envelope. Within it, the mechanism is sufficient. Beyond it, a different mechanism is required.

• Multi-actor governance — voting between owners requires P2P, not same-origin BroadcastChannel. This is the level-4 frontier (a Village seed, a DAO seed). It needs a mesh-beyond-origin substrate, which the existing primitive does not provide.
• Asset custody — wallets are a security boundary the IDB envelope does not cross.
• Stateful long-running agents — context windows longer than a tab can hold need WebWorkers + IDB transcript stores. The pattern admits this extension but does not force it.
• Real-time multi-party coordination — sub-second cross-party sync needs WebRTC. Same envelope-break as governance.

The honest map: levels 0-3 (vertical → domain → behaviour → agent) ship inside this spec. Levels 4-5 (institution → civilisation) require an additional spec layer above this one. That layer exists in adjacent work and is not specified here.

X How to write a conforming seed

The shortest path: