You now have: mechanism (43-46), runtime stack (47-50), governance (51-55), operator loops (Part IX), and compile-first memory (60). The remaining failure mode is organizational: one repo-wide agent with every tool, rewriting gate weights while fixing a UI typo, promoting overlays because the narrative sounded confident. Practitioner literature from 2025-2026 converges on three independent lines - all subordinate to CFES (gate on expected value, persist each prediction at the moment it's made, and judge policies over batches of outcomes, never a single trade):
Figure 1. Concept map for this appendix entry: fight, desk translation, what to lock.
The fog machine: why "one agent to rule them all" fails
Connect every tool, every file, and every API to a single long-horizon agent and three failures appear quickly: scope drift, where the agent "helps" outside the task it was given and edits gate weights while fixing a UI typo; an accountability vacuum, where nobody owns a bad promotion because the agent that made it isn't a person; and context rot, where rewriting the whole context in one shot quietly drops details that mattered. The Matrix operating blueprint (2026 practitioner synthesis) states the alternative explicitly: not one agent - an org chart for autonomous work. The org chart is not cosmetic. It enforces boundaries (who may edit what), memory skills (what to read before acting), and proof (what must be measured before any work counts as done).
Five layers of an agent company OS
Map the operating blueprint to finance infrastructure as follows: a workspace brain holding the shared operating context (product docs, conventions, approval rules, examples of good work - referenced, not reloaded every session); a runtime that coordinates wake schedules, permissions, and model routing; department verticals, each a long-running concern with its own Memory Skill; a worker pool of narrow, disposable execution seats for batch jobs and one-off tasks; and a proof loop that ties every artifact to a check-in criterion before it updates memory. The layers exist so that no single agent ever holds unscoped access to everything at once.
Agentic Context Engineering (ACE): playbooks that grow without collapsing
Zhang et al. (Agentic Context Engineering, arXiv:2510.04618, 2026) formalise a failure mode every long-running agent system hits: context collapse. When an LLM is asked to rewrite the entire context each adaptation step, the context shrinks - 18k tokens to 122 tokens in one AppWorld case study - and accuracy cliffs below the no-adaptation baseline.
Karpathy LLM Wiki vs chunk RAG: compounding knowledge
Karpathy's LLM Wiki pattern (2026) and Appendix F.5's compile-first memory share a gene: ingest → revise structured state → query pre-built synthesis. Humans abandon wikis because maintenance grows faster than value. LLMs do not get bored updating fifteen cross-references - if the schema tells them how.
Definition
A Memory Skill is a department-scoped playbook (typically one markdown file) loaded before action. It encodes boundaries, definition of done, proof commands, and anti-patterns. It replaces reading forty unrelated AGENTS files.
Worked picture
Two automation channels - primary book and evening batch book - share code but not raw labeled rows. Transfer briefs write a markdown handoff: gate floors to copy, execution IDs to not copy, suggested evaluate commands. You fork the pattern, not the P/L context - holdout discipline preserved.
What breaks in production
Giving an agent more tools is not giving it more edge. Edge comes from labeled independent outcomes and honest scoring. Tools without evaluate() are theatre.
The loop is the product
Autonomy without proof is a fog machine. A specialist platform compounds through scoped workers, evolving playbooks, and ledger-graded promote gates - not one repo-wide agent with every tool.