# Metabolism Model **Status:** Concept v0.1, exploratory. Part of the information-organism lens (INTENT.md, Two Lenses). --- **Originating question:** > Good, can we describe what we discuss through the lens of how a metabolism for information organsms looks like. What is the substrate we need? I am thinking information artifacts, compute allowances, runtime environments etc. Yes. I think **metabolism** is the right lens because it forces us to distinguish the organism from the material and energy flows that sustain it. For an information organism, metabolism is not just “running inference.” It is the complete cycle by which the organism acquires information and resources, transforms them into internal structure and useful action, expends scarce capacity, and disposes of or compresses what is no longer useful. > **Information metabolism is the regulated conversion of environmental information, compute, time, storage, authority, and attention into internal models, decisions, actions, and externally useful effects.** ### 1. The basic metabolic equation An information organism consumes: ```text information artifacts + compute + storage + runtime capacity + external services + human attention + authority + time ``` and produces: ```text interpretations predictions decisions actions new information artifacts learned structure coordination environmental change ``` plus waste: ```text obsolete memory failed hypotheses redundant representations logs temporary embeddings dead branches unused intermediate results compute heat/cost ``` At the highest level: ```text SUBSTRATE ↓ METABOLISM ↓ USEFUL WORK + LEARNED STRUCTURE + WASTE ``` ### 2. Substrate vs nutrients The **substrate** is what makes metabolism possible. The **nutrients** are what the organism consumes during operation. **Substrate** ```text runtime environment storage execution engine network connectivity identity credentials resource accounting semantic membrane ``` **Nutrients** ```text documents events messages prompts data compute budget API allowance human feedback ``` ### 3. Six fundamental substrate layers ```text 1. Information substrate 2. Computational substrate 3. Memory substrate 4. Execution substrate 5. Interaction substrate 6. Governance substrate ``` ### 4. Information substrate Raw informational material: ```text documents database records events messages source code telemetry images schemas contracts policies API responses human statements ``` The membrane converts raw information artifacts into metabolically accessible information. ### 5. Compute is the energy substrate Compute comes in forms such as: ```text CPU GPU accelerator time LLM tokens database queries network transfer external API calls ``` These can often be translated into a common economic resource: ```text cost ``` or: ```text compute credits ``` ### 6. Prompts are more like hormones than nutrients Prompts modulate processing. They alter: ```text goal activation attention sampling resource allocation ``` So: ```text Prompt → metabolic direction Budget → metabolic capacity ``` ### 7. Runtime is the physical habitat/body substrate The organism must exist somewhere: ```text container VM Kubernetes workload serverless process agent runtime database message broker filesystem network namespace ``` The runtime provides execution, isolation, scheduling, resource limits, connectivity, and persistence. ### 8. Memory is metabolically expensive tissue Retained information has costs: ```text storage indexing retrieval maintenance security context pollution ``` The organism should decide when to retain, compress, summarize, generalize, forget, or archive. ### 9. Information digestion ```text raw artifact ↓ accessible representation ↓ decoded content ↓ semantic claims ↓ relevant observation ↓ internal activation ``` This suggests **information digestibility**. ### 10. Metabolic pathways Examples: **Retrieval pathway** ```text question → identify information need → query source → retrieve artifact → project semantics → answer ``` **Classification pathway** ```text incoming artifact → decode → extract features → compare patterns → classify → emit event ``` **Planning pathway** ```text goal → construct alternatives → predict consequences → evaluate → select ``` **Learning pathway** ```text episodes → detect regularity → form hypothesis → test → strengthen structure ``` ### 11. Enzymes have a useful computational analogue Equivalent computational enzymes: ```text tools models functions agents parsers indexers retrievers reasoners classifiers ``` A regex is cheap and specialized. An LLM is general but expensive. A useful organism learns which transformation mechanism is appropriate. ### 12. Compute allocation becomes metabolic regulation A central rule: > **Use the least expensive metabolic pathway expected to achieve sufficient confidence and utility.** ### 13. Resource currencies Do not collapse everything into money. Important currencies include: ```text compute latency storage bandwidth human attention external API quota risk budget authority money ``` ### 14. Authority is also a metabolic resource Being allowed to read, write, approve, send, delete, purchase, or deploy changes what the organism can accomplish. ### 15. Human attention is premium energy Human attention should probably have a much higher shadow price than ordinary compute. The organism should learn when to interrupt, ask, escalate, or continue independently. ### 16. Homeostasis becomes resource regulation The organism should maintain variables such as: ```text compute_remaining memory_pressure queue_depth latency uncertainty human_attention_budget error_rate ``` within useful ranges. ### 17. Starvation and abundance should change behavior Under scarcity: ```text more reuse more compression less exploration cheaper models more selective sensing ``` Under abundance: ```text more exploration more simulation deeper evidence retrieval parallel hypotheses structural learning ``` ### 18. Metabolic waste Waste includes: ```text temporary scratch data stale embeddings expired caches obsolete hypotheses unused branches duplicate facts low-value logs superseded models ``` Needed processes: ```text garbage collection forgetting compaction archival deduplication ``` ### 19. Excretion is also an interface function Some information should leave the organism entirely, such as expired personal data, disallowed retained content, temporary source material, or stale credentials. ### 20. Growth means conversion of metabolism into structure Distinguish: ```text doing work ``` from: ```text growing ``` Possible budget split: ```text maintenance metabolism task metabolism growth metabolism exploration metabolism ``` ### 21. A plausible metabolic budget ```yaml budget: operations: 60% learning: 15% exploration: 10% consolidation: 5% maintenance: 10% ``` ### 22. Minimal substrate stack ```text ┌─────────────────────────────────────┐ │ Environmental Information Sources │ └──────────────────┬──────────────────┘ │ SEMANTIC MEMBRANE │ ┌──────────────────▼──────────────────┐ │ Information Substrate │ │ observations / events / artifacts │ ├─────────────────────────────────────┤ │ Memory Substrate │ │ episodes / concepts / models │ ├─────────────────────────────────────┤ │ Computational Substrate │ │ CPU / GPU / LLM / tools │ ├─────────────────────────────────────┤ │ Runtime Substrate │ │ processes / containers / network │ ├─────────────────────────────────────┤ │ Resource Accounting │ │ budgets / quotas / cost │ ├─────────────────────────────────────┤ │ Governance Substrate │ │ identity / policy / authority │ └─────────────────────────────────────┘ ``` ### 23. Three kinds of substrate availability **Ambient substrate** ```text runtime basic storage network identity ``` **Allocated substrate** ```text compute budget LLM tokens API quota storage quota ``` **Acquired substrate** ```text additional compute new data access new tools human attention increased authority ``` ### 24. Self-reasoning about metabolism The organism can learn: ```text how expensive am I? which processes waste compute? what knowledge reduces recurring cost? when should I cache? when should I forget? when should I ask for help? ``` ### 25. Metabolism ties into evolution Different lineages may have different metabolic architectures. ### 26. A useful hierarchy ```text SUBSTRATE provides possible resources MEMBRANE controls exchange with environment METABOLISM converts resources into information work ORGANISM maintains identity and learned structure ECOSYSTEM allocates resources and selects organisms ``` ### 27. Compact metabolic model Let the organism receive resources: \[ R = (I,C,M,A,H,T) \] where: - \(I\) = information, - \(C\) = compute, - \(M\) = memory/storage, - \(A\) = authority, - \(H\) = human attention, - \(T\) = time. The metabolic system performs transformations: \[ \Phi(R,S,G) \rightarrow (W,S',X) \] where: - \(S\) = current organism state, - \(G\) = current goals, - \(W\) = useful work returned to the environment, - \(S'\) = changed internal structure, - \(X\) = waste. Viability requires, over time: \[ Value(W + \Delta S) \gtrsim Cost(R) \] while staying within governance and safety constraints. The substrate should be thought of as the organism's **ecology of consumable capacities**. Information artifacts are raw material. Compute is energy. Runtime is habitat/body infrastructure. Memory is tissue. Tools and models are enzymes. Prompts are regulatory signals. Budgets determine metabolic capacity. Human attention is premium metabolic support. Authority determines which transformations can escape into the environment. A useful design question for every subsystem is: > **What resource enters, what transformation occurs, what useful product emerges, what does it cost, and what waste or persistent structure remains?**