Skip to content
Spice Rack · the organism
02

the Genome.

the DNA

The DNA. Every cell carries versioned instructions it can read, and rewrite.

no one place enforces the rules

56%

no centralized control layer

Quoted from published research, not counted from our own systems. That is what the dotted ground marks; our own numbers sit on a ruled grid and carry a dated receipt. Attribute as cited.

56% of enterprises surveyed have no centralized control layer between users or agents and the models they call, so there is no common policy enforcement point.

You are renting your AI's brain, and you cannot see inside it.

Today an AI agent's instructions are a prompt you edit in place, with no versions, no audit trail, and a vendor you do not control shaping it. When its behavior changes, you cannot see what changed, who changed it, or how to put it back. The intelligence is real, but how it behaves is a black box.

where today falls short

A prompt is not a version.

You can always retype an instruction. What you cannot do is go back to the version that worked, see exactly what changed between then and now, have someone check a change before it goes live, or take something that works for one team and give it to everyone. So every edit starts from scratch. Every other kind of software your company runs already solved that.

The blueprint

A cell's code, written down.

Every cell runs on a genomeA cell's complete set of DNA, every gene in the full instruction set it inherits and runs on., made of its identity, role, rules, skills, and hooks, each versioned and inherited. Like DNA, it is readable, forkable, and passed on intact, so a cell is never a black box. The diagram below shows a genome composing.

DNA double helix, vintage-treated (sepia, engraving hatch, aged paper)

the answer

Each cell is defined, not hardcoded. Its genome is versioned like software.

A cell's rules, skills, identity, and hooksA rule that fires automatically at a set moment, such as before a write or at the end of a session, so it never depends on someone remembering to run it. are a set of independently versioned packagesOne versioned part of a cell, such as its rules, its skills, its identity, or its hooks. A cell is assembled from several, and each one is updated on its own., each pinnedHeld at one exact version. It cannot move on its own, and when someone does move it, the move is recorded. to one exact version and deployed like software releases by a reconcilerA process that compares what should be true against what is, and fixes the gap, so configuration never quietly drifts.. And the loop closes both ways. A cell can edit its own genome, and that edit can be captured, reviewed, and promoted back into the canonical source of truthThe one copy that counts. Every other copy is expected to match it, and when they disagree, it wins.. Every version is on the record, and a better version can express itself and deploy.

How a genome's versioned config is deployed to the cell and promoted back to the source.
source of truthrulesskillsidentityhooksmaterializesand pins the version🌶️a cellrules7f3a1c9skills9f2a7c4identity7b1e0a3hooksc3d5f80appliedappliedappliedfailedreviewed
source of truthrulesskillsidentityhooksversioned configgit + DB, sharedthe reconcilermaterializes and pinsdeploy🌶️a cellself-editrules7f3a1c9skills9f2a7c4identity7b1e0a3hooksc3d5f80skill deployed: v1 → v1.2recorded releasesappliedappliedappliedfailedapplied and failed, on the recordreviewed

Tap a part of the drawing to read about it.

A cell carries its genome as a stack of versioned packages, and every version is a real pinned revision, not a label. The reconciler materializes that manifest, deploys it to the cell, and every apply lands as a recorded release, applied or failed, on the record. When the cell edits its own package, that change is promoted back up into the canonical source of truth. Package versions here are illustrative of the mechanism; the real totals are in the record below.

more than a prompt

What a genome has that a prompt doesn't.

A prompt is one editable string. A genome is versioned parts, released on the record, and able to improve itself and have the improvement stick.

01

Versioned parts.

!Today A lone agent's instructions are one un-versioned prompt you overwrite in place.

the cell Its brain is a set of versioned packagesOne versioned part of a cell, such as its rules, its skills, its identity, or its hooks. A cell is assembled from several, and each one is updated on its own., rules, skills, identity, and hooksA rule that fires automatically at a set moment, such as before a write or at the end of a session, so it never depends on someone remembering to run it., each pinnedHeld at one exact version. It cannot move on its own, and when someone does move it, the move is recorded. to one exact version. Most run the fleet-wide default; a per-agent override is a deliberate, recorded choice.

10 cells, 2 to 13 packages eachA real count from our own database, shown as proof rather than a claim. It is a dated snapshot, captured Oct 8, 2026.

🌶️a cellrules7f3a1c9skills9f2a7c4identity7b1e0a3hooksc3d5f80one genome, versioned parts🌶️a cellrules7f3a1c9skills9f2a7c4identity7b1e0a3hooksc3d5f80a version is a real pinned commit
02

It deploys, and it tells you when a deploy failed.

!Today A lone agent changes a prompt and hopes; nothing records that anything shipped.

the cell Every apply is a recorded release, and even a failed apply lands on the record instead of vanishing. You can see exactly what shipped, when, and whether it landed.

1,005 releases cut, 991 applied and 14 failedA real count from our own database, shown as proof rather than a claim. It is a dated snapshot, captured Oct 8, 2026.

thereconcilerappliedappliedappliedfailedevery apply is a recorded releasethereconcilerappliedappliedappliedfailedapplied and failed, on the record
03

The self-edit loop closes.

!Today A lone agent cannot improve its own definition and have the improvement stick.

the cell A cell edited its own skill file, the reconcilerA process that compares what should be true against what is, and fixes the gap, so configuration never quietly drifts. caught the change as drift, and it was reviewed and promoted back into the shared source of truthThe one copy that counts. Every other copy is expected to match it, and when they disagree, it wins.. This path is deliberately governed and low-volume, not autonomous mass self-modification.

4 self-edit rows on the recordA real count from our own database, shown as proof rather than a claim. It is a dated snapshot, captured Oct 8, 2026.

a skill🌶️a cella cell edits itself, and it stickssource of truthgit + DB, sharedpromote🌶️a celldrift caught,reviewed, promoted

from our own systems

The genome, versioned today

These are not diagrams of a plan. They are the organism versioning its own definition, with config releases cut and recorded, cells each running a set of versioned packagesOne versioned part of a cell, such as its rules, its skills, its identity, or its hooks. A cell is assembled from several, and each one is updated on its own., and a governed self-edit loop where a cell's own change is captured and promoted back to the source of truthThe one copy that counts. Every other copy is expected to match it, and when they disagree, it wins..

KeyA green value is real, from our own database, as of Oct 8, 2026; in the diagrams, green marks a committed write.

cut, applied, recorded

1,005A real count from our own database, shown as proof rather than a claim. It is a dated snapshot, captured Oct 8, 2026.

config releases cut, applied and failed on the record

  • Releases that reached their cell and applied cleanly.
  • Applies that did not land. They stay on the record rather than being dropped, which is why the two parts sum to every release cut.

a real count from our own database, as of Oct 8, 2026

under the reconciler

10

cells running a versioned genome

the self-edit loop

4

self-edit rows, kept on the record

a cell proposing a change to its own genome, reviewed before it lands

zoom in

Down to a single rule

A cell is defined by its manifestThe list of exactly which package versions a cell should be running. The reconciler reads it and makes the cell match., the list of versioned packagesOne versioned part of a cell, such as its rules, its skills, its identity, or its hooks. A cell is assembled from several, and each one is updated on its own. it runs. Each package is pinnedHeld at one exact version. It cannot move on its own, and when someone does move it, the move is recorded. to one exact version, and the rule files sit in packages of their own. One rule file is the smallest strand of the genome, and a change to it is versioned, reviewed and released like any other piece of software.

  1. a cellone worker in the organism
    The whole plate: Flemming’s 1882 drawings of cells dividing, at plate scale
    ×1
  2. its manifestthe list of versioned packages that define it
    One dividing cell, its chromosomes drawn as dark threads, magnified 2.5 times
    ×2.5
  3. one packagepinned to one exact version
    One of those chromosomes, magnified 8 times
    ×8
  4. one rule filea file of instructions, the smallest strand of the genome
    A stretch of that chromosome, magnified 14 times
    ×14

talk to us

Curious how a layer like this would fit your own records?

Send a note

The self-edit loop is deliberately governed and low-volume.