diff --git a/ideas/lisp-provers-and-rust-comparison.org b/ideas/lisp-provers-and-rust-comparison.org
index ec06c09..1365048 100644
--- a/ideas/lisp-provers-and-rust-comparison.org
+++ b/ideas/lisp-provers-and-rust-comparison.org
@@ -14,7 +14,9 @@ Two properties cannot be eliminated without changing what Lisp is:
 - GC pauses — everything is a tagged pointer on the heap; mitigatable (generational, concurrent collectors) but not eliminatable
 - No memory model / no Send/Sync — threads share everything by default; concurrency correctness is a discipline enforced by code review or a prover, not by the compiler
 
-These are real. Lisp will not replace Rust for real-time audio, kernel drivers, or embedded systems where every allocation is deterministic. For everything else — knowledge management, protocol synthesis, agent coordination, interactive systems — GC pauses at predictable intervals are acceptable.
+These are genuine costs, but they are contingent on hardware, not laws of nature. The Symbolics Genera OS was a full operating system written in Lisp — device drivers, window system, TCP/IP, filesystem — running on the Ivory processor with hardware tag checking and single-cycle CONS allocation. Lisp was a systems language; the chip was designed for it. The reason Lisp's GC pauses are costly on modern silicon is that CPUs are optimized for C's memory model: 64-byte cache lines for structs, prefetchers for linear access, TLBs for contiguous layout. A RISC-V Lisp extension (~50K gates) eliminates the mismatch entirely.
+
+Without dedicated silicon, Lisp on commodity hardware has larger memory overhead and less predictable pause times than C or Rust on allocation-heavy workloads. For Passepartout's use cases — knowledge management, protocol synthesis, agent coordination, interactive systems — modern concurrent generational GCs (single-digit millisecond pauses) are acceptable.
 
 ** Fixable gaps (implementation and ecosystem, not language philosophy)
 
diff --git a/projects/cl-modernization/_index.org b/projects/cl-modernization/_index.org
index 7b20275..2e4271a 100644
--- a/projects/cl-modernization/_index.org
+++ b/projects/cl-modernization/_index.org
@@ -28,7 +28,9 @@ The central claim: Lisp's defects are not fundamental. They are deferred ecosyst
 - Ecosystem scale (a network effect, fixable with sustained effort)
 #+END_QUOTE
 
-The first category — GC pauses and shared-state concurrency — is real. Lisp will never be a systems language in the Rust sense for those two reasons. But for everything Passepartout does (knowledge management, protocol synthesis, agent coordination, verification), GC pauses at predictable intervals are acceptable. The second category is what this project fixes.
+The first category — GC pauses and shared-state concurrency — is a genuine engineering constraint, but it is contingent on hardware, not a law of nature. Symbolics' Genera OS was a full operating system written in Lisp — device drivers, window system, TCP/IP, file server, all running on the Ivory processor with hardware tag checking, generational write barriers at cache level, and single-cycle CONS allocation. Lisp was a systems language; the chip was designed for it. The reason Lisp struggles on modern silicon is that 40 years of CPU design — cache lines (64 bytes for C structs), prefetchers (linear access patterns), TLBs (contiguous layout), branch predictors (C's control flow) — has been optimized for C's memory model, not for tagged pointer architectures. A RISC-V extension with ~50K additional gates (CONS with write barrier, tag dispatch, read barrier, tag extract, GC check) eliminates the hardware mismatch, as analyzed in [[id:dddd52a7-adb8-470e-a459-614ade5f76af][Closing the Lisp Gap]].
+
+Without dedicated silicon, Lisp on commodity hardware has larger memory overhead and less predictable pause times on allocation-heavy workloads than C or Rust. For everything Passepartout does — knowledge management, protocol synthesis, agent coordination, verification — modern concurrent generational GCs (single-digit millisecond pauses) are entirely acceptable. The second category — the ecosystem gap — is what this project fixes.
 
 * Why Lisp Is a Uniquely Good Candidate