amr/hermes-brain
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

estimates: LOC and dev time for self-driving Lisp Machine

Browse Source 
- Current Passepartout: ~10,700 lines, 2 months one dev
- To v1.0.0: +4,500 lines, 4-6 months
- Lisp Machine hardware integration: +6,000 lines, 3-6 months
- Total: ~21,000 lines, 9-14 months one dev, 5-7 months team of 2-3
- Why small: Lisp is 3-10x denser, primitives are reused across
  domains, ACL2 proofs replace test fixtures, LLM generates boilerplate
- Comparison: Hermes ~50K, Claude Code ~100K, Llama.cpp ~200K
- Not a moonshot. A well-scoped engineering project.
This commit is contained in:
Hermes
2026-05-21 19:05:28 +00:00
parent 80daaa4830
commit d48925de23
1 changed files with 108 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

108
ideas/passepartout-economics.org
View File

@@ -959,6 +959,114 @@ a RISC-V cross-compiler, and one patient human who reviews the
contrastive queries can achieve a self-driving Lisp Machine in contrastive queries can achieve a self-driving Lisp Machine in
under a month. under a month.
*** Size and development time estimates
These are order-of-magnitude estimates based on the existing
architecture and the roadmap's line-count breakdowns. The numbers
are small because Lisp is more expressive, the architecture reuses
primitives across domains, and the symbolic engine replaces what
would be thousands of lines of Python in a conventional agent.
**** Current Passepartout (v0.7.2, main branch)
| Component | Lines of Lisp | Status |
|-----------|---------------|--------|
| Core pipeline (perceive-reason-act, memory, skills, transport, package) | ~1,800 | Built and running |
| Gate stack (security dispatcher, permissions, policy, vault, validator) | ~900 | Built and running |
| Neuro (provider router, provider dispatch, token economics, tokenizer) | ~900 | Built and running |
| Programming tools (lisp, org, repl, literate, standards, tools) | ~1,600 | Built and running |
| Symbolic (archivist, awareness, memory, scope, events, identity, self-improve) | ~1,200 | Built and running |
| Channels (TUI main/state/view, CLI, Telegram, Signal, Discord, Slack) | ~2,300 | Built, on refactor branch |
| TUI (cl-tty migration, ongoing) | ~1,300 | In progress on refactor branch |
| Config, diagnostics, embedding, sensors, integration tests | ~700 | Built and running |
| **Total existing** | **~10,700** | |
Development time to reach v0.7.2: approximately 2 months,
one developer (April-May 2026 from git log).
**** New code to reach v1.0.0 (Neurosymbolic Maturity)
| Phase / Feature | Lines | Est. dev time (one dev) |
|-----------------|-------|------------------------|
| v0.8.0 TUI stabilization (cl-tty) | ~500 | 3-4 weeks |
| v0.9.0 Eval harness + sandbox hardening | ~200 | 1-2 weeks |
| v0.11.0 Phase 0 (type-level gates, core integrity) | ~75 | 3-5 days |
| v0.13.0 Phase 0b (signal authentication, Layer 1) | ~200 | 1-2 weeks |
| v0.15.0 Phase 1 (fact store with provenance) | ~200 | 1-2 weeks |
| v0.17.0 Phase 1a (self-preservation, quarantine, watchdog) | ~120 | 1 week |
| v0.19.0 Phase 2 (Screamer admission gate) | ~200 | 1-2 weeks |
| v0.21.0 Phase 3 (archivist as fact proposer) | ~100 | 1 week |
| v0.23.0 Phase 4 (sufficiency criterion, the Flip) | ~50 | 2-3 days |
| v0.26.0 Phase 5 (VivaceGraph, Merkle DAG, ontology versioning) | ~400 | 2-4 weeks |
| v0.28.0-28.5 Phase 6 (ACL2 base + 5 macro layers) | ~540 | 3-4 weeks |
| v0.37.0 Phase 7 (10-80-10 planner) | ~500 | 3-4 weeks |
| All polish features (skins, export, CLI, MCP, LSP, telemetry, cost, etc.) | ~1,500 | 4-8 weeks |
| Integration testing, hardening, bug fixes | — | 4-8 weeks |
| **Total new code at v1.0.0** | **~4,500** | **4-6 months (one developer)** |
**** Additional code for a self-driving Lisp Machine
| Component | Lines | Est. dev time (one dev) |
|-----------|-------|------------------------|
| RISC-V microcode for Lisp dispatch (tagged memory, GC barriers, cons cells) | ~3,000 | 1-2 months |
| PCIe DMA driver from SBCL (C + sb-alien FFI) | ~500 | 2-4 weeks |
| Tenstorrent Tensix core management (allocate, load, benchmark) | ~1,500 | 3-4 weeks |
| Profiling and benchmark harness (Phase 4 applied to hardware) | ~500 | 1-2 weeks |
| Microcode synthesis from ACL2-verified specifications | ~500 | 2-4 weeks |
| **Total for Lisp Machine hardware integration** | **~6,000** | **3-6 months (one developer)** |
Notable: the microcode for Lisp dispatch (~3,000 lines of RISC-V
assembly) is smaller than the existing Lisp codebase. The hardest
part is not the assembly — it's the verification that the assembly
correctly implements the Lisp primitives, which ACL2 handles.
**** Total system at self-driving threshold
| | Lines of code | Dev time (one dev) | Dev time (small team, 2-3) |
|---|---|---|---|
| Passepartout v0.7.2 | ~10,700 | 2 months (done) | 1 month (done) |
| To v1.0.0 | +~4,500 | 4-6 months | 2-3 months |
| Lisp Machine hardware | +~6,000 | 3-6 months | 2-3 months |
| **Total** | **~21,000** | **9-14 months** | **5-7 months** |
**** Why the numbers are small
- **Lisp is 3-10x more compact than C++ or Python** for the same
semantics. The entire gate stack (900 lines) would be 3,000-5,000
lines of Python with middleware classes and serialization glue.
- **The architecture reuses primitives cross-domain.** The Merkle
tree, the gate stack, the fact store, the ACL2 prover — each is
built once and shared by all features. There is no "compliance
package" that duplicates the "refactoring package" infrastructure.
- **The symbolic engine replaces test code.** A conventional agent
needs thousands of lines of test fixtures for behavior validation.
ACL2's proofs replace those. The tests are the theorems.
- **The LLM generates the boilerplate.** The LLM writes gate rules,
macro layer templates, and migration scripts. The symbolic engine
verifies them. The human reviews the 5% edge cases. The bottleneck
is verification throughput, not code writing.
**** Comparison with other systems
| System | Lines | Developer-years |
|--------|-------|-----------------|
| Hermes Agent | ~50,000+ | 2+ years, ~3 devs |
| Claude Code | ~100,000+ (estimated) | 3+ years, large team |
| Llama.cpp | ~200,000 | 2+ years, many contributors |
| **Passepartout self-driving** | **~21,000** | **~1 year, 1-3 devs** |
| Symbolics Genera (1980s Lisp OS) | ~1,000,000 | ~10 years, large team |
The Symbolics comparison is instructive: they built a full Lisp
operating system from scratch in assembly and Lisp, with graphical
interface, networking, file system, and development environment.
Passepartout runs on Linux, which provides the OS layer for free.
The Lisp Machine hardware integration is a PCIe card, not a
replacement of the entire host. The scope is dramatically smaller.
The surprising result: **a self-driving Lisp Machine is a ~21,000
line project for a small team working less than a year.** Not a
billion-dollar moonshot. A well-scoped engineering project.
Large refactoring projects (extract module, rename API, split monolith) Large refactoring projects (extract module, rename API, split monolith)
are the hardest test for any AI agent. Current approaches (Claude Code, are the hardest test for any AI agent. Current approaches (Claude Code,
Copilot) handle them probabilistically — every step costs tokens, and Copilot) handle them probabilistically — every step costs tokens, and