Technology
The genome technology
A genome is a structured, versioned memory of how one AI agent should work for one business. It is written into the agent’s prompt. It does not change the model.
What a genome is
A genome belongs to one agent in one workspace. It is a short list of plain-language instructions called genes. Examples: “Keep replies under 60 words.” “End every invoice note with the GSTIN line.” “Never open an email with a greeting.”
The platform does not store the finished genome. It stores a log of events and rebuilds the genome from the log when it is needed. An event is a customer edit, a thumbs-down, or a rule an administrator set. Events are only ever added to the end of the log. Before each model call, the genes that apply to the task are written as one block of text and placed in the agent’s system prompt.
The definition used throughout this site:
The genome is a per-tenant, structured, versioned, append-only memory and preference layer that is compiled into the prompt of an LLM agent. It does not retrain or fine-tune model weights.
- Per tenant. One customer’s genome is never read for, or learned into, another customer’s.
- Structured. Each gene has a kind, a stratum, a strength between 0 and 1, a source and a list of references to where it came from.
- Versioned. The version is the number of the last event applied. Each run records the version it used.
- Append-only. A rollback adds an event. It does not delete history.
- Governed. Layers decide who may change what. Customer text is screened. Proposals wait for a person. Erasure removes what was learned from a person.
It does not train the model
No retraining, no fine-tuning, no change to model weights
All of the genome’s effect comes from text in the prompt. The model that reads it is the same model that would read any other prompt. Some model providers offer tuning of their hosted models. The platform behind this technology does not use it.
This is a design choice with a price and a benefit. The price: a model can still ignore text in its prompt, so a gene is an instruction, not a rule the model must obey. The benefit: text can be read, edited, rolled back and erased. Changes to model weights offer none of those for one customer’s data.
The problem it addresses
An agent that does business tasks gets corrections. The customer asks for a shorter summary, or for a tax line at the end of every invoice note. If the agent forgets each correction when the run ends, the customer repeats it on the next run, and the one after that. The cost is the customer’s time, and it grows with the number of agents and tasks.
Hosted language models take text in and give text out. So “remember what this customer prefers” has to be built around the model. The simplest version saves past feedback and pastes some of it into the prompt. That works for a few messages, then it gets worse. The same complaint is saved many times. A small retrieval budget fills with near-duplicates. Nothing records whether a saved statement later helped or hurt.
The genome is one structured answer to this. It merges repeated feedback into one gene, tracks whether each gene helped, keeps a record a customer can inspect, roll back and erase, and bounds how much prompt it uses. Learning preferences from feedback and keeping them as text in a prompt is not new. The research on this is cited on the Research page. What the genome adds is the governed layer around that idea.
How it works: one loop
The steps in words
- Event log. Every change is added to the end of a log: a customer edit, feedback, a rule an administrator set. Nothing is overwritten.
- Fold. The log is replayed in order to produce the current genome. The replay reads no clock, so the same log always gives the same genome.
- Genome. Genes with strengths, plus a few recent observations that are marked as tentative.
- Compile. The genes that apply to this task are chosen within a size budget and written as text in the format for the target model.
- Prompt section. The text goes into the system prompt, after the agent’s base instructions.
- Model call. The model reads the prompt and writes an output. Its weights are unchanged.
- Customer reaction. The customer accepts, edits or rejects the output.
- New events. The reaction is recorded as events in the log.
The last step leads back to the first: the reaction becomes new events in the same log.
Genes come from several places, and a stronger source wins a conflict. The next section shows the order. The topic pages go into each part: genes and strata, learning, identity and governance.
The layers
Genes live in eight strata. A gene can override only genes in a stratum below its own. The first three strata are protected: they are never dropped to make the prompt fit its size budget.
The strata in words
| # | Stratum | Who writes it | What it holds | In an AGF file | Status |
|---|---|---|---|---|---|
| 1 | kernel | The agent’s author. Built in. | The Identity Core and other non-negotiable rules. Never overridden and never dropped to fit the size budget. | Yes, as the read-only germline. An importer never copies it. | Built, flag off by default G19 |
| 2 | org | Workspace administrators. | Workspace policy for every agent. At most 20 genes. Never dropped to fit the size budget. | Yes | Built, flag off by default G24 |
| 3 | team | Workspace administrators. | Policy for one team. At most 10 genes per team. A run applies at most 3 teams of the person who started it. | Yes | Built, flag off by default G26 |
| 4 | customer | The customer, for one agent. | What the customer stated or confirmed. Its strength never moves. Two contradictions flag it for the customer to review. | Yes | Built, flag off by default G11 |
| 5 | shared | Workspace administrators. | Knowledge served to every agent in the workspace. One agent can opt out of a gene. | Yes | Built, flag off by default G27 |
| 6 | user | One member, for their own runs. | Style and trait genes only, written by the member to their own layer. | Yes, only when the person asks for it. | Built, flag off by default G24 |
| 7 | learned | Inferred from the customer’s edits and feedback. | The only stratum whose strength moves, and the only one whose genes retire themselves. | Yes, but an importer turns these into proposals, not live genes. | Built, flag off by default G12 |
| 8 | species | The base agent. | Default genes that come with the agent type, before any workspace event. | No. Never exported. | Built and tested G01 |
In an AGF genome file the kernel appears as a read-only “germline”, and the other layers appear as a list of layers. See the AGF summary.
What is built today
Every capability on this site carries one of five status tags. The tags come from the status matrix of the
Agent Genome book, which lists 110 capabilities. The tags describe the IntelliNix reference implementation at
commit 0575676 (2026-10-24).
- Built, flag off by default
- Code and committed tests exist. The capability reaches a run only when a runtime feature flag is switched on, and a missing flag counts as off.
- Built and tested
- Code and committed tests exist, and no genome feature flag gates it. Examples: a pure library, a schema, an SDK, erasure.
- Measured
- A number exists in a recorded result file. Only the three GenomeBench run sets qualify, and all of them are simulations.
- Specified, not built
- Written down in a design, but the code does not exist yet.
- Research direction
- An idea that is not yet a planned task. It may turn out not to work.
What “tested” does and does not mean
“Tested” means committed tests exercise the code. It does not mean a continuous-integration run was green. When the matrix was written, no CI run existed for the baseline commit, and the runs for its neighbouring commits had failed or were still going. The causes were not inspected.
Nixtra the website is a separate project. It gives you the genome file format, a builder that runs in your browser, and these docs. The engine that learns, consolidates and compiles is in the IntelliNix platform, where most genome features are switched off unless an operator turns them on.
| Group | Status and what it covers |
|---|---|
| Genes, strata, event log, fold, rollback |
|
| Learning rule |
|
| Running an agent with a genome |
|
| Identity and the seal |
|
| Layers, immunity, review |
|
| Lineage and erasure |
|
| Format, APIs and SDKs |
|
| Benchmark |
|
| Beyond Genome 2.0 |
|
Topics
-
Genes and strata
What a gene is, the eight strata, who may write each one, and how a gene reaches the prompt.
-
Learning
Observations, nightly consolidation, and the rule that moves a gene’s strength.
-
Identity
The Identity Core, the purpose guard and the seal that protect what an agent is for.
-
Governance
Heredity layers, immunity, quarantine and review, erasure, lineage and audit.
-
Portability
The AGF file format, dialects for different models, MCP, REST and the SDKs.
-
Evaluation
GenomeBench in plain language, with its caveats.
-
Models
Why the genome is model-independent by design, and what has not been tested.
-
Future
What remains of Genome 2.0 and proposed Genome 3.0 directions, all marked Research direction.
To use the format, build a genome in your browser, read the docs, or see the measured results and their limits.