The Cellular Architecture

The biology of knowledge was the metaphor. This is the executable architecture.

In The Biology of Knowledge article, I used a metaphor comparing how living cell manages it knowledge to characterize four digital assets: data as genome, information as transcriptome, knowledge as proteome, and decisions as metabolome.

That comparison becomes useful when it impacts the way we currently manage digital assets in modern organization. This article therefore makes a narrower, testable claim:

A governed knowledge system should be able to sense a signal, transduce it into a shared language, regulate it before admission, express role-specific answers from canonical state, and adapt by recording decisions that change future answers without rewriting history.

The reference implementation accompanying this article executes that complete loop. Leveraging my experience in the biomedical and drug research and development field, I use a synthetic clinical study (AXION-3) fixture so that every invariant (rules and properties that must remain true regardless of how much data the system contains) can be inspected and tested.

One boundary matters at the outset. This is an architectural analogy, not literal biochemistry. Cells do not normally write external events into DNA, and RDF statements are not molecules. The comparison concerns control, identity, validation, expression, memory, and feedback.

The honest starting point: the Semantic Medallion

The common medallion architecture pattern separates raw, cleaned, and business-ready data into Bronze, Silver, and Gold. The Semantic Medallion strengthens that pattern:

• Bronze lands source data without pretending it is already governed truth.
• Silver structures it and mints stable IRIs for the things being described.
• Gold maps those things to a shared ontology and publishes RDF, with relationships represented in the data rather than hidden in source-specific join code.

This article proposes and tests an extension of the Semantic Medallion architecture, drawing on concepts introduced in The Biology of Knowledge. Semantic transformation is necessary, but it does not by itself create a living control loop. A complete architecture must also define who is allowed to submit a signal, which conditions must be satisfied before a write is accepted, how the current state is derived from recorded history, which consumers are authorized to access each projection, and how decisions alter the system’s future rules and behavior.

The Cellular Architecture keeps the semantic engine and adds those responsibilities.

Cellular behavior	Engineering responsibility
Sense	Enforce the input contract, identity, authorization, and novelty at the boundary.
Transduce	Mint IRIs and map the accepted signal into RDF with explicit provenance.
Regulate	Validate the staged RDF against versioned SHACL constraints before commit.
Express	Compute an authorized projection from canonical state and active policy.
Adapt	Append the decision to history and version the rule that governs later expressions.

The executable path is:

sense -> transduce -> regulate -> commit -> express -> adapt

The four-line mapping step is valuable, but it proves only transduction. The complete loop requires the other operations too.

One holon is one governed RDF Dataset

A holon is a unit that is simultaneously a whole in its own right and a part of a larger whole. Arthur Koestler introduced the term in The Ghost in the Machine (1967); Herbert A. Simon’s “The Architecture of Complexity” supplied the closely related insight that complex systems become workable through stable intermediate forms. For a contemporary semantic-technology treatment, see Kurt Cagle’s introduction (https://inferenceengineer.substack.com/p/holons-an-introduction-127): a holon can preserve its own identity, context, rules, and provenance while remaining composable within a larger holarchy. That is the sense used here: AXION-3 is governed as a coherent whole, but it can also participate as one part of a wider clinical, portfolio, and regulatory system.

The AXION-3 data set is synthetic and not representing a full clinical study. A wider demonstration could represents a full Phase III clinical trial across protocol, operations, clinical data, safety, and statistics. The executable proof below deliberately uses only two subjects, one pre-existing serious adverse event, and one inbound serious adverse event. Volume does not prove the architecture; invariants do.

The AXION-3 holon is represented as one logical RDF Dataset with four named graphs:

Named graph	Responsibility	Write policy
Event	Accepted entities, activities, source records, and provenance.	Append accepted facts and decision events; do not rewrite prior assertions.
Scene	The current queryable state derived from Event.	Replace only by deterministic derivation from Event.
Boundary	SHACL shapes, authorizations, thresholds, and rule versions.	Add a new rule version and supersede the old one; retain both.
Projection	View definitions, policy dependencies, and allowed roles.	Change through governed configuration, not ad hoc query edits.

“Single” here means one identity and consistency boundary, not necessarily one physical server. A distributed production implementation may use several services, but it must preserve the same commit, provenance, and versioning guarantees.

The metaphor can now be stated precisely:

• A ligand is an external payload; not truth.
• A transcript (information) is staged RDF produced from an accepted payload; it is still not truth until it conforms.
• The genome (data) is the governed canonical dataset: Event, Scene, Boundary, and Projection together.
• A protein (knowledge) is an authorized query result. It may be cached, but it is not the authoritative record and must carry enough version information to be reproduced.
• A decision becomes durable only when it returns to Event and, where appropriate, produces a new Boundary rule version.

The inbound pathway: a signal becomes governed truth

The signal

A clinical site reports a serious adverse event through the EDC system or the Safety management system. The raw payload is a signal (so called “ligand” in the Cellular Architecture) presenting itself at the cell membrane boundary:

{
  "event_id": "EVT-015877",
  "ae_id": "AE-04412",
  "subject_id": "AXION3-0002",
  "site_id": "SITE-047",
  "actor_id": "ACTOR-204",
  "source_system": "EDC",
  "term": "Febrile neutropenia",
  "meddra_soc": "Blood and lymphatic system disorders",
  "grade": 3,
  "serious": true,
  "related_to_study_treatment": true,
  "start_date": "2026-05-30",
  "site_awareness_at": "2026-05-31T08:15:00Z",
  "submitted_at": "2026-05-31T13:40:00Z",
  "outcome": "Recovering"
}

The extra fields are not decoration: the event, actor, site, source system, and two timestamps are required to prove identity, authority, provenance, and the illustrative reporting-time rule.

Seriousness and grade are also kept separate. serious: true is a seriousness classification. grade: 3 is severity. This example happens to be both serious and grade 3; one does not imply the other.

Step 1: Sense at the boundary

The membrane/interface receptor performs four kinds of admission control before any RDF reaches the canonical dataset:

1. Contract. Unknown fields are forbidden. Identifiers must match the accepted syntax. Grade must be an integer from 1 through 5. Boolean fields must be actual booleans. Timestamps are ISO-compliant, must include a timezone, use whole-second precision, and appear in chronological order.
2. Identity. AXION3-0002 must already be a randomized subject and must belong to SITE-047.
3. Authority. ACTOR-204 must be an authorized reporter for SITE-047.
4. Novelty. The event IRI and adverse-event IRI must not already exist in Event.

A rejected ligand never mutates Event, Scene, Boundary, or Projection.

The receptor also derives reportingDelaySeconds from the two validated timestamps. That value is not accepted from the source payload, so a sender cannot claim a shorter interval than the timestamps establish.

Step 2: Transduce into RDF

The receptor mints IRIs by percent-encoding the source identifier and appending it to a controlled base. Separate prefixes are used for each path. This matters: a Turtle token such as ax:ae/AE-04412 is not a valid prefixed name because the slash is not an unescaped character in that local part. axae:AE-04412, with the prefix bound to the /ae/ base, is valid.

The tested stOTTR mapping produces this 22-triple transcript:

@prefix axactor: <https://data.disynphia.example/axion3/actor/> .
@prefix axae: <https://data.disynphia.example/axion3/ae/> .
@prefix axevent: <https://data.disynphia.example/axion3/event/> .
@prefix axsite: <https://data.disynphia.example/axion3/site/> .
@prefix axsource: <https://data.disynphia.example/axion3/source-record/> .
@prefix axsub: <https://data.disynphia.example/axion3/subject/> .
@prefix mio: <https://w3id.org/miosis#> .
@prefix prov: <http://www.w3.org/ns/prov#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

axae:AE-04412 a mio:AdverseEvent,
        mio:SeriousAdverseEvent ;
    prov:wasGeneratedBy axevent:EVT-015877 ;
    mio:aboutSubject axsub:AXION3-0002 ;
    mio:ctcaeGrade 3 ;
    mio:meddraSOC "Blood and lymphatic system disorders" ;
    mio:meddraTerm "Febrile neutropenia" ;
    mio:outcome "Recovering" ;
    mio:relatedToTreatment true ;
    mio:serious true ;
    mio:startDate "2026-05-30"^^xsd:date .

axevent:EVT-015877 a prov:Activity,
        mio:ExpeditedSafetyReport ;
    prov:endedAtTime "2026-05-31T13:40:00+00:00"^^xsd:dateTime ;
    prov:used axsource:EDC-AE-04412 ;
    prov:wasAssociatedWith axactor:ACTOR-204 ;
    mio:aboutAdverseEvent axae:AE-04412 ;
    mio:atSite axsite:SITE-047 ;
    mio:reportingDelaySeconds 19500 ;
    mio:siteAwarenessAt "2026-05-31T08:15:00+00:00"^^xsd:dateTime .

axsource:EDC-AE-04412 a mio:SourceRecord ;
    mio:sourceSystem "EDC" .

The adverse event is an entity generated by an activity. The activity is associated with an actor, used a source record, occurred at a site, and carries the relevant times. That is a coherent use of PROV-O; provenance is part of the fact at birth rather than an audit note added later.

The stOTTR template that generated those triples is:

@prefix ottr: <http://ns.ottr.xyz/0.4/> .
@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .
@prefix prov: <http://www.w3.org/ns/prov#> .
@prefix mio:  <https://w3id.org/miosis#> .

mio:SeriousAdverseEventRow [
    ottr:IRI ?ae,
    ottr:IRI ?subject,
    ottr:IRI ?event,
    ottr:IRI ?actor,
    ottr:IRI ?site,
    ottr:IRI ?sourceRecord,
    xsd:string ?sourceSystem,
    xsd:string ?term,
    xsd:string ?soc,
    xsd:integer ?grade,
    xsd:boolean ?serious,
    xsd:boolean ?related,
    xsd:date ?start,
    xsd:dateTime ?awareness,
    xsd:dateTime ?submitted,
    xsd:integer ?delaySeconds,
    xsd:string ?outcome
] :: {
    ottr:Triple(?ae, rdf:type, mio:AdverseEvent),
    ottr:Triple(?ae, rdf:type, mio:SeriousAdverseEvent),
    ottr:Triple(?ae, mio:aboutSubject, ?subject),
    ottr:Triple(?ae, mio:meddraTerm, ?term),
    ottr:Triple(?ae, mio:meddraSOC, ?soc),
    ottr:Triple(?ae, mio:ctcaeGrade, ?grade),
    ottr:Triple(?ae, mio:serious, ?serious),
    ottr:Triple(?ae, mio:relatedToTreatment, ?related),
    ottr:Triple(?ae, mio:startDate, ?start),
    ottr:Triple(?ae, mio:outcome, ?outcome),
    ottr:Triple(?ae, prov:wasGeneratedBy, ?event),

    ottr:Triple(?event, rdf:type, prov:Activity),
    ottr:Triple(?event, rdf:type, mio:ExpeditedSafetyReport),
    ottr:Triple(?event, mio:aboutAdverseEvent, ?ae),
    ottr:Triple(?event, mio:atSite, ?site),
    ottr:Triple(?event, prov:wasAssociatedWith, ?actor),
    ottr:Triple(?event, prov:used, ?sourceRecord),
    ottr:Triple(?event, mio:siteAwarenessAt, ?awareness),
    ottr:Triple(?event, prov:endedAtTime, ?submitted),
    ottr:Triple(?event, mio:reportingDelaySeconds, ?delaySeconds),

    ottr:Triple(?sourceRecord, rdf:type, mio:SourceRecord),
    ottr:Triple(?sourceRecord, mio:sourceSystem, ?sourceSystem)
} .

Once the receptor has created the normalized Polars dataframe (provided by the Polars Python library), the maplib operations are exactly the following (maplib is a software library that converts structured data, such as a Polars DataFrame, into RDF knowledge-graph statements using OTTR templates):

from pathlib import Path
from maplib import Model

STAGING_GRAPH = "https://data.disynphia.example/axion3/graph/staging/EVT-015877"
TEMPLATE_NAME = "mio:SeriousAdverseEventRow"
STOTTR = Path("adverse_event.stottr").read_text(encoding="utf-8")

model = Model()
model.add_template(STOTTR)
model.map(TEMPLATE_NAME, frame, graph=STAGING_GRAPH)
model.write("staged.nt", format="ntriples", graph=STAGING_GRAPH)

frame is the normalized dataframe produced by the tested receptor; its column names match the template arguments. These four calls prove the dataframe-to-RDF transduction. They do not, by themselves, prove admission, validation, commit, authorization, or feedback.

Step 3: Regulate before commit

The transcript remains in a staging graph until it conforms to the Boundary shapes. The illustrative AXION-3 rule says that a serious adverse-event report must be submitted no later than 24 hours after site awareness. It is a test rule for this synthetic trial, not a statement of a universal regulatory deadline.

The shape performs the check it claims to perform:

@prefix mio:  <https://w3id.org/miosis#> .
@prefix prov: <http://www.w3.org/ns/prov#> .
@prefix sh:   <http://www.w3.org/ns/shacl#> .
@prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .

mio:SeriousAdverseEventShape
    a sh:NodeShape ;
    sh:targetClass mio:SeriousAdverseEvent ;
    sh:property [
        sh:path mio:serious ;
        sh:minCount 1 ;
        sh:maxCount 1 ;
        sh:hasValue true
    ] ;
    sh:property [
        sh:path ( prov:wasGeneratedBy mio:reportingDelaySeconds ) ;
        sh:minCount 1 ;
        sh:maxCount 1 ;
        sh:datatype xsd:integer ;
        sh:minInclusive 0 ;
        sh:maxInclusive 86400 ;
        sh:message "The illustrative trial rule requires a serious AE report within 24 hours of site awareness."
    ] .

The complete Boundary also checks the adverse-event cardinalities and datatypes, the randomized-subject class, the reporting activity, its source record, its site, its actor, and the actor-to-site authorization relation.

A test payload submitted more than 24 hours after site awareness reaches staging but fails SHACL. The Event and Scene graphs remain triple-for-triple unchanged from their state before the attempt.

Step 4: Commit Event and derive Scene

Only a conforming staging graph can become canonical. The reference implementation uses copy-on-write:

1. Clone the current RDF Dataset into a candidate.
2. Append the staged triples to the candidate Event graph.
3. rebuild the candidate Scene graph with a deterministic SPARQL CONSTRUCT over Event.
4. Validate the candidate dataset again.
5. Replace the live in-memory reference only if every step succeeds.

A production triplestore should provide the equivalent guarantee with a transaction, an atomic named-graph swap, or an event/outbox design. Appending Event and refreshing Scene as unrelated best-effort writes would not satisfy the architecture.

For this signal, Event grows from 38 to 60 triples. Scene grows from 21 to 32 triples. The accepted event contributes exactly the 22 triples generated in staging; Scene holds the queryable clinical projection, not a second independently edited truth.

 

The outbound pathway: one governed state, many expressions

A projection is not merely a stored query. The Projection graph also records which role may invoke it and which policy class it depends on. The application checks that policy before executing SPARQL. The query itself is not an access-control system.

The medical monitor asks for serious, treatment-related adverse events in the RAS-mutant primary population whose grade meets the active Boundary threshold:

PREFIX mio: <https://w3id.org/miosis#>

SELECT ?ae ?subject ?term ?grade ?start ?threshold
WHERE {
    GRAPH <https://data.disynphia.example/axion3/graph/scene> {
        ?ae a mio:SeriousAdverseEvent ;
            mio:aboutSubject ?subject ;
            mio:meddraTerm ?term ;
            mio:ctcaeGrade ?grade ;
            mio:startDate ?start ;
            mio:serious true ;
            mio:relatedToTreatment true .
        ?subject mio:inRasMutantPrimaryPopulation true .
    }
    GRAPH <https://data.disynphia.example/axion3/graph/boundary> {
        ?rule a mio:SafetyThreshold ;
              mio:minimumGrade ?threshold .
        FILTER NOT EXISTS { ?rule mio:supersededBy ?newerRule }
    }
    FILTER (?grade >= ?threshold)
}
ORDER BY DESC(?start) ?subject

The GRAPH clauses are deliberate. The holon is an RDF Dataset with named graphs, so portable queries must say which graph supplies clinical state and which supplies the active rule.

With the initial threshold of grade 3, the next authorized query after commit returns:

adverse event	subject	term	grade	threshold
AE-04412	AXION3-0002	Febrile neutropenia	3	3

“Reactive” means that the answer changes on the next evaluation against the committed dataset. Immediate push delivery requires an additional subscription, continuous-query, or change-data-capture mechanism; a SPARQL SELECT alone does not push results.

The result is a protein in the architectural metaphor: produced for a consumer from governed state. It can be cached for performance, but the cache must not become the authoritative source and should identify the dataset and rule version from which it was produced.

A deterministic subject record

SPARQL DESCRIBE is processor-defined. It is convenient for exploration, but different services may return different descriptions. A proof should use a deterministic CONSTRUCT instead:

PREFIX mio:  <https://w3id.org/miosis#>
PREFIX prov: <http://www.w3.org/ns/prov#>

CONSTRUCT {
    ?subject ?subjectProperty ?subjectValue .
    ?entity ?entityProperty ?entityValue .
    ?activity ?activityProperty ?activityValue .
}
WHERE {
    VALUES ?subject {
        <https://data.disynphia.example/axion3/subject/AXION3-0002>
    }
    GRAPH <https://data.disynphia.example/axion3/graph/scene> {
        ?subject ?subjectProperty ?subjectValue .
        OPTIONAL {
            ?entity mio:aboutSubject ?subject ;
                    ?entityProperty ?entityValue .
            OPTIONAL { ?entity prov:wasGeneratedBy ?activity }
        }
    }
    OPTIONAL {
        GRAPH <https://data.disynphia.example/axion3/graph/event> {
            ?activity ?activityProperty ?activityValue .
        }
    }
}

This returns the subject facts, every Scene entity connected through mio:aboutSubject, and the relevant generating activities from Event. SPARQL still performs joins between graph patterns. What disappears is the repeated, source-specific foreign-key choreography across five operational systems.

Adaptation: a decision changes policy without erasing history

Before the inbound signal, the fixture already contains a related grade-2 serious adverse event for AXION3-0003. It does not appear in the medical-monitor view because the active threshold is 3.

A synthetic DSMB (Drug Safety Monitoring Board) decision lowers that projection threshold to 2. The decision is appended to Event. The old Boundary rule is retained and marked as superseded. A new rule is added as a revision derived from the decision:

@prefix axdecision: <https://data.disynphia.example/axion3/decision/> .
@prefix axevent: <https://data.disynphia.example/axion3/event/> .
@prefix axrule: <https://data.disynphia.example/axion3/rule/> .
@prefix mio: <https://w3id.org/miosis#> .
@prefix prov: <http://www.w3.org/ns/prov#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

axevent:EVT-015900 a prov:Activity,
        mio:DsmbDecisionEvent ;
    prov:endedAtTime "2026-06-02T14:00:00+00:00"^^xsd:dateTime ;
    prov:generated axdecision:DSMB-03-REC-01 .

axdecision:DSMB-03-REC-01 a prov:Entity,
        mio:GovernanceDecision ;
    prov:wasGeneratedBy axevent:EVT-015900 ;
    mio:recommendation
        "Lower the medical-monitor projection threshold from grade 3 to grade 2." .

axrule:safety-threshold-v1 a mio:SafetyThreshold ;
    prov:generatedAtTime "2026-05-01T00:00:00+00:00"^^xsd:dateTime ;
    mio:minimumGrade 3 ;
    mio:supersededBy axrule:safety-threshold-DSMB-03-REC-01 .

axrule:safety-threshold-DSMB-03-REC-01 a mio:SafetyThreshold ;
    prov:generatedAtTime "2026-06-02T14:00:00+00:00"^^xsd:dateTime ;
    prov:wasDerivedFrom axdecision:DSMB-03-REC-01 ;
    prov:wasRevisionOf axrule:safety-threshold-v1 ;
    mio:minimumGrade 2 .

The next authorized execution of the same safety query returns two rows:

adverse event	subject	term	grade	threshold
AE-04412	AXION3-0002	Febrile neutropenia	3	2
AE-04398	AXION3-0003	Anaemia	2	2

No clinical fact was rewritten. The pre-existing Event facts remain. Scene remains identical. The decision was appended to Event, and the Boundary gained a new versioned rule. That is the feedback arc: an expressed result leads to a governed decision, and the decision returns to memory in a form that changes future expression.

The five capabilities, stated without overclaim

1. Entity reconciliation

Give each canonical thing one controlled internal IRI and retain its source-system identifiers as data. Domain standards such as IDMP (Identification of Medicinal Product, see) can inform identifiers and semantics, but they do not magically guarantee that every regulator, registry, and sponsor publishes the same global IRI.

2. Semantic expression

The ontology lets a query ask for adverse events, subjects, provenance activities, and active policies by meaning rather than by source table location. The demonstrator vocabulary under mio: is illustrative; a production system must publish, govern, and version that ontology.

3. Impact analysis

The Projection graph states that the medical-monitor view uses the mio:SafetyThreshold policy class. Before changing that policy, the system can identify which projections depend on it. The proof returns the medical-monitor safety projection as affected.

4. Reactive projection

A committed signal changes the result of the next authorized query without rebuilding a separate downstream mart. Push notification remains a separate delivery concern.

5. Governed feedback

A decision is not complete when someone acts on it. It becomes institutional memory when the decision, its provenance, and the resulting rule revision return to the canonical dataset without deleting the prior state.

What this does not prove

This is a reference architecture, not a production clinical platform. It does not claim regulatory validation, medical correctness, operational scalability, or security certification.

A production implementation would still need, among other things, a real identity provider, fine-grained policy enforcement, signed and immutable audit records, ontology release governance, controlled terminology services, transaction and recovery guarantees, monitoring, retention policy, privacy controls, and validated deployment procedures.

OWL and DCAT may add useful semantics and catalog description to the wider system. They are not required to prove the loop shown here. This proof directly executes JSON contract validation, RDF/Turtle, stOTTR through maplib, PROV-O relations, SHACL, SPARQL over named graphs, role gating in the service layer, and versioned feedback.

The practical rule

A knowledge graph is not a cell merely because it stores RDF.

It becomes cellular when it has a governed boundary, an explicit transformation into canonical language, validation before admission, a reproducible derivation of current state, authorized expression, and a feedback path that records decisions and versions the rules they change.

Do not begin by modelling the enterprise. Grow one cell around one consequential object. Prove the loop. Prove the rejection path. Prove the feedback path. Then let the pattern divide.

Make knowledge live

The Biology of Knowledge argued that evolution’s lesson is not simply that knowledge must be preserved. Knowledge survives only when it is joined to identity, context, defence, expression and feedback. A genome (the data) by itself is inert. It becomes life through the disciplined cycle by which a cell senses its environment, transcribes what matters, expresses what is needed and retains the consequences of action.

The Cellular Architecture turns that principle into an engineering obligation.

Data is not useful merely because it has been stored. Information is not trustworthy merely because it has been transformed from data based on context. Knowledge is not operational merely because information is used to solve/answer a problem/question and adapt to new incoming signal. And a decision is not complete merely because someone has made it. Each must contribute to the next, and the consequences must return to memory (feedback loop).

That return path is what most knowledge architectures lack.

Facts arrive without durable identity. Rules remain buried in documents and code. Reports harden into disconnected copies. Decisions disappear into meetings, messages and workflows, leaving the institution unable to explain why its present state differs from its past (see The Definition of Success). The organisation possesses data, yet repeatedly forgets what it has learned. It has storage, but no metabolism.

A cellular system behaves differently. Its data is a genome, not a dump. Its information is a transcript, governed at the moment of admission. Its knowledge is a protein, expressed for a purpose rather than copied into another permanent truth. Its decisions are a metabolome whose effects return to the system, alter its rules and become part of its history.

This is why the unit of design is the holon: one consequential thing held as a coherent whole, yet able to participate in larger wholes. Around it, the organisation establishes a boundary, a memory, a language, a means of expression and a feedback loop. The objective is not to centralise everything. It is to make every important object capable of maintaining its integrity while contributing to the intelligence of the larger institution.

Begin with one such object, give it an identity, govern what may enter, preserve what happened, derive what is true now. Express only what each consumer is entitled to see. Record every consequential decision. Version the rules it changes. Then prove that the system can reject error, absorb evidence and adapt without erasing its past.

Only then let the pattern divide. The biology was never decoration. It was the specification.

Build knowledge as life builds it: bounded enough to remain coherent, open enough to sense, disciplined enough to reject error, expressive enough to serve many purposes and capable of learning from every consequence.

Then knowledge ceases to be an archive of what the organisation once knew. It becomes the means by which the organisation remains alive.