{"path":"research/soar-listen-to-the-architecture.md","content":"# Listen to the architecture: John Laird on SOAR, read against the Deliberus data model\n\n**Date**: 2026-11-09 · **Type**: a podcast episode read against the corpus · **Status**: analysis. Every\nposition below that is not quoted from a ruling is Claude's and unruled. No ledger rows were opened; the\nfour proposals in § 5 wait on the founder's word and are filed here only.\n\n**Source**: *The Cognition Project*, episode 24, *\"Soaring: John Laird\"*, host Tom Griffiths (Princeton),\npublished 2026-10-22, 38:23. Transcript: Particle's machine transcript as served in Exa's podcast library,\nsaved with its turn marks in `sources/podcasts/cognition-project-024-laird-soar-2026-10-22.md`; its header\nlists the misheard names (*Rosenblum* for Rosenbloom, *Lebert* for Lebiere, *Alan Newton* for Newell) and\nSpotify's automatic chapters, whose durations give the only time windows inside Laird's 33-minute answer.\nThe passage the founder asked about (about 08:00 to 09:00) is the one he pasted from Spotify's transcript;\nParticle's text agrees with it word for word apart from fillers. A timestamped transcription was refused\nby OpenAI that morning (credit exhausted); the Mac's local model reads Swedish only.\n\n**The founder's instruction**: *\"This is another podcast I'd like you to read and analyze and mine for\ninsights that might apply to Deliberus. One idea I'm spontaneously thinking about is the idea at about\n8.00-9.00, if you can find that passage and think about how it relates to our work on the data model and\nother aspects of Deliberus.\"*\n\n**Read depth**: the whole episode from the transcript (about 6,600 words). Corpus homes opened this\nsession: `claim-or-system.md` § 3 (the sort), `the-kind-of-mistake-we-make.md` § 9 (the `confirmed` field),\n`machine-work-as-a-standing-property.md` (*a pass fires once, at one door*), `claims-and-code-one-loop.md`\n(the trusted core, AJ4), `taxonomy-gaps-and-the-closed-enum.md` (the confession slot),\n`latent-scaffolding-and-the-type-token-split.md`, `the-analogy-daemon.md` and\n`perceiving-possibility-and-the-analogy-organ.md` § 4 (Copycat), `deliberus/machine_sentences.py` (one rule\nunder many links), and the global rule *Split semantic from temporal*. Not read: Laird's *The Soar Cognitive\nArchitecture* (2012) and Newell's *Unified Theories of Cognition* (1990). Facts about SOAR beyond what the\nepisode says (its preference vocabulary, its impasse types, the problem of expensive chunks) are from Claude's\ntraining and are marked as such; they are survey-grade.\n\n**Discipline for this note, from the correction made the same morning** (`the-wiser-civilization-as-successor-carlsmith-and-faggella.md` § 8):\neach meeting below names its key, as the keeper must before it writes a link: *same claim*, *one shared\nclaim* (an overlap), or *an analogy with its respect named*, and says where the two part. SOAR is one\nagent's cognition, in steps of about fifty milliseconds, inside one mind; Deliberus is a record between\nmany minds that persists and is attributed. What transfers is architectural discipline, never the\ncognitive claim.\n\n---\n\n## 0. In short\n\n**What he says.** SOAR's founding move was to stop choosing a rule and let all matching rules fire in\nparallel, each only *proposing*, *evaluating* or *applying* an operator, with a fixed decision procedure\npicking from the proposals; the knowledge changes which method emerges, the architecture never does (the\n*Universal Weak Method*). His thesis made the lack of knowledge a first-class event: when the system\ncannot decide, that is an **impasse**, which becomes a **subgoal**, so the missing knowledge is *\"a\nproblem itself to be solved\"*, recursively (*universal subgoaling*); and **chunking** compiles what the\nsubgoal found into a new rule, so the impasse does not recur. From there the career is one rule: *\"keep\nlooking for capabilities the system doesn't currently have and ask how can we add those capabilities in in\na way that respects everything that's already there, but also takes advantage of what's there … Newell\nused to say you should listen to the architecture.\"* He added three memories that way (semantic, episodic,\nmental imagery), each entering through the existing working memory and never as a separate solver; he\nholds the architecture fixed so nobody drops down to C to patch a gap; and he now puts language models at\nSOAR's edges, as an interface and a knowledge source, with the human asked *\"is this right?\"*.\n\n**What it is to this project.** *Listen to the architecture* is the discipline the project has applied\nwhen it did well and violated when it paid: a new capability expressed as claims, links, a row in the\nrecord of machine judgments or a reading computed over them, never as a stored property that encodes a\njudgment or a state. The sort in `claim-or-system.md` § 3 is that discipline written as four questions, and\nthe `confirmed` field, the stored link strength, the stored terminus and the yellow link are the four times\nthe project bolted a capability on and paid at the readers. The impasse is the project's gap (a sorry\nmarker, an unexamined link, a horizon), the subgoal is the descent, and chunking is the reuse of a rule\nunder many links, already built for a machine's sentences by wording. The episodic memory he added after\n*Memento* is the record of machine judgments and, for the sessions, the corpus graph. Where the two part\nis in what the knowledge is: SOAR's is one agent's and consistent, Deliberus's is many people's and holds\ncontradiction as content.\n\n---\n\n## 1. What Laird says\n\nQuotations are from the transcript; the time windows are Spotify's chapter boundaries.\n\n1. **Rules propose, evaluate and apply; a fixed procedure decides** (≈ 00:00–05:00). *\"Instead of having\n   a lot of rules where you then are trying to select the right rule, the rules themselves fire in\n   parallel when they match, but rules are proposing operators or evaluating operators or applying\n   operators … the rules being things that were more monotonic and that were just for proposing and\n   evaluating, and then non-monotonic for applying.\"* His first paper, the *Universal Weak Method*: many\n   methods *\"realized for a single task based on what knowledge the system had about the task\"*.\n2. **An impasse is an opportunity** (≈ 05:00–07:00). *\"Sometimes there's not enough knowledge in the\n   system to actually know what to do. And a lot of systems at the time would then sort of select randomly\n   or make arbitrary decisions. And what we decided to do was to say that was an opportunity … that would\n   lead to what we called an impasse. And then the response to the impasse was to have a sub-goal. And in\n   the sub-goal, then you could treat that impasse, the lack of knowledge, as a problem itself to be\n   solved.\"* Kinds of subgoal follow the kind of lack: *\"whether … you didn't know what action to take or\n   you didn't know how to apply the action. So maybe if you didn't know how to … actually perform the\n   action, you would decompose it into simpler parts and do those and then recursively use the same methods\n   there.\"*\n3. **Chunking, and everything learnable** (≈ 07:00–08:00). *\"A learning mechanism that analyzed what was\n   going on in the sub-goal and would then compile that into a rule.\"* The aim: *\"cognitive architectures,\n   where all of the knowledge in the system is theoretically, at least syntactically, learnable. So if\n   you're working on a problem, you don't work for a while in rules and say, well, this is something I\n   don't know how to do. I'm going to write … Lisp code or C code in order to do this little component.\"*\n4. **Listen to the architecture** (≈ 08:00–09:00, the passage he asked about). *\"One of the themes is to\n   keep looking for capabilities the system doesn't currently have and ask how can we add those\n   capabilities in in a way that respects everything that's already there, but also takes advantage of\n   what's there. So it's not a completely separate problem-solving system or whatever. It's really taking\n   advantage of what's already there. And Newell used to say you should listen to the architecture so that\n   when you're trying to add something new, you say, well, what can I get out of what's already there?\"*\n   The other half of the method: *\"take what we had and see how well it stood up to a more real-world\n   problem\"* (R1-Soar, the expert system for computer configuration), which *\"validated and also shakes out a\n   bunch of bugs\"*.\n5. **Efficiency prunes designs** (≈ 11:00–13:00, and again near the end). The rewrite in C ran fifty times\n   faster, *\"because we're doing applications … we want to have a system that runs fast and we can do a\n   lot of experiments on\"*; *\"making sure you're not asking the system to doing quadratic or exponential\n   computations under the hood\"*; and *\"you might think having too many constraints makes things\n   difficult, but boy, it lets you get rid of a lot of different possibilities that aren't going to scale.\"*\n6. **What a cognitive architecture is** (≈ 13:00–17:00). *\"A level of abstraction for computation that has\n   a set of capabilities and it has memories\"*; working memory *\"is like its context except that it gets\n   changed by what's going on in the system as opposed to just accumulating knowledge\"*; the architecture\n   *\"should be pretty solid so that … you're not every once in a while … going down and saying, well,\n   let's do this in the architecture because it's too hard to do with the knowledge and the representations\n   we have\"*; Lebiere's *\"separation between church and state\"*. The level is about fifty milliseconds of\n   human decision, above the brain architectures (Spaun, Leabra) that he hopes will one day *\"be creating\n   the level that I live upon\"*.\n7. **Three memories added by listening** (≈ 17:00–21:00). Semantic memory, retrieved by recency and\n   frequency; episodic memory, after *Memento*: *\"every AI system I know of and our systems are like that\n   guy. They're cognitive cripples\"*; and mental imagery, placed deliberately: *\"that's a precursor to\n   what goes into working memory. So we're not going to match rules against what's in mental imagery space.\n   We're going to instead be able to filter out and extract relations and symbolic structures from that\n   deliberately. And then that gets into working memory and we use the whole SOAR engine to reason about\n   that.\"*\n8. **Language models at the edges, the human asked** (≈ 26:00–30:00). The models are *\"a little bit more\n   flexible and general than what we could encode in SOAR\"*, so they serve as an interface (*\"converts it\n   into a JSON format that we then process and read into SOAR\"*) and as a knowledge source, checked:\n   *\"doing multiple retrievals from the language model to make sure it's consistent, and then ask, is this\n   knowledge consistent with what I've heard from the human? And then we always ask the human, okay, here's\n   what I'm going to do. Is this right?\"* Learning a task is never a step list, *\"that ends up with very\n   fragile learning\"*; it is general knowledge, and most correction is specialisation: *\"you've learned\n   something in one situation and you're trying to apply it in a new situation and it just doesn't apply\n   exactly and you have to specialize the knowledge and correct it.\"*\n9. **Newell** (≈ 33:00–37:00). *Human Problem Solving* (1972) as the agenda; *\"keep your eye on the main\n   chance\"* (*\"how does it feed to the main questions we're asking?\"*); Herb Simon's question at the end of\n   other people's presentations, as Laird remembers it, *\"think hard about what's really going on here and\n   what the key ideas are\"* (the founder, 2026-11-10: *\"that feels like a valuable reminder to keep telling\n   ourselves\"*); and on a model of his advisor:\n   *\"I don't want that to be something that just reads his papers and then digest them and I interact with\n   a large language model. I want his new insights, his new ideas.\"*\n\n---\n\n## 2. The passage he asked about, read against the data model\n\n**What the sentence says.** A new capability is added through what the architecture already affords, so\nthat it uses the existing representations and the existing engine, and never arrives as a separate\nproblem solver beside them. The test Newell gives is a question asked before building: *what can I get out\nof what's already there?*\n\n**The project's architecture, stated the same way.** One node type, Claim (`ClaimBase` in code; every\nlater kind, `machine_step`, `supposed`, a reference class, a membership, is a claim with a `claim_kind`);\neleven link types; the record of machine judgments (`deliberus/judgments.py`, every model call written down,\nnothing edited); readings computed on request and storing nothing (the badge, the horizon kind, the truth\ngraph, the map view); and a small fixed core, the form checks and the combination rules, which is the\n*architecture* in Laird's sense, as against the graph's contents, which are the *knowledge*. The sort in\n`claim-or-system.md` § 3 is *listen to the architecture* written as a procedure: could two people disagree\nabout it (a claim); does it say who did what (the record); can it be computed again from those (a reading);\nwhat is left is form, kept as small as it can be, with a *does not fit*. The two notes meet as the **same\ndiscipline**, reached from a single agent's architecture and from a shared record.\n\n**Where the project listened.** Each of these added a capability through the existing representation:\n\n| Capability wanted | How it entered | Where ruled or built |\n|---|---|---|\n| a prior for a claim from what it says | a reference class is a generalization used as a prior's source, *\"never a second kind of object\"*; membership is a claim, named in the `IN_CLASS` link's `grounds` | BC1, BI4 (ruled 2026-11-08), `reference_classes.py` |\n| the machine's own sentence under a link | a claim of kind `machine_step`, asserted by nobody, moving no strength until examined | AG12 (ruled 2026-10-10) |\n| an *if*-sentence | its halves as claims of kind `supposed`, the sentence as the link's relevance claim | AM5 (ruled 2026-10-19) |\n| what a link rests on | the relevance claim, a claim about the link, with the inference's pieces as its parts | the sort, row 4 |\n| where a disagreement currently bottoms | a horizon kind **read, never set**, computed from the arrangement; the setter answers 410 | ruled 2026-09-15, `horizon.py` |\n| what a run did | one row per model call in the record, from which a dead run is rebuilt | built 2026-10-06 |\n\n**Where it bolted on, and paid at the readers.** Each of these stored a judgment or a state as a property,\nwhen the architecture could have expressed it as a claim or a reading:\n\n| Property | What it was | What it cost | Where |\n|---|---|---|---|\n| `confirmed` | a flag named for an act no code performed; set by whoever wrote the link | five readers took five meanings; extraction's links shielded from tidying, the linker's waiting for a review nobody could perform | `the-kind-of-mistake-we-make.md` § 9; retired, Q32 |\n| link `strength` | a 0–1 rating the classifier wrote at extraction, undefined, 0.7 on links from the correction UX | ranked the bridging feed for months; replaced by relevance computed from answered questions | Q31, Q33 |\n| `terminus` / `is_bedrock` | a verdict stored on the claim | a stored verdict goes stale and closes what the ruling says is never closed; replaced by the reading | `what-belongs-in-the-ontology.md` § 6c |\n| `QUALIFIES` (the yellow link) | a menu slot, not a kind | 538 links that weighed nothing and meant five different things | Arc BB |\n| `trust_tier` | set by the writer, read by nothing that decides | dormant twin of `confirmed` | § 9b of the same note |\n\nThe hard-won gotcha *a stored property is defined where it is written, and a placeholder is named for the\nwaiting* is *listen to the architecture* applied to a single property: a property is a new capability only\nif something reads it, and what reads it must find the definition where it was written.\n\n**Where SOAR and Deliberus part here.** In SOAR the architecture is fixed by its designers and the\nknowledge is the agent's own, consistent by construction; in Deliberus the knowledge is contested between\npeople and attributed, and the graph is built to hold two users disagreeing. So Laird's *\"all knowledge\nlearnable, never drop to C\"* becomes *argue it in the graph, check its form in code* (`one-inference-per-link.md`\n§ 8: code checks the form, truth is argued in the graph), and his line about church and state is the project's\ntrusted core (AJ4, `claims-and-code-one-loop.md`: a small core never argued at the moment it applies), with\none demand SOAR never had: that the line between core and contents be arguable later (the meta hold of\n2026-08-30, renewed 2026-11-07). The sorting test of August is the same boundary seen from the knowledge\nside: a commitment belongs in the graph if the system can hold two users disagreeing about it and keep\nworking, in the ontology if it cannot.\n\n---\n\n## 3. The other meetings, each with its key\n\n1. **Propose, evaluate, apply, and a fixed decision: the same split, in other materials** (an overlap on\n   one claim). SOAR's rules only propose and evaluate; a knowledge-free procedure decides; application then\n   changes the state. The project: microtasks propose and never assert (canon); a deterministic computation\n   combines what they wrote (the badge, Q46's log-odds, the weakest premise, Q48's ranges); only then does\n   a write change the graph. The global rule *Split semantic from temporal* (the model decides WHAT, code\n   decides WHEN) is this split for the project's own hooks. SOAR's preference vocabulary (acceptable,\n   better, worse, best, worst, indifferent, reject, require, prohibit: from training, not the episode) is a\n   small typed set for how a proposal bears on a choice, as supports, attacks, relevance and `necessary` are\n   here. **Where they part**: SOAR's decision picks one operator and discards the rest; the project's\n   computation yields a posterior and leaves every alternative standing (*contributions are added, never\n   overwritten*). The picking is what a record between people may never do.\n\n2. **The impasse is the gap, the subgoal is the descent** (a shared mechanism, different host). *\"Select\n   randomly or make arbitrary decisions\"* versus *\"that was an opportunity\"* is the sorry marker's founding\n   idea (a gap as a contribution entry point) and the ruled principle *no gap displayed without a move\n   offered*. Universal subgoaling is the descent: a missing premise, an unanswered critical question, an\n   unexamined link each becomes a problem of its own, recursively, and his *\"decompose it into simpler parts\n   and do those and then recursively use the same methods there\"* is the self-similar decomposition\n   principle in his words. His kinds of impasse (no action proposed; a tie; not knowing how to apply: the\n   first two from the episode, the taxonomy from training) have homes: the gate's *no bearing*, the keeper's\n   tie between two renderings, the split. **The sharper point**: SOAR detects an impasse *architecturally*.\n   The knowledge never has to declare *I don't know*; a tie, or a cycle in which nothing changes, is an event the decision\n   procedure raises, so an arbitrary pick is impossible to paper over. That is the confession principle\n   built into the architecture rather than asked of a menu. The project's confession slots (`does_not_fit`,\n   the gate asked first, the ruling that a machine's refusal belongs in a gate) sit at the level of the knowledge: a model is asked to confess.\n   The version at the level of the architecture exists in one place: AM1, *no verdict without what it rests on*, where a\n   keeper verdict whose chain cannot be written is refused by code, whatever the model said. **Where they\n   part**: SOAR's subgoal is solved inside the same mind in milliseconds; the project's gap waits, publicly,\n   for a person or a microtask, and that waiting is content (an unexamined claim reads *unexamined*).\n\n3. **Chunking is the reuse of a rule, and its pathology is ours** (an analogy, in the respect of storing a\n   subgoal's result). Chunking compiles what the subgoal found into a rule so the impasse does not recur.\n   The project's version is built for a machine's sentences: *one rule can sit under many links*, and a\n   sentence whose wording matches an earlier machine-written rule reuses that claim instead of minting\n   another (`machine_sentences.py`, matching by normalised wording, never by meaning; a match with a claim\n   somebody made is shown, never merged). The sort already says a rule *\"recurs under other links\"*, which\n   is the flywheel's condition that identity be cheap to decide. **Why they differ**: SOAR stores the chunk\n   for speed, since recomputing is the expensive search; the project stores the chain's claims because they\n   are contestable, and recomputes readings because recomputing is cheap and keeps them honest. Latent\n   scaffolding is the mirror move (do not mint a derivable question until touched). Laird's caveat is the\n   project's own ruling: step lists are fragile, learn general knowledge, and *\"a lot of correction really\n   is … you have to specialize the knowledge\"*: a normic generalization is the universal plus named\n   exception claims (AT1), a case review ends in a candidate rule (Y9), and a generalization and its cases\n   calibrate each other (BI2). SOAR's known trouble with overgeneral and expensive chunks (training, not the\n   episode) is an overgeneral rule under many links, which the exception claim is the remedy for.\n\n4. **Episodic memory: the record of machine judgments, and the corpus graph** (same function). *\"Every AI\n   system I know of and our systems are like that guy. They're cognitive cripples.\"* The record was built on\n   2026-10-06 because a run died and nothing could say what it had done; since then every call is written\n   down and a dead run is rebuilt from it. For the sessions, the corpus graph and the ledger do what\n   Laird's episodic memory does for the agent: a session that woke without them re-derived settled things\n   and asserted the opposite of rulings it had not read (the wrong-by-default anchors). His reason for it is\n   the evals loop's: episodic memory *\"lets the system recall what it did and understand why it was\n   successful … that's really critical for doing the generalization\"*, which is a reading keyed to the\n   version that made it (T8) and a changed instruction voiding a proof.\n\n5. **Mental imagery as a precursor: embeddings never matched by rules** (same architectural placement).\n   *\"We're not going to match rules against what's in mental imagery space … extract relations and symbolic\n   structures from that deliberately.\"* The project: similarity is discovery, never authority; a cosine\n   proposes a candidate pair and the keeper's verdict writes the link; a phase stored per claim was tried\n   and found to find only flat denials (`resonance-db-and-negation.md`). **Where they part**: SOAR's imagery\n   is the agent's own; the project's embeddings are a model's average over many communities, nobody's\n   meaning (`why-representations-converge-and-whether-minds-do.md`), which is one more reason nothing\n   decides on them.\n\n6. **The language model at the edges, and the human asked** (a shared design move, with one caveat). An\n   interface that turns language into structure (*structure is output, never input*, the inversion\n   principle) and a knowledge source whose answers are checked before use; *\"we always ask the human …\n   is this right?\"* is consent, a person ruling on a rendering of their own position, and his shift from\n   *\"tell me every step\"* to *\"is this right\"* is the first-take screen's shape. **The caveat**: his check\n   is *\"multiple retrievals from the language model to make sure it's consistent\"*; the corpus measured\n   that a model agreeing with itself is steadiness, not rightness (it answered the wording, eighteen of\n   thirty links changing side under a second question), and that a second model is not a second\n   observation (R7). Consistency across retrievals is where his check stops and the project's begins.\n\n7. **Working memory is a context that is changed, not accumulated** (an analogy for the sessions). His\n   contrast with a language model's context names the difference between a transcript that grows and a\n   state that is maintained: the corpus graph asked before writing, and the briefing a session is handed,\n   are attempts to give a session the second kind.\n\n8. **Efficiency prunes designs** (same lesson, one instance here). The test of every query's plan (a graph query starts\n   at the node it names, measured 18.7 of 19.6 seconds in one query), the keeper's pair ceiling, and the\n   embedded engine for tests are the project's *\"not asking the system to doing quadratic … computations\n   under the hood\"*; his *\"having too many constraints … lets you get rid of a lot of different\n   possibilities that aren't going to scale\"* is why the budget is weighed before a sweep.\n\n9. **Copycat and SOAR: two architectures the corpus now borrows from** (a comparison, no equivalence). The\n   analogy daemon is Copycat re-described (codelets, the Slipnet, temperature; `the-analogy-daemon.md`);\n   SOAR gives what Copycat does not: a decision cycle with a fixed procedure, impasses as first-class\n   events, and learning by compiling a subgoal. The two sit at different levels, Copycat inside one\n   perception, SOAR across a whole agent, and the corpus owes neither its authority.\n\n10. **Newell's two maxims, together** (the method, not a finding). *Listen to the architecture* says how a\n    capability is added; *keep your eye on the main chance* says which. Together they are the READ FIRST\n    ordering and the order of work at the top of `TODO.md`: a capability enters only where the main\n    question needs it, and through what exists.\n\n---\n\n## 4. Where the analogy must not be pushed\n\n- **SOAR's knowledge is one agent's.** Its rules are not attributed, do not contradict each other as\n  content, and are not read by a stranger. Every operation the project does to a claim (count, attack,\n  update, show, attribute) has no counterpart on a SOAR rule, so by BD13 the two are never called one.\n- **An impasse resolves inside the mind that met it.** The project's gaps are met by a different mind than\n  the one that left them, which is the whole point (*what is invisible from inside a position is visible\n  from outside it*); a design that let the machine resolve its own impasses to a verdict would be the\n  steering hazard.\n- **Chunking has no confession.** A chunk is a rule learned and trusted; the project's reuse of a rule is a\n  claim anyone may attack. Only the storage move transfers, not the trust.\n- **The level of fifty milliseconds is his, not ours.** Nothing in the project is at the grain of one human\n  decision cycle; the analogy runs at the level of architecture, where a capability enters, not of timing.\n\n---\n\n## 5. Proposals (unruled, filed here only)\n\n1. **The *listen to the architecture* test, before any new stored property, label or link type** (RULED the same morning, *\"Yes, make it a gotcha. It should be a strong directive/principle.\"*; ledger BL1; the four checks and the line: `parsimony-and-the-core-data-model.md`). Ask the\n   sort's four questions in order (claim; record; reading; form), and admit a new kind only where some\n   operation the project does to claims does not apply to it (BD13's converse). Worked on two cases:\n   the `:Record` label passed (a query for `:Claim` must miss a cut whole, an operation that differs);\n   `trust_tier` fails (nothing reads it). Where it would live: a hard-won gotcha in CLAUDE.md, which needs\n   his blessing, or `docs/graph-properties.md`, whose test already demands a definition per property.\n2. **Name a microtask's non-answers as SOAR names impasses.** Three kinds, each routed to its subgoal: *no\n   candidate* (the gate's no; a wider search), *a tie* (two renderings; the keeper), *cannot apply* (the\n   claim cannot be cut or the chain cannot be written; a split or a refused verdict). Mostly built, scattered\n   (`bearing`, `cant_tell`, `does_not_fit`, AM1's refusal); the proposal is to register them per microtask in\n   `standing_work.MICROTASKS` with the subgoal each raises, so a non-answer is an event the standing work reads,\n   never a silence.\n3. **Reuse of a machine's rule by meaning, not only by wording.** `machine_sentences.py` reuses a rule whose\n   normalised wording matches; the keeper's confident *same* on two rule claims is the chunk that SOAR would\n   have compiled once. Hold until the keeper's held-out pairs are read (his order), since a wrong *same*\n   between rules spreads a leap under every link that reuses it.\n4. **A line for the method, if he wants one**: *A capability enters Deliberus through what is already\n   there, a claim, a link, a row in the record or a reading, and a stored property that encodes a judgment\n   or a state is the sign that it did not.* Graded demonstrated (the five rows of the table of properties bolted on).\n   Candidate for the gotchas, not the canon: it governs how we build, not what we hold.\n\n---\n\n## 6. What was not checked\n\n- SOAR's preference vocabulary, its impasse types and the expensive-chunks literature are from training,\n  survey-grade, and should be read in Laird's book before any of § 3's points 1 to 3 reach a public page.\n- No fine timestamps: the windows are Spotify's chapters, and the passage he asked about is placed by his\n  own paste.\n- Whether SOAR's current work on metacognition (his AGI conference paper, mentioned in passing) bears on\n  the project's confession principle was not looked at.\n\n## 7. Sources\n\n- *The Cognition Project* ep. 24, *\"Soaring: John Laird\"*, 2026-10-22, 38:23; audio from the Acast feed,\n  transcript in `sources/podcasts/cognition-project-024-laird-soar-2026-10-22.md`.\n- Corpus homes cited: `claim-or-system.md`, `the-kind-of-mistake-we-make.md`,\n  `machine-work-as-a-standing-property.md`, `claims-and-code-one-loop.md`, `taxonomy-gaps-and-the-closed-enum.md`,\n  `latent-scaffolding-and-the-type-token-split.md`, `the-analogy-daemon.md`,\n  `perceiving-possibility-and-the-analogy-organ.md`, `one-inference-per-link.md`,\n  `storing-the-record-of-machine-judgments.md`, `what-belongs-in-the-ontology.md`,\n  `resonance-db-and-negation.md`, `why-representations-converge-and-whether-minds-do.md`,\n  `self-similar-decomposition-and-claim-ontology.md`; ledger rows AG12, AM1, AM5, AT1, BC1, BD13, BI2, BI4,\n  Q31, Q32, Q33, R7, T8, AJ4.\n\n## From the Topic Index\n\n*The `CLAUDE.md` Topic Index entry that pointed here, word for word as it stood on 2026-11-15, before the index was trimmed to the warnings only it carries. The index keeps a short entry; the full text lives here.*\n\n- **\"Listen to the architecture\" / SOAR, impasses and chunking / a new capability through what exists / which stored properties the project should never have added** → `docs/research/soar-listen-to-the-architecture.md` (2026-11-09; no ledger rows of its own; it led to Arc BL). Newell's maxim is the sort of `claim-or-system.md` § 3 as a procedure (claim, record, reading, form); the project followed it for reference classes, machine sentences, horizon kinds and the record, and bolted on and paid with `confirmed`, link `strength`, the stored terminus and the yellow link. The impasse that becomes a subgoal is the gap that becomes a descent, and SOAR raises an impasse architecturally where the project asks a model to confess; chunking is one rule under many links (built by wording); the episodic memory Laird added after *Memento* is the record and, for the sessions, the corpus graph. **Do not call SOAR's rules claims**: by BD13 no operation the project does to a claim applies to them.\n"}