assembly-economics/concepts/MetabolismModel.md

<!--
Provenance: promoted verbatim from history/20261011-InitialExploration.md
(lines 3204–3773, conversation dated 2026-10-06), including the originating
question(s). Promoted 2026-10-12 under ASSEMBLY-WP-0002-T06. Consolidation
happens in later commits; history/ keeps the original.
-->

# 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?**