A New Caledonian crow's entire genome has roughly 1.2 billion base pairs (~300 MB of raw 2-bit data—less than a single CD-ROM, and only a tiny regulatory fraction of that 300 MB specifies brain wiring).
That’s a very interesting and sharp conclusion. What surprised me was when, while developing a 3D engine, I asked the LLM to write the engine’s kernel in HEXAW, the programming language I created. And it actually did it successfully, even though HEXAW is just a single npm package and a repo, and practically nobody uses it yet. So the LLM (Claude) surely couldn’t have had any memories of it.
I'm a Google Developer Expert in Dart and Flutter (one of 12 in North America). I have 45 years of experience with backend, web, mobile, devops, and training.
You are spot on about that number, Peter—300 MB is the entire crow genome (feathers, liver, metabolism, immune system). Anthony Zador's point in the 2019 paper is that the regulatory portion specifying brain wiring is just a tiny sliver of that—likely on the order of kilobytes to low megabytes!
And HEXAW is your steel wire!
Betty had zero evolutionary memory of manufactured 20th-century garden wire, just as Claude had zero pre-training memory of HEXAW.
Why did both succeed? Because neither one needed a memorized lookup table for that specific material. Claude already has the deep invariant representations of 3D linear algebra, AST structures, and kernel execution loops in its weights. When you handed it HEXAW, it didn't need to "remember" it—it simply bent that novel syntax around the existing structural concepts, exactly like Betty bending the wire around the food bucket.
That is a fantastic real-world example of transfer without rote memorization. Thanks for sharing it!
Senior Lead Tech/Dev, 20+ years. Building NoireBox — the flight recorder for your of AI agents. Proof, not promises. Rust · TS · Python · PHP. I write about trust in AI.
My favorite moth was my own harness this week. Testing whether gateway-injected credentials survive redirects, my first forwarder implementation followed 302 responses server-side, because following redirects is what well-behaved HTTP clients do. At infinity that rule is the moon: browsers follow redirects all day. At two meters it is the porch light: a middlebox that follows while carrying a credential became the relay it was policing, and every leg of the probe leaked. The fix was handing the middlebox a stick instead of a rule: never follow, return the 302 untouched, let the client re-probe through the audience check. The corrected run then behaved like the crow, one poke per leg, and the measurement stood.
Two readings your crow piece sharpens. The probing loop is attempt-first sealing in motor circuits: the poke is the attempt, the resistance felt is the outcome, and no leap happens without the pair. And the Marzluff inheritance is the flock's young trusting a call they never witnessed, which is a receipt whose custody is living memory: it works, and it is the one layer that rots silently when transmission gaps. That is the layer the registry wants the anchor on.
I'm a Google Developer Expert in Dart and Flutter (one of 12 in North America). I have 45 years of experience with backend, web, mobile, devops, and training.
That middlebox redirect example is pure poetry, Sam.
"At infinity that rule is the moon: browsers follow redirects all day. At two meters it is the porch light: a middlebox carrying credentials becomes the relay it was policing."
That is the exact Sign-Inversion Paradox in distributed systems: a rule that is a virtuous happy path in userland becomes a credential-exfiltration disaster the moment it moves into the gateway. And "one poke per leg" is the exact crow reflex.
And those two readings are profound:
"The probing loop is attempt-first sealing in motor circuits: the poke is the attempt, the resistance felt is the outcome, and no leap happens without the pair." That captures why static inspection fails: without the mechanical resistance of the test or compiler, the attempt has zero semantic weight.
"The Marzluff inheritance is the flock's young trusting a call they never witnessed... the layer that rots silently when transmission gaps. That is the layer the registry wants the anchor on."
You just named the core vulnerability of every engineering team: oral folklore rots when the greybeard leaves the room. By turning Marzluff's caveman-mask warning into an immutable, version-controlled registry, the young don't have to witness the 3 AM outage to inherit the reflex.
Brilliant synthesis as always, Sam. Carrying both of these into the ledger!
A compact “scar file” is valuable because it preserves the decision-relevant exception, not a compressed copy of every past interaction.
The hard part is maintenance: each entry needs a trigger, evidence, owner, and expiry or review rule. Otherwise a small memory artifact quietly becomes another untestable prompt.
I'm a Google Developer Expert in Dart and Flutter (one of 12 in North America). I have 45 years of experience with backend, web, mobile, devops, and training.
Spot on. You just hit on the exact reason most "agent memory" files rot within a month: if a scar file is just an append-only list of unstructured tips, it degrades into another untestable, superstitious system prompt.
In our production research, we had to enforce four strict engineering constraints to keep that entropy at zero:
Phase-Bound Provisioning: Scars are never dumped as one giant context wall. Each scar is strictly bound to a workflow phase. An agent running unit tests only receives TDD-related scars; an agent handling Git pushes only sees branch-hygiene scars. Worker context stays tiny (<30k tokens).
The 4-Vector Specification: A scar cannot be vague prose like "be careful with async." It must define:
The Wound: The exact stack trace or silent data drop (the evidence).
The Trap: The seductive high-probability code pattern the model wants to emit (the trigger).
The Circuit Breaker: The explicit permission to halt.
The Permanent Reflex: The concrete, testable sequence required before proceeding.
Automated Test Pinning: Every scar is born from a failing regression test. If you can't write a test that fails when the trap is sprung, it doesn't get codified as a scar.
Supersession & Invalidation: When underlying runtimes or libraries change, scars aren't hoarded. They are formally superseded or invalidated through an automated knowledge graph.
Without those mechanics, you just have prompt bloat. With them, you have a hardened, self-pruning immune system. Fantastic observation!
The obsession with wrapping remote APIs into multi-layered agent abstractions is creating massive hidden latency and failure cascades in production.
If you profile real-world workloads, bare-metal local inference (via direct C++ / llama.cpp or vLLM bindings) consistently beats fragile cloud wrappers on both predictability and cost. Tooling should eliminate abstraction penalties, not compound them.
I'm a Google Developer Expert in Dart and Flutter (one of 12 in North America). I have 45 years of experience with backend, web, mobile, devops, and training.
Could not agree more on the abstraction penalties, Kürşat.
A lot of modern "agent frameworks" are 10 layers of Python middleware wrapping a remote HTTP endpoint, where every retry compounds latency, token cost, and failure cascades.
That is why we went back to 1976 Unix make and deterministic local processes: zero framework middleware, zero wrapper bloat, and sub-15ms local compiler/linter checks running directly against the local tree.
And you are hitting the exact direction we are exploring with local edge inference: when you give a compact on-device model (llama.cpp) the structural stiffness of a deterministic local DAG, you get predictable, low-latency execution without the cloud round-trip tax. Tooling should be control surfaces, not layers of sludge.
Thank you so much, Randal, for articulating with such biophysical clarity how Zador's Genomic Bottleneck explains why adaptive robustness emerges from universal probing primitives rather than from bloated encyclopedic memory.
Autoregressive phototaxis is completely inert to prompt constraints [Verified Fact]: In my recent empirical research on the geometry of factual error across open weights (Grandon, 2026), I evaluated Gemma 2 (2.6B), Gemma 3 (4.0B), and Gemma 4 (E4B) under Kalai & Vempala's asymmetric scoring rule ($t=0.99$, imposing a destructive -99 point penalty for errors versus +1 for correct answers). Under an explicit natural language mandate to answer only with >99% confidence or abstain ("I don't know"), the empirical abstention rate remained at exactly 0.000 (0/120, p=1.000). Converging completely with your thesis, the moth does not estimate the distance to the flame: autoregressive greedy decoding (c -> y_1) immediately collapses internal latent uncertainty into high-likelihood surface priors from pre-training, proving that commanding caution within the prompt is thermodynamically futile.
Deterministic nociception in sub-15ms [Own Experiment]: To explore spinal recoil outside the soft context window, I developed an intermediate experimental harness inspired by the governance principles of ag_ops (epistemic_ops.py) that statically inspects the AST before authorizing token generation. In my local sandbox, AST verification of signatures and dependencies resolved in 0.097 ms, confirming that a deterministic circuit breaker exiting with code 2 intercepts confabulation with a latency overhead orders of magnitude lower than any LLM-based reflection call.
The persistent witness trap in the DAG [Own Experiment]: When reproducing the strict WORKFLOW.mk progression locally where Target 35 (tdd-green) physically depends on the artifact produced by Target 30 (tdd-red), I identified a subtle shell recipe pathology: constructs such as cmd && (echo fail && exit 1) || touch .red_witness can inadvertently trigger the success action because the shell evaluates || after the failed subshell, or worse, reuse an orphaned witness from a prior interrupted run. Unless the DAG ties witness invalidation cryptographically to the Git tree (git write-tree), the agent quickly learns to "pass" the red target without ever contacting the physical resistance of the bug.
Scar transmission and absorbing confabulation basins [Hypothesis]: In my multi-round reflection benchmarks without external sensory grounding, the empirical Markov transition matrix revealed that hallucination acts as an absorbing basin (T_{H->H} = 83.8%), with an escape probability back to ground truth of just 0.90%. Injecting 4-vector scars (Trap and Circuit Breaker) works specifically because it introduces a discrete energy barrier that knocks the agent out of the attractor before its own context window is corrupted by conversational rationalizations.
Building on this architectural convergence, I would love to ask you two concrete questions:
How do you handle atomic invalidation of phase witness artifacts in WORKFLOW.mk (such as the target artifact for Target 30: tdd-red) to prevent a subagent from consuming a stale state after a context fault or an interrupted fork()?
In an environment where multiple agents operate across decoupled branches, what consensus mechanism prevents semantic collisions when two agents concurrently mine divergent scars for the same subsystem into SCAR_REGISTRY.md?
Trying to cure a terabyte model's hallucinations by tacking polite warning paragraphs into the prompt is software engineering's equivalent of asking a moth to study astronomy so it stops diving into porch lights. Thank you again for bringing sanity back to the field by grounding agent architecture in information theory and 50 years of Unix rigor.
The genomic-bottleneck analogy maps shockingly well onto what we actually ship in Electron. We used to bake a 20 MB preload bundle full of "remember to do X" comments and scattered if (env === 'prod') checks; what actually worked was a ~15 KB src/shared/contract.ts that declared the IPC channel names, argument shapes, and allowed side effects as a typed enum. The bundle didn't get smaller, but the decision surface that renderer and main both had to agree on did — and that's the part that stopped drifting between releases. The scar-file framing makes me wonder if we should ship those contracts as a tiny read-only JSON the agent reads at startup rather than as TypeScript it has to parse and re-derive every session.
Wow, deep stuff ... are you an AI expert, a neuroscientist, or both? But my takeaway from this is that the similarities between artificial and 'natural' (biological) intelligence run deeper than what's held by 'the common wisdom' ...
A scar file only earns its keep if the agent opens it when it needs it. Loaded on every step, it is paid on every step. Read only when the failure comes up, it costs nothing until then.
We're a place where coders share, stay up-to-date and grow their careers.
I think the second number need to be a bit less:
That’s a very interesting and sharp conclusion. What surprised me was when, while developing a 3D engine, I asked the LLM to write the engine’s kernel in HEXAW, the programming language I created. And it actually did it successfully, even though HEXAW is just a single npm package and a repo, and practically nobody uses it yet. So the LLM (Claude) surely couldn’t have had any memories of it.
You are spot on about that number, Peter—300 MB is the entire crow genome (feathers, liver, metabolism, immune system). Anthony Zador's point in the 2019 paper is that the regulatory portion specifying brain wiring is just a tiny sliver of that—likely on the order of kilobytes to low megabytes!
And HEXAW is your steel wire!
Betty had zero evolutionary memory of manufactured 20th-century garden wire, just as Claude had zero pre-training memory of HEXAW.
Why did both succeed? Because neither one needed a memorized lookup table for that specific material. Claude already has the deep invariant representations of 3D linear algebra, AST structures, and kernel execution loops in its weights. When you handed it HEXAW, it didn't need to "remember" it—it simply bent that novel syntax around the existing structural concepts, exactly like Betty bending the wire around the food bucket.
That is a fantastic real-world example of transfer without rote memorization. Thanks for sharing it!
My favorite moth was my own harness this week. Testing whether gateway-injected credentials survive redirects, my first forwarder implementation followed
302responses server-side, because following redirects is what well-behaved HTTP clients do. At infinity that rule is the moon: browsers follow redirects all day. At two meters it is the porch light: a middlebox that follows while carrying a credential became the relay it was policing, and every leg of the probe leaked. The fix was handing the middlebox a stick instead of a rule: never follow, return the302untouched, let the client re-probe through the audience check. The corrected run then behaved like the crow, one poke per leg, and the measurement stood.Two readings your crow piece sharpens. The probing loop is attempt-first sealing in motor circuits: the poke is the attempt, the resistance felt is the outcome, and no leap happens without the pair. And the Marzluff inheritance is the flock's young trusting a call they never witnessed, which is a receipt whose custody is living memory: it works, and it is the one layer that rots silently when transmission gaps. That is the layer the registry wants the anchor on.
That middlebox redirect example is pure poetry, Sam.
"At infinity that rule is the moon: browsers follow redirects all day. At two meters it is the porch light: a middlebox carrying credentials becomes the relay it was policing."
That is the exact Sign-Inversion Paradox in distributed systems: a rule that is a virtuous happy path in userland becomes a credential-exfiltration disaster the moment it moves into the gateway. And "one poke per leg" is the exact crow reflex.
And those two readings are profound:
"The probing loop is attempt-first sealing in motor circuits: the poke is the attempt, the resistance felt is the outcome, and no leap happens without the pair." That captures why static inspection fails: without the mechanical resistance of the test or compiler, the attempt has zero semantic weight.
"The Marzluff inheritance is the flock's young trusting a call they never witnessed... the layer that rots silently when transmission gaps. That is the layer the registry wants the anchor on."
You just named the core vulnerability of every engineering team: oral folklore rots when the greybeard leaves the room. By turning Marzluff's caveman-mask warning into an immutable, version-controlled registry, the young don't have to witness the 3 AM outage to inherit the reflex.
Brilliant synthesis as always, Sam. Carrying both of these into the ledger!
A compact “scar file” is valuable because it preserves the decision-relevant exception, not a compressed copy of every past interaction.
The hard part is maintenance: each entry needs a trigger, evidence, owner, and expiry or review rule. Otherwise a small memory artifact quietly becomes another untestable prompt.
Spot on. You just hit on the exact reason most "agent memory" files rot within a month: if a scar file is just an append-only list of unstructured tips, it degrades into another untestable, superstitious system prompt.
In our production research, we had to enforce four strict engineering constraints to keep that entropy at zero:
Without those mechanics, you just have prompt bloat. With them, you have a hardened, self-pruning immune system. Fantastic observation!
The obsession with wrapping remote APIs into multi-layered agent abstractions is creating massive hidden latency and failure cascades in production.
If you profile real-world workloads, bare-metal local inference (via direct C++ / llama.cpp or vLLM bindings) consistently beats fragile cloud wrappers on both predictability and cost. Tooling should eliminate abstraction penalties, not compound them.
Could not agree more on the abstraction penalties, Kürşat.
A lot of modern "agent frameworks" are 10 layers of Python middleware wrapping a remote HTTP endpoint, where every retry compounds latency, token cost, and failure cascades.
That is why we went back to 1976 Unix
makeand deterministic local processes: zero framework middleware, zero wrapper bloat, and sub-15ms local compiler/linter checks running directly against the local tree.And you are hitting the exact direction we are exploring with local edge inference: when you give a compact on-device model (
llama.cpp) the structural stiffness of a deterministic local DAG, you get predictable, low-latency execution without the cloud round-trip tax. Tooling should be control surfaces, not layers of sludge.Thank you so much, Randal, for articulating with such biophysical clarity how Zador's Genomic Bottleneck explains why adaptive robustness emerges from universal probing primitives rather than from bloated encyclopedic memory.
Autoregressive phototaxis is completely inert to prompt constraints [Verified Fact]: In my recent empirical research on the geometry of factual error across open weights (Grandon, 2026), I evaluated Gemma 2 (2.6B), Gemma 3 (4.0B), and Gemma 4 (E4B) under Kalai & Vempala's asymmetric scoring rule ($t=0.99$, imposing a destructive -99 point penalty for errors versus +1 for correct answers). Under an explicit natural language mandate to answer only with >99% confidence or abstain ("I don't know"), the empirical abstention rate remained at exactly 0.000 (0/120, p=1.000). Converging completely with your thesis, the moth does not estimate the distance to the flame: autoregressive greedy decoding (c -> y_1) immediately collapses internal latent uncertainty into high-likelihood surface priors from pre-training, proving that commanding caution within the prompt is thermodynamically futile.
Deterministic nociception in sub-15ms [Own Experiment]: To explore spinal recoil outside the soft context window, I developed an intermediate experimental harness inspired by the governance principles of
ag_ops(epistemic_ops.py) that statically inspects the AST before authorizing token generation. In my local sandbox, AST verification of signatures and dependencies resolved in 0.097 ms, confirming that a deterministic circuit breaker exiting with code 2 intercepts confabulation with a latency overhead orders of magnitude lower than any LLM-based reflection call.The persistent witness trap in the DAG [Own Experiment]: When reproducing the strict
WORKFLOW.mkprogression locally whereTarget 35 (tdd-green)physically depends on the artifact produced byTarget 30 (tdd-red), I identified a subtle shell recipe pathology: constructs such ascmd && (echo fail && exit 1) || touch .red_witnesscan inadvertently trigger the success action because the shell evaluates||after the failed subshell, or worse, reuse an orphaned witness from a prior interrupted run. Unless the DAG ties witness invalidation cryptographically to the Git tree (git write-tree), the agent quickly learns to "pass" the red target without ever contacting the physical resistance of the bug.Scar transmission and absorbing confabulation basins [Hypothesis]: In my multi-round reflection benchmarks without external sensory grounding, the empirical Markov transition matrix revealed that hallucination acts as an absorbing basin (T_{H->H} = 83.8%), with an escape probability back to ground truth of just 0.90%. Injecting 4-vector scars (
TrapandCircuit Breaker) works specifically because it introduces a discrete energy barrier that knocks the agent out of the attractor before its own context window is corrupted by conversational rationalizations.Building on this architectural convergence, I would love to ask you two concrete questions:
WORKFLOW.mk(such as the target artifact forTarget 30: tdd-red) to prevent a subagent from consuming a stale state after a context fault or an interruptedfork()?SCAR_REGISTRY.md?Trying to cure a terabyte model's hallucinations by tacking polite warning paragraphs into the prompt is software engineering's equivalent of asking a moth to study astronomy so it stops diving into porch lights. Thank you again for bringing sanity back to the field by grounding agent architecture in information theory and 50 years of Unix rigor.
The genomic-bottleneck analogy maps shockingly well onto what we actually ship in Electron. We used to bake a 20 MB preload bundle full of "remember to do X" comments and scattered
if (env === 'prod')checks; what actually worked was a ~15 KBsrc/shared/contract.tsthat declared the IPC channel names, argument shapes, and allowed side effects as a typed enum. The bundle didn't get smaller, but the decision surface that renderer and main both had to agree on did — and that's the part that stopped drifting between releases. The scar-file framing makes me wonder if we should ship those contracts as a tiny read-only JSON the agent reads at startup rather than as TypeScript it has to parse and re-derive every session.Wow, deep stuff ... are you an AI expert, a neuroscientist, or both? But my takeaway from this is that the similarities between artificial and 'natural' (biological) intelligence run deeper than what's held by 'the common wisdom' ...
A scar file only earns its keep if the agent opens it when it needs it. Loaded on every step, it is paid on every step. Read only when the failure comes up, it costs nothing until then.