The Matrix: Language Understanding
The language column of the matrix, from a word to a collective rewriting its own core

A model will write a paragraph on any subject, fluent and unsigned. Its weights kept the patterns of everything it read and dropped who wrote each piece, so its words arrive without a maker. Retrieval pastes the right passages into a context window for one call and lets them go after it, and the memory the big assistants now keep about their users sits in the vendor's store, in the vendor's words. The clipboard I described in Amnesiac APEs Wearing RAGs has grown, and nothing on it is signed.
The open social web went the other way, and its records carry their language with them. A Mastodon post is an ActivityStreams object that any server can read. A Bluesky post is a record in its author's own signed repository, typed by a public schema that the AT Protocol calls a lexicon and named under a domain, like app.bsky.feed.post. Strangers' software can agree on a vocabulary without agreeing on a platform. The same networks show where meaning still gets stuck. When a Mastodon account moves to another server, its posts stay behind. In mid-2025 Threads let its users read the fediverse but not yet reply to it. A Bluesky repository moves with its owner, while the threads around it are assembled by servers that, for most people, one company runs.
Bitcoin keeps the most durable records of all. Every transaction is signed, linked to the ones before it by hashes, copied to every full node and never rewritten. Its language is the narrowest, though: a transaction says who may spend what, and anything else a person means has to live somewhere else, with an exchange or a wallet. Those places are middles again, and they hold much of the money too. In 2025 a report by Gemini and Glassnode counted about 30 percent of all bitcoin with exchanges, funds, public companies and governments.
Cloud platforms settle meaning by giving it a home. A shared document or an agent becomes one durable object with a global name and storage of its own, every reader is routed to it, and so there is only ever one version to read. The meaning is settled because one provider holds it.
So the language column asks for what each of these keeps only in part. Can a word, a paragraph or a whole body of shared meaning keep its maker, travel between parties that share no server, and still read the same at the other end?
The language column of the matrix starts with a word and ends with people writing their own core. Read down, its twelve cells are Language, Paragraphs, Dictionaries, Contexts, Context Clusters, CC Centers, Chaotic CCCs, Stochastic CCCC patterns, Seeing vs creating, Code creation, Co-re-creation and Core Creation. The first seven follow meaning as it grows out of structure. The last five follow it into the hands of the people who make it.
From row 5 to row 8 each name is built from the one before it, which comes along whole and abbreviated. Context Clusters are clusters of contexts, CC for short. CC Centers are the centers of those clusters, so a CCC is a context cluster center. Chaotic CCCs are those centers as they move, and the notes call that movement chaotic with respect to time; abbreviated once more, a chaotic context cluster center is a CCCC. Stochastic CCCC patterns are the patterns those moving centers leave when they are read as probabilities. Every C in the chain is a step of the climb, and each cell holds every cell before it.
This is the second of four posts on the matrix. The Matrix, Then and Now set out the terrain and why it needed a map; here I walk down one column, quote what I wrote under the grid in 2014, and say what each cell asks us to build. The code is gathered in an appendix at the end, so the argument can be read without it, and the text notes which part of the appendix goes with which step.
Language and paragraphs
Rows 1 and 2 begin with nodes, and the notes put words among them from the first page.
A graph is one way to represent the model of a network by describing nodes and connections between nodes. Think of nodes as the unit elements in our universe of discourse. For instance, language elements can be modeled as nodes, just as a computing machine or a neuron can be modeled as a node.
Row 2 then lays a mesh over those nodes, and on the language side the mesh "forms structures similar to words, phrases, sentences and paragraphs". A word on its own is a node. A paragraph is the smallest unit of language that someone wrote for someone, which makes it the first thing in the column with an author and an audience, and the first thing that relates more than two parties at once. That is why the matrix reaches for hypergraphs so early: an edge joins two nodes, while a paragraph joins its writer, its readers and whatever it answers.
In the record a paragraph is one row, and the row names what it joins. Each name is an incidence: a role, a target, and the kind of thing the target is (appendix A1).
A target can be another row, a party's key, a file named by the hash of its content, or the identifier of something that lives in a foreign system and came in over a bridge. A reply in a family's circle is then a row with three incidences: its author, its audience, which is the family's circle, and the post it answers (appendix A2).
Nothing in that row is nested. The post it answers stays where it is, the circle stays a key, and the graph of incidences carries everything else. A party keeps an index of those incidences, rebuilt from its rows whenever it likes, and every question about who said what to whom is a query over it (appendix A3).
Spoken, written, shared and heard language each have a place in that picture, and the eighth and ninth sections of Mathematics' Architecture & Processes take them in turn, with a feed built as one query over this index.
The socioware essay follows Derrida on what happens to a paragraph next. Writing lets a meaning travel without its author, and the same fact lets it be read without being understood. Derrida's own example in "Signature Event Context" is the signature, the mark that is supposed to tie a text to the one person who made it and has to be repeatable to work at all. The mesh takes that worry literally. Every row carries the key of whoever wrote it, and the key signs the row, so a paragraph can travel as far as the mesh reaches and still find its way back to its writer.
Dictionaries and contexts
Row 3 is where language meets information architecture.
The first step in information architecture is labeling pieces of information, naming things and classifying them as and when needed.
To preserve this 'flatness', i.e. to not have nested keys for any value in the dictionary, we simply allow the values unknown by one dictionary to be a reference to another dictionary where the original key has a known value.
Every record in the matrix is a flat dictionary, and the references of the last section are how it stays flat. A flat dictionary has one more property worth building in: two programs that hold the same dictionary should write the same bytes, so that a signature over those bytes survives being parsed and written again by someone else's code. Sorting the keys is enough (appendix A4).
The incidences get the same treatment. A row's list of references is kept in one order, by role, then target, then kind, with exact duplicates dropped, so an index rebuilt from the rows is byte for byte the index that was written as they arrived (appendix A5).
Row 4 then asks more of a dictionary than it can give alone.
"We will show them our signs in the furthest regions (of the earth) and in their souls, until it becomes clear to them that this is the truth."
Creating and deducing meanings of signs (acts and objects) in relation to other signs is the key theme of this row. Meaning construction, understanding and deconstruction needs more tools than simple semantic annotators from the previous row. Merely remembering the key value pairs cannot get us far enough.
A sign is an act or an object that stands for something to someone. We keep three things apart and linked: the sign as it was made, what it means here, and a token a machine can compute over. In the diabetes app the socioware essay imagines, a photograph of a meter is the sign, the reading it shows is its meaning in this context, and the number a model works with is its token. In the record, the photograph is a file named by its content, and the reading names it twice, as an attachment and as the sign it reads, so the reading stays beside its sign (appendix A6).
The token is where Husserl's technization lives, symbols manipulated by rule with no grasp of what they mean. Keeping the token linked to its meaning and the meaning linked to its sign keeps the way back open: a reading can be questioned and made again without losing what it was a reading of.
Compound signs are about other signs. A reply is about a post, a reaction is about a reply, an assertion is about another assertion, and what a compound does is defined by what it relates to; that relation is what the matrix calls context. A party's map of maps, in the essay's terms, is its olog: boxes for the kinds of things it deals with, arrows for how they relate, and a note of which paths through the diagram agree. Spivak and Kent proposed ologs as a categorical framework for knowledge representation in 2012, and they fit row 4 well, since an olog is exactly a dictionary of dictionaries with its arrows checked.
Barthes, and Baudrillard after him, read signs for the social power they carry. Row 4 keeps that power in view by keeping every compound tied to the signs it is about, and every sign tied to the key that made it.
Two parties rarely share an olog. When a lab says "result" and a clinic says "report", the place where the two turn out to be the same thing is the essay's ontolog, and the matrix gives it a law: export a record into the other vocabulary, import it back, and the record we started with comes back unchanged (appendix A7).
A translation that loses something fails the law on the first record that carried it, which is the moment you want to find out.
Each party's olog is its internal language and its log is its external one. The tenth section of Mathematics' Architecture & Processes sets Chomsky's universal grammar beside Guy Deutscher's relativism along that line, with the closed vocabulary of roles that sits between them.
Context clusters and their centers
Rows 5 to 7 gather contexts into clusters, find their centers, and watch the clusters move.
Understanding is understood as the capability to provide (context-based) solutions to (context-aware) clusters of decision problems or function problems regardless of the collective complexity of the problems.
A context cluster is a set of contexts that pose problems together. Lyotard saw knowledge breaking into language games, each with its own rules, and a context cluster is one such game with its problems written down. Understanding is measured inside the game that poses the problems, which keeps it close to the people playing it.
Before the matrix, our collective called the traits we were after the CURE, and its first letter is the one this stretch of the column needs: context-based retrieval by content. Retrieval in the matrix walks the same references the records already hold, starting from what matches by content and following incidences outward, and it keeps the origin of everything it finds. It starts from the records that match by content, follows their references a step or two outward, keeps only what someone signed, and remembers the path it took to each (appendix A8).
What a model receives from this is a context in which every entry says who signed it and how it was reached, so whatever the model writes back can cite both. Amnesiac APEs Wearing RAGs found only a clipboard where this memory should be, held for one call and gone by the next. The context here is assembled from a memory the parties keep, and it is assembled again for the next call from the same place.
A cluster's center, in language, is the record most of the cluster is about: the post a thread answers, the visit a set of readings belongs to. No one appoints it; it is the record the cluster's own incidences point at most, and when the cluster grows, its center can move. Row 7's chaotic CCCs are those movements read over time. Replies arrive before the posts they answer, a lab's report arrives before the visit it belongs to, and the meaning of the cluster has to come out the same whatever the order. A reader that meets a reply to a post it does not hold yet keeps the reply and waits; Unified Computations shows why waiting is enough.
Stochastic parrots, seeing and creating
Rows 8 and 9 bring models into the column. Stochastic CCCC patterns are those moving centers read as probabilities, and a model writing from a context produces one: a distribution over what could be said, sampled once. The matrix lets that output into the record on one condition. A suggestion is kept beside the row a person signs, with the name of the model that made it, and it counts once the person confirms it. The row keeps both, the model's name and its suggestion beside what the person signed (appendix A9).
What the model said and what the person signed are both in the row, so the difference between them is in the record too. That difference is the most useful thing a model can teach us about itself.
Row 9's cell is Seeing vs creating. Seeing is a projection: one of row 8's maps applied to records that already exist. Creating writes a new signed record. In code the difference is two type signatures: a view takes a row and returns what a reader may see of it, or nothing, and creating takes a draft and a signer and returns a new signed row (appendix A10).
Baudrillard's third order is the case where the map comes first and generates the real, the way codes and weights now do. A view in this column is always a projection of signed rows, so it can be laid back against the rows it came from. Merleau-Ponty's painter sees and is seen at once, and row 9 records the creating at the point where it happens, as an act signed by whoever did it.
Code creation, co-re-creation, core creation
The last three cells move from what people say to what they make together.
Code creation is the shared document where every change is a signed addition. An edit is a row that supersedes the row it replaces; a deletion is a tombstone that retracts its target. Both are references the row carries in its own columns, so they need no machinery of their own (appendix A11).
The document anyone sees is the set of rows nothing has superseded or retracted, and its history is every row, readable in order. Who wrote each line is never a question; the line's row is signed.
Co-re-creation is one party's work taken up, remixed and carried further by another. A remix is a row that names what it remixes, and since each of those rows is signed, every contributor's signature travels with the result. Star and Griesemer called work that travels this way a boundary object: plastic enough for each party to use in its own way, and robust enough to keep one identity across all of them.
Core creation is a collective writing its own core. Mt. Kolmogorov: A Complex Climb argued that a large data app has a much shorter description that can generate the rest, usually its schema. Row 12 reads that as the collective's core: one description of the records, shared by every party, from which both sides of the wire are generated, so theory and practice cannot drift apart. The July 2020 Anarchitecture & Skunkworks post said to start with entities and identities and to annotate processes before automating them. That order holds. Identities are the keys, entities are the records they sign, and the annotations people add are the tags of row 3, which machines learn from afterwards.
The column ends where it began, with a meaning leaving home and a way back to whoever made it. Once again, the solution emerges from the problem definition itself; the problem was always that meaning leaves home.
What to build
Each column post ends with a short curriculum. This one builds the records the other two columns compute over and think with.
- A flat, signed record format with typed references. Canonical JSON for the body, the incidence list in its one order, and a signature over a context line plus the canonical JSON of the header and body, so a signed statement cannot be moved to another row (appendix A12).
- Posts and replies as hyperedges, and a feed as one query. The
feedOfof the ninth section of Mathematics' Architecture & Processes, over an index you rebuild from the rows and compare byte for byte with the one you wrote on insert. - An olog for one party and an ontolog between two. Declare one equivalence, such as a lab's result and a clinic's report, and run the round-trip check of appendix A7 over every record you hold until it finds nothing.
- Retrieval by content and origin. The retrieval of appendix A8, with a content index that runs where the records are; hand a model only what it returns, and keep the signers and paths beside the model's answer.
- A shared document of signed additions. Edits that supersede, deletions that retract, and a current view of the heads, synced peer to peer. The sixth section of Mathematics' Architecture & Processes supplies the sync, and Suggestions from Papa puts this document in a UI.
Readings
- Risav Karna, The Matrix, Then and Now (2026).
- Risav Karna, Collaborative Systems in the Age of Codes and Weights (2026).
- Risav Karna, Mathematics' Architecture & Processes and Mathematics' Anarchitecture & Processes (2020).
- Risav Karna, Mt. Kolmogorov: A Complex Climb (2024).
- Jacques Derrida, "Signature Event Context" (1972).
- David Spivak and Robert Kent, "Ologs: A Categorical Framework for Knowledge Representation" (2012).
- Jean-François Lyotard, The Postmodern Condition (1979).
- Susan Leigh Star and James Griesemer, "Institutional Ecology, 'Translations' and Boundary Objects" (1989).
Appendix: the code
The code below is in the order the text uses it. Each part names the section it belongs to.
A1. Incidences
From Language and paragraphs.
// refs.ts
export type RefKind = 'entry' | 'key' | 'blob' | 'origin';
/** One incidence: this row joins `to`, in the role `role`. */
export interface Incidence {
readonly role: string;
readonly to: string;
readonly kind: RefKind;
/** When the incidence held, for the few that are bound to a time. */
readonly at?: string;
}
export const entryRef = (role: string, to: string): Incidence => ({ role, to, kind: 'entry' });
export const keyRef = (role: string, to: string): Incidence => ({ role, to, kind: 'key' });
export const blobRef = (role: string, to: string): Incidence => ({ role, to, kind: 'blob' });
An entry is another row, a key is a party, a blob is a file named by its SHA-256, and an origin is the identifier of something that came in over a bridge.
A2. A reply as a row
From Language and paragraphs.
const reply = {
kind: 'public:post',
refs: [
keyRef('author', alice),
keyRef('audience', family),
entryRef('answers', post.id),
],
body: { text: 'Same here. The walk after dinner helps.' },
};
A3. The incidence index
From Language and paragraphs.
// incidences.ts
export interface IncidenceIndex {
/** Every row that names `to` in one of `roles`. */
naming(to: string, roles: readonly string[]): Promise<readonly { entryId: string; role: string }[]>;
/** Every incidence one row has. */
incidencesOf(entryId: string): Promise<readonly Incidence[]>;
}
A4. Canonical JSON
From Dictionaries and contexts.
// canonical.ts
/** A value as canonical JSON: object keys sorted, undefined members dropped, nothing else changed. */
export function canonicalJson(value: unknown): string {
if (value === null || typeof value !== 'object') return JSON.stringify(value);
if (Array.isArray(value)) return `[${value.map(canonicalJson).join(',')}]`;
const entries = Object.entries(value as Record<string, unknown>)
.filter(([, child]) => child !== undefined)
.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(',')}}`;
}
A5. References in one order
From Dictionaries and contexts.
export function normalizeRefs(refs: readonly Incidence[]): Incidence[] {
const seen = new Set<string>();
const out: Incidence[] = [];
for (const ref of refs) {
const key = `${ref.role}\u0000${ref.to}`;
if (!seen.has(key)) { seen.add(key); out.push(ref); }
}
const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0);
return out.sort((a, b) => cmp(a.role, b.role) || cmp(a.to, b.to) || cmp(a.kind, b.kind));
}
A6. A reading beside its sign
From Dictionaries and contexts.
const photo = blobRef('attachment', photoSha256);
const reading = {
kind: 'glucose',
source: 'photo_assisted',
refs: [photo, entryRef('reads', photoRow.id)],
body: { mgdl: 142 },
};
A7. The round-trip law
From Dictionaries and contexts.
// ontolog.ts
export interface Translation<A, B> {
readonly to: (a: A) => B;
readonly from: (b: B) => A;
}
/** The records a declared equivalence fails to carry out and back. Empty when the law holds on `sample`. */
export function roundTripFailures<A, B>(t: Translation<A, B>, sample: Iterable<A>): A[] {
const failures: A[] = [];
for (const a of sample) if (canonicalJson(t.from(t.to(a))) !== canonicalJson(a)) failures.push(a);
return failures;
}
const labToClinic: Translation<LabResult, ClinicReport> = {
to: (r) => ({ test: r.analyte, value: r.value, unit: r.unit, reportedAt: r.resultAt }),
from: (c) => ({ analyte: c.test, value: c.value, unit: c.unit, resultAt: c.reportedAt }),
};
A8. Retrieval by content and origin
From Context clusters and their centers.
// retrieve.ts
export interface Found {
readonly entryId: string;
/** Who vouched for it. */
readonly signer: string;
/** The references walked to reach it. */
readonly path: readonly string[];
/** Local to this query; never stored, and never shown on a person. */
readonly score: number;
}
export async function retrieve(
index: IncidenceIndex,
byContent: (query: string) => Promise<readonly { entryId: string; score: number }[]>,
signerOf: (entryId: string) => Promise<string | null>,
query: string,
hops = 2,
): Promise<Found[]> {
const found = new Map<string, Found>();
/** Keeps an entry if it is new and someone vouched for it, and returns it. */
const visit = async (entryId: string, path: readonly string[], score: number): Promise<Found | null> => {
if (found.has(entryId)) return null;
const signer = await signerOf(entryId);
if (signer === null) return null; // nobody vouched for it, so it is no context
const f = { entryId, signer, path: [...path, entryId], score };
found.set(entryId, f);
return f;
};
/** Follows every reference out of the frontier, `left` more times. */
const walk = async (frontier: readonly Found[], left: number): Promise<void> => {
if (left === 0 || frontier.length === 0) return;
const next: Found[] = [];
for (const f of frontier)
for (const ref of await index.incidencesOf(f.entryId)) {
const g = ref.kind === 'entry' ? await visit(ref.to, f.path, f.score / 2) : null;
if (g !== null) next.push(g);
}
return walk(next, left - 1);
};
const first: Found[] = [];
for (const hit of await byContent(query)) {
const f = await visit(hit.entryId, [], hit.score);
if (f !== null) first.push(f);
}
await walk(first, hops);
return [...found.values()].sort((a, b) => b.score - a.score);
}
A9. A row, with the model's suggestion beside it
From Stochastic parrots, seeing and creating.
// row.ts
export interface Row {
readonly id: string; // a ULID: its first ten characters are a time
readonly kind: string;
readonly occurredAt: string; // when the row says it happened, with the writer's UTC offset
readonly recordedAt: string;
readonly deviceId: string;
readonly source: 'manual' | 'photo_assisted' | 'imported' | 'system';
readonly supersedesId: string | null;
readonly targetId: string | null;
readonly payload: string; // canonical JSON of the body
readonly aiModelId: string | null; // the model that suggested it, if one did
readonly aiSuggestion: string | null;
}
A10. Seeing and creating
From Stochastic parrots, seeing and creating.
/** Seeing: the row as this reader may see it, or nothing. */
export interface View {
readonly name: string;
project(row: Row): Row | null;
}
/** Creating: a new row, signed by the one who made it, naming what it changes. */
export type Create = (draft: Omit<Row, 'id' | 'recordedAt'>, signer: Signer) => Promise<Row>;
A11. Edits and deletions as references
From Code creation, co-re-creation, core creation.
export function columnRefs(
row: { supersedesId: string | null; targetId: string | null },
attachments: readonly string[] = [],
): Incidence[] {
const refs: Incidence[] = [];
if (row.supersedesId !== null) refs.push(entryRef('supersedes', row.supersedesId));
if (row.targetId !== null) refs.push(entryRef('retracts', row.targetId));
for (const sha256 of attachments) refs.push(blobRef('attachment', sha256));
return refs;
}
A12. The signed message
From What to build, item 1.
export function signedRowMessage(
context: string,
header: { id: string; kind: string; deviceId: string; occurredAt: string },
parts: readonly unknown[],
): Uint8Array {
const { id, kind, deviceId, occurredAt } = header;
return new TextEncoder().encode(`${context}\n${canonicalJson([id, kind, deviceId, occurredAt, ...parts])}`);
}
About the author
- Technical Leadership & Architecture
Comments
Join the discussionNo comments yet. Be the first to comment.
An Architecture
In this series, we explore ways to think about the architecture of common libraries & UIs. We will use JS, Bun, TS, Svelte 5+, Nx, RxJS, ScalaJS, ReasonML, Idris 2+, and Lean 4+.





