From b3dc5b83defa3fe6d2fc767a263a7e86d0fac57a Mon Sep 17 00:00:00 2001 From: tegwick Date: Sun, 11 Oct 2026 23:55:45 +0200 Subject: [PATCH] Add initial exploration history and draft INTENT.md Co-Authored-By: Claude Opus 5.5 Assistant: claude-code Assistant-Model: opus Assistant-Process: 1494246@bnt-lap001 Assistant-Session: caf6de6f-f9e4-47ce-a584-49baa271fa4b --- INTENT.md | 163 + history/20261011-InitialExploration.md | 4263 ++++++++++++++++++++++++ 2 files changed, 4426 insertions(+) create mode 100644 INTENT.md create mode 100644 history/20261011-InitialExploration.md diff --git a/INTENT.md b/INTENT.md new file mode 100644 index 0000000..35010b2 --- /dev/null +++ b/INTENT.md @@ -0,0 +1,163 @@ +# INTENT.md + +> **Status:** draft suggestion (2026-10-11), derived from `README.md` and +> `history/20261011-InitialExploration.md`. To be reviewed and ratified by the +> project owner. + +## Project + +`assembly-economics` + +## Purpose + +`assembly-economics` exists to develop an experimental economic framework for +societies in which superhuman machine capability — physical, computational and +increasingly cognitive — provides most of the leverage for innovation and +profit. + +In such an economy, wage labour can no longer be the main way people take part +in value creation and gain agency. The project explores a **post-work mechanism +for participation and agency**. Its framing is that an economy is an *adaptive +information processing network*: an assembly of information organisms, humans +and institutions, linked by flows of information, resources and attention. + +It is the philosophical and economic framework that **coulomb.social** explores +and builds on. + +## Core Intent + +Describe an economy as a living, evolvable information-processing system, and +establish the concepts needed to design, govern and evaluate such systems so +that: + +1. **Abundant machine resources are spent to preserve scarce sentient + resources.** Money, compute and machine capacity are convertible potential. + Human attention, autonomy and wellbeing are lived capacity. They can only be + allocated once and must be protected by viability boundaries, not optimised + away. +2. **Humans keep purpose and authority.** Information organisms learn, predict + and act, but objectives, authority and hard constraints come from the human + and institutional environment and stay outside the optimisation loop. +3. **Participation does not require labour.** Supplying objectives, judgment, + attention, consent and governance is treated as real economic contribution, + and it is valued accordingly. + +## Conceptual Pillars + +The initial exploration established six connected layers. Together they form +the project's working vocabulary. + +### 1. Adaptive Information Processing Network (AIPN) + +A persistent, typed, token-flowing, self-modifying semantic network. Nodes are +high-level business concepts (`DocumentType`, `EmployeeRole`, +`WorkstationClass`, `Goal`, `Observer`). Activations are concrete instances +(documents, people, materials). Observers emit multi-dimensional +success/error signals against explicit and implicit goals. Learning changes +future activation, prediction, utility and, eventually, the structure itself. + +> Semantic structure + activation + prediction + feedback + adaptation. +> `sense → activate → predict → act → observe → learn → reorganize` + +Key distinctions: structure vs. activation, observation vs. evaluation, +prediction vs. utility, learning vs. authority, viability before optimisation. + +### 2. Membrane + +The boundary between an organism and its environment, such as a company's +governed IT landscape. It works through semantic projections (read models, not +replicas), preserves identity, provenance and the original governance envelope, +and is claim-oriented. It is bidirectional but asymmetrical. It filters the +vast environment down to what the organism actually samples. It is layered +(constitutional, operational, adaptive, ephemeral) and keeps negative space +visible. Membrane configuration is the main control and deployment interface. + +### 3. Seed Kernel + +A minimal developmental substrate rather than a finished intelligence. It +attaches to an information environment and grows by adapting to it. The +environment feeds it objectives (prompts act more like hormones than +nutrients) and resources (compute budget). Utility becomes endogenous, +attention becomes resource allocation, and symbiosis is a better target than +autonomy. + +### 4. Evolution + +Organisms as genotype/phenotype pairs that are bred, recombined and inherited +across generations. Fitness is multi-dimensional and environment-based. There +are nested adaptation loops (learning, development, evolution, ecosystem), and +heritable membranes. Hard constraints remain outside evolutionary optimisation. + +### 5. Metabolism and Substrate + +Organisms run on substrate layers: information, compute as energy, runtime as +habitat, memory as expensive tissue, authority and human attention as premium +energy. Metabolic pathways, waste and excretion, starvation and abundance +behaviour, and return on compute tie internal regulation to economic selection +pressure. + +### 6. Resource Ontology and Attention Economics + +Resource *accounting* (money as generalised, convertible potential) is distinct +from resource *ontology*. Resources are classed as commodity, capability, human +and institutional, along with whether they are sentient. Human attention is +treated as the reference scarce resource. Attention regulation becomes a +central societal control loop: + +```text +human purpose → objectives → economic allocation + → (money · compute · machine capacity) → information organisms + → work → abundance → human benefit → feedback +protected throughout by: attention · autonomy · wellbeing viability boundaries +``` + +## Scope + +**In scope** + +- A conceptual canon (currently v0.1 in the history file) and its successors +- Economic models for participation, agency and value attribution in a + post-work setting +- Resource ontology, conversion functions and attention-protection mechanisms +- Membrane and governance models for embedding information organisms in real + institutions +- Reference scenarios (e.g. invoice processing) and minimal experimental + kernels that make the concepts testable +- Framework input for coulomb.social + +**Out of scope (for now)** + +- Production implementations, storage engines, protocols or API formats. + Canon v0.1 deliberately leaves these unstandardised. +- Concrete marketplace product features. Those belong in `coulomb-social`. +- Pricing mechanics as such. See `adaptive-pricing`. + +## Guiding Principles + +- Semantic explicitness over opaque optimisation +- Viability precedes optimisation, and sentient viability precedes all else +- Learning is distinct from authority, and governance stays outside the network +- Provenance and explainability are first-class +- Keep the kernel small; separate the normative core from exploratory + extensions + +## Proposed Next Artifacts + +From canon v0.1 § 53, extended toward the economic layer: + +- `canon/ConceptualCanon.md`: extract and stabilise the v0.1 canon +- `canon/NetworkObjectModel.md`: precise, implementation-neutral object model +- `canon/MembraneModel.md`: the interface membrane and its layers +- `canon/ResourceOntology.md`: resource classes, conversion functions, + sentient boundary +- `canon/ParticipationModel.md`: post-work participation and agency +- `research/ResearchProgram.md` and `research/ReferenceScenario-InvoiceProcessing.md` + +## Relationship to the Ecosystem + +- **coulomb.social**: primary consumer; this repo supplies its philosophical + and economic framework. +- **adaptive-pricing / commerce-canon**: neighbouring economic mechanics that + may later adopt this repo's resource ontology. +- **the-custodian / State Hub**: work coordination (domain `communication`, + topic `coulomb-social`). diff --git a/history/20261011-InitialExploration.md b/history/20261011-InitialExploration.md new file mode 100644 index 0000000..6f22790 --- /dev/null +++ b/history/20261011-InitialExploration.md @@ -0,0 +1,4263 @@ +# Initial Exploration + +## Generic Information Processing Networks as Evolvable Information Organisms + +**Date:** 2026-10-06 + +--- + +## User + +I want to establish a generic information processing network that draws analogies form the biological brain and artificial artificial intelligence and super intelligence research. The idea is to have learning mechanisms pick up on regularities in the information processing so that we get a viable system that adapts to activations from its environment. The interesting part is, that the entities interacting should be rather hight level information objects like you would find in business applications. So a node in the network is for example a DocumentType or EmployeeRole or WorkstationClass and the activations are instances of those types like documents, users, materials that move along edges with in the end some observers generating error/success signals based on implicit an explicit controlling goals. + +## Assistant + +Yes. I think there is a genuinely interesting architecture hiding here, and the crucial move is **not to model low-level neurons**, but to lift several neural/cognitive principles into a network whose native vocabulary is business-semantic. + +A good provisional name would be **Adaptive Information Processing Network (AIPN)**. More structurally, I would describe it as a **typed, token-flowing, self-modifying semantic network**. + +The closest cognitive analogue is surprisingly ACT-R rather than a conventional neural network. ACT-R separates declarative “chunks” from procedural rules and uses activation to make contextually relevant knowledge more likely to participate in processing; activation is influenced by frequency, recency and association with the current context. Your proposal moves that idea up another abstraction level. + +### 1. The central distinction: structure versus activation + +I would separate three things very rigorously: + +**Semantic structure** + +```text +Invoice ──submitted-to──> AccountsPayable +Employee ──occupies──> EmployeeRole +EmployeeRole ──uses──> WorkstationClass +PurchaseOrder ──precedes──> Invoice +``` + +These are relatively stable relationships between **types/concepts**. + +**Concrete activation** + +```text +Invoice #4711 +Employee "Alice" +Workstation WS-328 +PurchaseOrder #9912 +``` + +These are **tokens** moving through or activating that structure. + +And finally: + +**Network state** + +```text +Invoice activation = .83 +AccountsPayable activation = .91 +Invoice → AccountsPayable + expectancy = .97 + utility = .76 + confidence = .99 +``` + +So I would not say that Alice *is* a node. Rather: + +> Alice's occurrence in some processing episode activates the `Employee`, `EmployeeRole`, `Department`, `WorkstationClass`, etc. structures associated with her. + +That distinction gives you something extremely powerful: **the graph remains comparatively small even if billions of concrete events pass through it.** + +### 2. A useful primitive model + +I'd start with only six primitives: + +| Primitive | Meaning | +|---|---| +| **Node** | A persistent information-processing concept | +| **Token** | A concrete information object/event/instance | +| **Edge** | A possible relationship or transition | +| **Activation** | Temporary relevance/readiness of node or edge | +| **Observer** | Evaluates something that happened | +| **Signal** | Feedback affecting future processing | + +For example: + +```text + ┌─────────────┐ +invoice.pdf ─────▶│ DocumentType│ + │ Invoice │ + └──────┬──────┘ + │ + activation + │ + ▼ + ┌─────────────┐ + │ AP Process │ + └──────┬──────┘ + │ + ┌────────────┴────────────┐ + ▼ ▼ + auto-process human-review + 0.93 0.07 + │ + ▼ + payment made + │ + ▼ + ┌──────────┐ + │ Observer │ + └────┬─────┘ + │ + success + │ + └── reinforces preceding path +``` + +This starts to look simultaneously like: + +- a semantic graph, +- a Petri net, +- a workflow system, +- a reinforcement-learning system, +- a predictive model, +- and an associative memory. + +That combination is precisely what makes it interesting. + +### 3. Activation should mean more than "a token passed here" + +This is where the brain analogy becomes valuable. + +A node should maintain something analogous to membrane potential or cognitive activation: + +\[ +A_i(t+1) += +decay(A_i(t)) ++ +external_i ++ +\sum_j w_{ji} A_j ++ +context_i ++ +predictionError_i +\] + +Not because biological neurons literally work at this semantic level, but because the abstraction gives useful behavior. + +An invoice arriving might activate: + +```text +Invoice 1.00 +AccountsPayable 0.81 +Supplier 0.67 +Contract 0.55 +FraudRisk 0.14 +HumanReview 0.08 +``` + +If invoices from a particular supplier repeatedly cause reconciliation failures: + +```text +Supplier:X + + +Invoice + + +MonthEnd +``` + +may eventually strongly activate: + +```text +ManualVerification +``` + +without anyone explicitly programming the rule. + +### 4. The particularly important brain analogy is not Hebbian learning alone + +The famous shorthand: + +> neurons that fire together wire together + +is insufficient for what you want. + +If `Invoice` and `HumanReview` frequently co-occur, blindly strengthening that connection may simply automate existing inefficiency. + +The more interesting biological model is **three-factor learning**: + +```text +A activated +B activated ++ +later success/error signal +────────────────────────── +change A → B +``` + +This maps beautifully to business systems. + +Suppose: + +```text +Invoice + → OCR + → VendorMatching + → AutoApproval + → Payment +``` + +Twenty minutes later: + +```text +Observer: payment completed correctly +Signal: +0.8 +``` + +The system doesn't merely increment the final edge. It strengthens the **eligible causal path** leading to the outcome. + +Conversely: + +```text +Duplicate payment detected +Signal: -1.0 +``` + +weakens or inhibits parts of the path. + +This solves a central problem: + +> **credit assignment across business processes.** + +### 5. Success/error should not be a single scalar + +This becomes even more interesting if feedback is vector-valued. + +For example: + +```yaml +outcome: + correctness: +1.0 + latency: +0.7 + cost: +0.4 + security: +1.0 + customer_satisfaction: -0.2 + regulatory_compliance: +1.0 +``` + +Different observers can contribute signals. + +```text +Customer observer +Finance observer +Security observer +Compliance observer +Operations observer +``` + +There may therefore be no universally "good" path. + +A path can be: + +```text +fast +0.9 +cheap +0.8 +secure +0.3 +reliable +0.6 +``` + +while another is: + +```text +fast +0.3 +cheap +0.2 +secure +0.99 +reliable +0.98 +``` + +The **currently active goals** modulate which feedback matters. + +### 6. Goals themselves should be nodes + +This is an important consequence. + +Don't put "objective function" somewhere outside the model. + +Represent objectives in the network: + +```text +Goal + ├── MinimizeProcessingCost + ├── MinimizeCustomerWaitingTime + ├── AvoidFraud + ├── MaintainCompliance + └── PreserveHumanAttention +``` + +And instantiate them contextually: + +```text +GoalActivation: + AvoidFraud .95 + MaintainCompliance 1.0 + MinimizeProcessingCost .41 +``` + +Then goal activation changes the interpretation of other activations. + +This also connects strongly with the systems-theory angle: + +> the network doesn't optimize toward one permanent objective; its **regulatory state changes which distinctions currently matter**. + +### 7. Prediction should be first-class + +I would actually make **prediction error** more fundamental than reward. + +Every edge can learn: + +```text +given A, +how likely is B? +``` + +Example: + +```text +PurchaseOrder + ↓ 0.94 +Delivery + ↓ 0.91 +Invoice + ↓ 0.97 +Payment +``` + +Suppose this happens: + +```text +PurchaseOrder +Delivery +Invoice + +``` + +Nothing explicitly needs to say "error." + +The network expected `Payment`. + +Its absence is information. + +Likewise: + +```text +Invoice + → LegalComplaint +``` + +may be extremely surprising. + +So each processing episode naturally generates: + +```text +expected events +observed events +prediction error +``` + +Learning then seeks models that make the environment increasingly unsurprising *conditional on its goals and actions*. + +### 8. Edges should have multiple learned properties + +Don't reduce an edge to one neural-style weight. + +I would give an edge something like: + +```yaml +edge: + source: Invoice + target: AutoApproval + + association: 0.72 + transition_probability: 0.84 + confidence: 0.97 + + utility: + cost: 0.91 + latency: 0.96 + correctness: 0.89 + security: 0.71 + + eligibility: 0.12 + activation: 0.67 + + observations: 158422 +``` + +This separates several questions: + +**Association** + +> Do these things tend to occur together? + +**Prediction** + +> Does A imply B is likely to follow? + +**Utility** + +> Is going from A to B advantageous? + +**Confidence** + +> How much evidence do we have? + +**Activation** + +> How relevant is this relation right now? + +That separation will save you enormous conceptual trouble later. + +### 9. Nodes shouldn't all have the same semantics either + +Your high-level network might contain: + +```text +Type + ├── DocumentType + ├── EmployeeRole + ├── WorkstationClass + ├── MaterialType + └── CustomerType + +State + ├── InvoiceAwaitingApproval + └── CustomerAtRisk + +Capability + ├── OCR + ├── ValidateInvoice + └── DispatchLetter + +Goal + ├── ReduceLatency + └── EnsureCompliance + +Observer + ├── SLAObserver + ├── FraudObserver + └── CustomerFeedbackObserver + +Context + ├── MonthEnd + ├── Emergency + └── HighLoad +``` + +Yet all of these can participate in the same activation calculus. + +### 10. And then comes the genuinely interesting part: structural learning + +Initially the system learns only weights. + +#### Level 0 — fixed topology + +```text +A ──0.3──▶ B +``` + +Learn: + +```text +0.3 → 0.47 +``` + +#### Level 1 — edge discovery + +Repeated correlation creates: + +```text +A ─────▶ C +``` + +#### Level 2 — inhibition + +Learn: + +```text +A ──| B +``` + +#### Level 3 — contextual relationships + +Discover: + +```text +A + context:X → B +``` + +#### Level 4 — concept formation + +Repeated pattern: + +```text +A → B → C +A → B → C +A → B → C +``` + +becomes: + +```text + ┌─────────────┐ +A ───▶ │ Pattern P17 │ ───▶ C + └─────────────┘ +``` + +Eventually the system may discover that `P17` corresponds to something humans call: + +```text +"invoice reconciliation" +``` + +Now we have gone from **parameter learning** to **representation learning**. + +### 11. Hierarchical compression is probably essential + +The network should therefore be recursively compositional. + +At one level: + +```text +Invoice → Validate → Approve → Pay +``` + +At another: + +```text +AccountsPayableProcess +``` + +And higher: + +```text +FinancialOperations +``` + +The system should be able to learn that a frequently recurring subgraph behaves sufficiently coherently that it can become a new node. + +I would call this operation: + +> **chunking** + +Your version could allow chunks themselves to emerge. + +This gives you a recursive architecture: + +```text +events + ↓ +patterns + ↓ +processes + ↓ +capabilities + ↓ +organizations + ↓ +ecosystems +``` + +Every layer uses fundamentally the same machinery. + +### 12. One major difference from a normal neural network + +A conventional deep neural network learns something roughly like: + +```text +input + ↓ +latent representation + ↓ +latent representation + ↓ +output +``` + +The internal units intentionally have no stable human interpretation. + +Your network would instead preserve semantic identity: + +```text +Invoice +Supplier +Contract +EmployeeRole +Approval +Payment +``` + +So it sacrifices some representational freedom in exchange for: + +- inspectability, +- intervention, +- semantic stability, +- policy control, +- explanation, +- compositionality, +- integration with business systems. + +I'd therefore resist calling the nodes "neurons." + +A better analogy is: + +> **neurons : brain :: semantic processors : organizational information system** + +You are borrowing the *learning dynamics*, not the physical representation. + +### 13. The resulting processing loop + +```text + ENVIRONMENT + │ + ▼ + observations + │ + ▼ + ┌─────────────────┐ + │ semantic ingest │ + └────────┬────────┘ + │ + ▼ + ACTIVATE + │ + ▼ + ┌──────────────────┐ + │ spread activation│ + │ predict │ + │ select │ + └────────┬─────────┘ + │ + action + │ + ▼ + ENVIRONMENT + │ + consequences + │ + ▼ + OBSERVERS + │ + ┌──────────────┼──────────────┐ + ▼ ▼ ▼ + error success surprise + └──────────────┬──────────────┘ + │ + ▼ + LEARNING + │ + ┌────────┴────────┐ + ▼ ▼ + weights structure +``` + +And crucially: + +```text +learning → changes future activation +``` + +rather than: + +```text +learning → writes another business rule +``` + +### 14. I would separate four kinds of learning + +**Associative learning** + +> What tends to occur together? + +```text +EmployeeRole ↔ WorkstationClass +``` + +**Predictive learning** + +> What follows what? + +```text +ApprovedInvoice → Payment +``` + +**Instrumental learning** + +> What actions produce desirable consequences? + +```text +Invoice → AutoApprove → good outcome +``` + +**Structural learning** + +> What new concepts or processes should exist? + +```text +A → B → C → A → B → C + ↓ + P17 +``` + +### 15. Add homeostasis and it gets much more interesting + +There is another biological idea I think you should import very early: + +**homeostatic variables**. + +The network shouldn't merely chase rewards. It should maintain viable operating ranges: + +```text +queue_depth 0.31 +operator_load 0.64 +cash_liquidity 0.72 +security_exposure 0.12 +customer_waiting_time 0.41 +system_load 0.55 +``` + +with preferred ranges. + +Then: + +```text +error = desired_range - observed_state +``` + +produces regulatory activation. + +For example: + +```text +operator_load > 0.85 +``` + +activates: + +```text +Automation +Deferral +LoadBalancing +Prioritization +``` + +The fundamental objective doesn't need to be "maximize reward." + +It can instead be: + +> **maintain essential variables within viable bounds while adapting to environmental perturbation.** + +### 16. A compact formal kernel + +\[ +N=(V,E,T,G,O) +\] + +where + +- \(V\) = semantic processing nodes, +- \(E\) = typed relationships, +- \(T\) = information tokens, +- \(G\) = goals/regulatory variables, +- \(O\) = observers. + +Each node has: + +\[ +v=(type,state,activation,memory) +\] + +Each edge: + +\[ +e=(source,target,type,W,P,U,C) +\] + +where + +- \(W\): associative strength +- \(P\): predictive model +- \(U\): utility/outcome model +- \(C\): confidence + +And each episode generates a trace: + +\[ +\tau=(T,V_{active},E_{active},actions,outcomes) +\] + +Observers turn traces into feedback: + +\[ +O(\tau,G)\rightarrow S +\] + +and learning becomes: + +\[ +L(\tau,S,N)\rightarrow N' +\] + +That is enough to start experimenting. + +### 17. What I think this could become + +```text + adaptive + organization + ▲ + │ + concept formation + ▲ + │ + structural learning + ▲ + │ + outcome learning + ▲ + │ + predictive learning + ▲ + │ + associative learning + ▲ + │ + activation network + ▲ + │ + event graph +``` + +Each layer is useful independently. + +That means you can **grow intelligence rather than assume intelligence**. + +And because the substrate consists of high-level information objects, humans and agents can inspect the same cognitive structure the system itself uses. + +A compact description is: + +> **A persistent semantic network is continually excited by information objects from its environment. Activation propagates through learned associations, generates predictions and actions, and leaves eligibility traces. Observed consequences produce multi-dimensional regulatory signals that modify both connection strengths and, eventually, network structure. Recurrent structures are compressed into higher-order concepts, allowing the network to develop increasingly abstract models of its environment and its own operation.** + +--- + +## User + +Very interesting elaboration, please build an initial draft of the conceptional canon. + +## Assistant + +Below is a first **v0.1 conceptual canon**. I’ve kept the kernel deliberately small and separated the normative core from exploratory extensions so it can evolve into a research/programming artifact rather than becoming overcommitted too early. + +# Adaptive Information Processing Network +## Conceptual Canon v0.1 + +**Status:** Initial draft +**Purpose:** Establish a precise conceptual vocabulary for adaptive information-processing networks operating on high-level semantic information objects. + +### 1. Intent + +An **Adaptive Information Processing Network (AIPN)** is a persistent network of semantic information-processing entities whose internal state changes in response to information arriving from its environment. + +The network is intended to learn regularities in its own operation and in the environment with which it interacts. Learning modifies future activation, prediction, selection, and eventually network structure. + +Unlike conventional artificial neural networks, the primary entities of an AIPN are intended to retain explicit domain semantics. + +Typical nodes may represent concepts such as: + +- `DocumentType` +- `Invoice` +- `EmployeeRole` +- `WorkstationClass` +- `SupplierClass` +- `Process` +- `Capability` +- `Goal` +- `Risk` +- `Observer` + +Concrete entities such as a particular invoice, employee, document, machine, message, or material occur as information objects that activate parts of the network. + +The network therefore operates at a semantic level suitable for organizational, business, technical, and socio-technical systems. + +### 2. Foundational Idea + +The system distinguishes between: + +1. **persistent semantic structure**, and +2. **temporary concrete activation**. + +A node such as: + +```text +Invoice +``` + +may persist for years. + +A concrete invoice: + +```text +Invoice #4711 +``` + +may activate that node during a processing episode. + +The persistent network accumulates knowledge from many such episodes. + +The foundational processing cycle is: + +```text +Environment + ↓ +Information Object + ↓ +Semantic Activation + ↓ +Activation Propagation + ↓ +Prediction / Selection / Action + ↓ +Environmental Consequence + ↓ +Observation + ↓ +Feedback Signal + ↓ +Learning + ↓ +Modified Network +``` + +The network is therefore both: + +- a model of its environment, and +- an adaptive mechanism participating in that environment. + +### 3. Design Principles + +#### 3.1 Semantic explicitness + +Nodes and edges SHOULD have explicit meaning. + +The system SHOULD prefer interpretable representations such as: + +```text +Invoice → requires → Approval +``` + +over anonymous latent dimensions whenever doing so does not fundamentally prevent useful learning. + +#### 3.2 Structure and activation are distinct + +Persistent knowledge MUST be distinguishable from temporary processing state. + +The existence of: + +```text +Invoice → Approval +``` + +does not imply that either node is currently active. + +#### 3.3 Observation and evaluation are distinct + +The system MUST distinguish: + +```text +what happened +``` + +from: + +```text +whether what happened was desirable. +``` + +An observation is evidence. + +A signal is an evaluation or regulatory consequence derived from evidence. + +#### 3.4 Prediction and utility are distinct + +An event can be highly probable but undesirable. + +For example: + +```text +Complaint → ManualEscalation +``` + +may have: + +```text +probability = 0.92 +utility = -0.63 +``` + +The network MUST therefore avoid reducing expectation and desirability to a single weight. + +#### 3.5 Learning is local where possible + +Learning SHOULD be attributable to identifiable nodes, edges, episodes, and signals. + +This supports: + +- explainability, +- debugging, +- governance, +- intervention, +- comparison, +- rollback. + +#### 3.6 Delayed consequences are expected + +Actions frequently produce consequences much later. + +The network SHOULD retain temporary evidence that earlier activations contributed to later outcomes. + +This mechanism is represented by **eligibility traces**. + +#### 3.7 Goals belong to the modeled world + +Goals SHOULD be represented within the network rather than existing solely as hidden implementation configuration. + +Examples: + +```text +MinimizeCost +ReduceLatency +AvoidFraud +MaintainCompliance +PreserveHumanAttention +``` + +Goal activation may vary with context. + +#### 3.8 Viability precedes optimization + +The network SHOULD distinguish: + +```text +remaining within viable operating bounds +``` + +from: + +```text +optimizing preferred outcomes. +``` + +Some states may therefore be unacceptable regardless of their apparent local utility. + +#### 3.9 Learning and authority are distinct + +Learning that an action appears beneficial MUST NOT imply that the system is authorized to perform it. + +The system MUST distinguish at least: + +```text +can +may +does +should +must +``` + +where appropriate. + +This permits learning under constrained authority. + +#### 3.10 Higher-order structure may emerge + +Repeated or coherent patterns MAY be represented as new network entities. + +The network can therefore progressively construct abstractions from recurrent processing structure. + +### 4. Core Ontology + +The minimum canonical vocabulary consists of: + +```text +Node +Token +Edge +Activation +Episode +Context +Prediction +Action +Observer +Signal +Goal +ViabilityVariable +EligibilityTrace +Chunk +``` + +These concepts form the initial kernel. + +### 5. Node + +A **Node** is a persistent semantic entity capable of participating in information processing. + +A node represents a meaningful distinction recognized by the network. + +Examples: + +```text +Invoice +EmployeeRole +WorkstationClass +OCRCapability +FraudRisk +HumanReview +CustomerComplaint +``` + +A node SHOULD possess stable identity independent of its temporary activation state. + +Conceptually: + +```yaml +node: + id: Invoice + kind: DocumentType +``` + +Useful semantic kinds include: + +```text +EntityType +State +Role +Capability +Process +Resource +Context +Goal +Risk +Observer +Policy +Concept +``` + +A node MAY maintain learned or temporary state including: + +```text +activation +frequency +recency +confidence +memory +statistics +prediction models +utility estimates +``` + +### 6. Token + +A **Token** is a concrete information object participating in a processing episode. + +Examples: + +```text +Invoice #4711 +Employee Alice +Workstation WS-328 +Shipment #91284 +Customer Request #882 +``` + +A token MAY activate multiple nodes simultaneously. + +Example: + +```text +Invoice #4711 +``` + +might activate: + +```text +Invoice +SupplierInvoice +PDFDocument +HighValueTransaction +Supplier:Acme +MonthEnd +``` + +Tokens MAY be transient, persistent, externally referenced, or reconstructed from event history. + +### 7. Edge + +An **Edge** is a persistent relationship between network entities. + +Example: + +```text +Invoice → requires → Approval +``` + +Edges SHOULD be typed. + +Possible examples include: + +```text +is-a +part-of +uses +requires +precedes +associated-with +predicts +enables +inhibits +routes-to +observed-by +contributes-to +``` + +An edge SHOULD NOT be reduced to a single scalar weight. + +A useful conceptual form is: + +```yaml +edge: + source: Invoice + target: HumanReview + relation: routes-to + + association: 0.42 + transition_probability: 0.18 + confidence: 0.91 + + utility: + correctness: 0.94 + latency: 0.31 + cost: 0.22 + + activation: 0.12 +``` + +### 8. Activation + +**Activation** represents the current relevance, readiness, or excitation of a network entity. + +Activation may originate from incoming tokens, neighboring nodes, current goals, context, prediction, surprise, explicit attention, regulatory state, or remembered association. + +Activation SHOULD normally decay over time unless sustained. + +### 9. Context + +A **Context** is a semantic representation of conditions that modulate processing. + +Examples: + +```text +MonthEnd +EmergencyOperation +HighSystemLoad +CustomerFacing +ProductionEnvironment +NightShift +``` + +The network SHOULD be capable of distinguishing: + +```text +A → B +``` + +from: + +```text +A + Context X → B +``` + +### 10. Episode + +An **Episode** is a bounded trace of related network activity. + +An episode MAY contain input tokens, activated nodes, traversed edges, contexts, predictions, actions, observations, and resulting signals. + +Episodes provide a unit for learning, replay, explanation, comparison, attribution, experimentation, and auditing. + +### 11. Prediction + +A **Prediction** expresses an expectation concerning future observations or network states. + +Prediction error arises from the difference between expected and observed outcomes. + +Both occurrences and absences may be informative. + +### 12. Action + +An **Action** is an intervention generated or selected by the network that may affect its environment. + +Examples: + +```text +RouteToHumanReview +SendNotification +ApproveDocument +RequestMissingData +DelayProcessing +Escalate +``` + +The canon distinguishes: + +```text +something happened +``` + +from: + +```text +the network caused something to happen. +``` + +An action MAY be: + +```text +possible +permitted +recommended +selected +executed +mandatory +``` + +These states MUST NOT be treated as equivalent. + +### 13. Observer + +An **Observer** is an entity that evaluates or interprets observations, states, episodes, or consequences. + +Multiple observers MAY interpret the same episode differently. + +### 14. Signal + +A **Signal** is evaluative or regulatory information capable of changing future network behavior. + +Signals may represent success, failure, reward, penalty, prediction error, novelty, surprise, constraint violation, human feedback, or viability deviation. + +Signals SHOULD normally permit multiple dimensions. + +### 15. Goal + +A **Goal** is a modeled desired tendency, condition, outcome, or constraint. + +Goals participate in processing through activation. + +Goal conflicts are expected and SHOULD remain visible rather than silently flattened. + +### 16. Viability Variable + +A **Viability Variable** represents a system condition that should remain within an acceptable operating range. + +Examples: + +```text +QueueDepth +CashLiquidity +SecurityExposure +OperatorLoad +CustomerWaitingTime +ComputeCapacity +ErrorRate +``` + +Deviation from viable ranges MAY itself create activation and signals. + +### 17. Eligibility Trace + +An **Eligibility Trace** is temporary evidence that a previous activation, edge traversal, prediction, or action may have contributed to a later outcome. + +Eligibility traces address delayed credit assignment. + +### 18. Chunk + +A **Chunk** is a higher-order semantic entity representing a recurring or coherent structure. + +A chunk may summarize a sequence, subgraph, recurring context, workflow, behavioral pattern, or causal configuration. + +Chunks MAY themselves participate as ordinary nodes. + +### 19. Canonical Learning Modes + +The initial canon distinguishes four primary learning modes: + +- Associative Learning +- Predictive Learning +- Instrumental Learning +- Structural Learning + +An optional fifth is Regulatory Learning. + +### 20. Optional Fifth Learning Mode: Regulatory Learning + +Question: + +> Which interventions restore or preserve viable system conditions? + +### 21. Edge Semantics + +The network SHOULD distinguish at least four independent properties of a relationship: + +- Association +- Prediction +- Utility +- Confidence + +These MUST NOT automatically collapse into one scalar. + +### 22. Inhibition + +Relationships need not only increase activation. + +An edge MAY inhibit another node, relationship, or action. + +### 23. Competition + +When multiple candidate actions become active, they MAY compete. + +Selection may depend on activation, predicted utility, confidence, goals, authorization, cost, uncertainty, or exploration policy. + +### 24. Attention + +**Attention** is the allocation of limited processing resources toward selected activations. + +Attention MAY be driven by high activation, high surprise, high uncertainty, high expected utility, high risk, explicit human focus, or active goals. + +### 25. Memory + +The canon recognizes at least three useful forms of memory: + +- Structural memory +- Statistical memory +- Episodic memory + +### 26. Temporal Semantics + +The network SHOULD distinguish co-occurrence, ordering, duration, delay, recency, and periodicity. + +### 27. Causality + +The network MUST distinguish association from causation. + +Causal confidence MAY be increased through interventions, controlled experiments, repeated counterfactual evidence, external knowledge, or structural assumptions. + +### 28. Exploration and Exploitation + +A purely exploitative network risks becoming trapped in existing behavior. + +The system SHOULD permit controlled exploration. + +### 29. Plasticity + +Not every network component should learn equally quickly. + +A useful distinction is: + +```text +fast plasticity +slow plasticity +frozen structure +``` + +### 30. Consolidation + +Frequently reinforced patterns MAY transition from flexible to stable representation. + +### 31. Forgetting + +The network SHOULD permit information to weaken. + +Possible mechanisms include activation decay, confidence decay, edge weakening, evidence aging, and chunk dissolution. + +### 32. Structural Formation + +A potential structural-learning progression is: + +```text +Level 0 — Fixed topology +Level 1 — Edge weight adaptation +Level 2 — Edge creation/removal +Level 3 — Context-dependent structure +Level 4 — Chunk formation +Level 5 — Hierarchical concept formation +``` + +### 33. Processing Cycle + +A canonical processing cycle is: + +```text +1. Observe +2. Interpret +3. Activate +4. Propagate +5. Predict +6. Select +7. Act +8. Observe consequences +9. Evaluate +10. Assign credit +11. Learn +12. Consolidate or forget +``` + +### 34. Minimal Formal Model + +An AIPN may be represented as: + +\[ +N=(V,E,T,G,O,H) +\] + +where: + +- \(V\) = nodes +- \(E\) = edges +- \(T\) = tokens +- \(G\) = goals and viability variables +- \(O\) = observers +- \(H\) = retained history or memory + +A node may be represented as: + +\[ +v=(id,type,state,A,M) +\] + +An edge may be represented as: + +\[ +e=(s,t,r,W,P,U,C) +\] + +An episode: + +\[ +\tau=(inputs,context,activations,predictions,actions,observations) +\] + +Observers generate signals: + +\[ +O(\tau,G)\rightarrow S +\] + +Learning updates the network: + +\[ +L(N,\tau,S)\rightarrow N' +\] + +### 35. Reference Example: Invoice Processing + +A concrete token: + +```text +Invoice #4711 +``` + +Semantic interpretation activates: + +```text +Invoice 1.00 +SupplierInvoice 0.94 +Supplier:Acme 0.87 +AccountsPayable 0.76 +PurchaseOrderMatching 0.63 +FraudRisk 0.11 +``` + +The network predicts outcomes, selects actions, observes results, and updates eligible structures. + +### 36. Example of Surprise + +If `ApprovedInvoice → Payment` is expected but `ApprovedInvoice → CustomerComplaint` occurs, the event creates surprise and may activate investigation, fraud risk, process anomaly, or human attention. + +### 37. Human Interaction + +Humans MAY interact with the network by providing tokens, activating goals, providing explicit feedback, authorizing actions, adding or removing semantic structure, challenging learned relationships, annotating chunks, changing viability ranges, and constraining learning. + +### 38. Agent Interaction + +Artificial agents MAY occupy the same general roles. + +The canon does not require a fundamental semantic distinction between human and artificial participants. + +Authority and reliability may differ independently. + +### 39. Governance Boundary + +Some network structures MUST be capable of being declared non-learnable or only learnable under explicit authority. + +### 40. Explainability Requirement + +Any learned decision SHOULD, where practical, permit reconstruction of: + +```text +what was active? +what was predicted? +which actions competed? +which goals mattered? +which evidence supported the choice? +what feedback changed the network? +``` + +### 41. Provenance + +Learned structures SHOULD retain evidence of origin. + +### 42. Uncertainty + +Unknown and uncertain states SHOULD remain explicitly representable. + +### 43. Multi-Level Organization + +The same conceptual machinery MAY operate at multiple abstraction levels. + +### 44. Recursion + +A chunk at one level MAY become a node at another. + +### 45. Canonical Distinctions + +The following distinctions SHOULD remain explicit: + +```text +type ≠ instance +node ≠ token +structure ≠ activation +observation ≠ evaluation +association ≠ prediction +prediction ≠ causation +prediction ≠ utility +utility ≠ authorization +goal ≠ viability constraint +action ≠ occurrence +confidence ≠ probability +learning ≠ execution +adaptation ≠ unrestricted autonomy +``` + +### 46. Initial Maturity Ladder + +```text +AIPN-0 — Semantic Event Graph +AIPN-1 — Activation Network +AIPN-2 — Associative Learner +AIPN-3 — Predictive Learner +AIPN-4 — Outcome Learner +AIPN-5 — Regulatory Learner +AIPN-6 — Structural Learner +AIPN-7 — Concept Former +AIPN-8 — Reflective Network +``` + +### 47. Research Questions + +Open questions include representation, activation, credit assignment, causality, structural learning, stability, goal formation, viability, hierarchy, authority, forgetting, and explanation. + +### 48. Initial Implementation Hypothesis + +A first experimental implementation SHOULD remain modest: + +```text +one bounded domain +10–50 node types +hundreds to thousands of instances +a small number of explicit goals +several observers +fixed topology initially +learned association and prediction +``` + +### 49. Minimal Experimental Kernel + +```text +Node +Token +Edge +Activation +Episode +Prediction +Observer +Signal +EligibilityTrace +``` + +### 50. Working Definition + +> A persistent semantic network whose entities are activated by concrete information objects and environmental conditions; whose activation propagates through learned relationships to generate expectations and possible actions; whose consequences are evaluated by observers and regulatory goals; and whose accumulated experience modifies the network's future activation, prediction, utility estimates, and ultimately its semantic structure. + +### 51. Short Form + +> **Semantic structure + activation + prediction + feedback + adaptation.** + +Operationally: + +```text +sense +→ activate +→ predict +→ act +→ observe +→ learn +→ reorganize +``` + +### 52. Scope of v0.1 + +This version establishes the conceptual language. + +It intentionally does **not** yet standardize storage representation, distributed architecture, graph database model, learning algorithms, message protocols, API formats, numerical activation functions, optimization methods, agent implementation, ontology language, or persistence strategy. + +### 53. Proposed Next Artifacts + +```text +ConceptualCanon.md +ArchitectureBlueprint.md +ResearchProgram.md +ReferenceScenario-InvoiceProcessing.md +LearningModel.md +NetworkObjectModel.md +ExperimentProtocol.md +``` + +The immediate next useful artifact is probably `NetworkObjectModel.md`, translating the conceptual entities defined here into a precise executable object model while deliberately remaining independent of implementation language or storage technology. + +--- + +## User + +Before introducing more artefacts, let's think about how a system like this can be integrated with a classic it environment of a company. There are actual artefacts and many of them in a company and they are organized and archived in many it systems according to existing governance rules. It will be essential for practicability to establish a good interface membrane between what we discuss here and the original data entities. + +## Assistant + +Yes. I think this interface membrane is not a peripheral integration concern; it is one of the core architectural boundaries of the whole idea. + +The adaptive network should **not become another system of record**. It should sit above the existing operational landscape as a learning and interpretive layer, while the authoritative business artefacts remain governed by their original systems. + +A useful name is: + +> **Semantic Membrane** + +Its purpose is to translate between the messy, heterogeneous, governed world of enterprise IT and the comparatively clean semantic world of the adaptive network. + +The core architectural rule would be: + +> **Reference the original artefact, project only what is needed, preserve provenance and authority, and never confuse the learned representation with the authoritative source.** + +### 1. Two worlds + +On the enterprise side you have things like: + +```text +SAP invoice +SharePoint document +CRM customer +Active Directory user +HR employee record +Jira ticket +email +PDF +database row +API object +machine telemetry +physical shipment +``` + +On the network side: + +```text +Invoice +Customer +EmployeeRole +Supplier +Contract +Incident +WorkstationClass +``` + +plus activations, associations, predictions and learned relationships. + +The membrane connects these worlds without pretending they are identical. + +### 2. Do not ingest objects directly — create semantic projections + +Introduce: + +> **Projection** + +```text +Source Artefact + ↓ +Semantic Projection + ↓ +Network Token / Activation +``` + +The projection contains only the information relevant for the adaptive network. + +### 3. Identity must survive the membrane + +Every projected object should retain a durable link back to its authoritative origin. + +Distinguish: + +```text +source identity +semantic identity +instance identity +``` + +Identity resolution itself should be explicit, probabilistic where necessary, and auditable. + +### 4. Authority stays outside the network + +A crucial invariant: + +```text +semantic representation ≠ authoritative state +``` + +The network may infer something while the enterprise system records something else. + +A useful information classification: + +```text +OBSERVED +DECLARED +INFERRED +PREDICTED +PROPOSED +AUTHORITATIVE +``` + +### 5. The membrane should be bidirectional, but asymmetrical + +Inbound: + +```text +Enterprise System + ↓ +observe / subscribe / query + ↓ +normalize + ↓ +semantic projection + ↓ +network activation +``` + +Outbound: + +```text +Network + ↓ +recommendation / proposed action + ↓ +policy & authority check + ↓ +adapter + ↓ +Enterprise System +``` + +Reading and learning can be relatively permissive. + +Acting should require explicit authority. + +### 6. Five membrane functions + +```text +1. Observe +2. Identify +3. Project +4. Govern +5. Actuate +``` + +### 7. Artefact vs representation + +Distinguish: + +```text +Artefact +Representation +Claim +``` + +Claims retain provenance. + +### 8. The membrane should be claim-oriented + +A claim may specify subject, predicate, object, source, authority, observed time, and confidence. + +This allows contradictions without corrupting the model. + +### 9. Preserve the original governance envelope + +Objects enter the semantic network carrying restrictions such as data classification, tenant, owner, retention, purpose, and allowed processing. + +Derived knowledge may inherit restrictions. + +### 10. Learning must not destroy provenance + +Learned relationships should retain evidence such as episode counts, source period, tenant, and confidence. + +### 11. Historical state matters + +Mutable business objects should become observations of temporal state transitions rather than just snapshots. + +### 12. Read models rather than replicas + +The network stores enough information to reason, not enough to become a replacement source system. + +### 13. Lazy materialization + +Semantic representation can be built on demand. + +### 14. The membrane becomes a sensory and motor system + +Inbound: + +```text +source artefact + ↓ +sensor + ↓ +semantic activation +``` + +Outbound: + +```text +selected action + ↓ +motor adapter + ↓ +enterprise change +``` + +### 15. Epistemic boundary + +The network never sees reality directly. + +It sees observations produced by interfaces. + +Missing data can mean false, unknown, not observed, not accessible, not projected, or not retained. + +### 16. Adaptive membrane only carefully + +Some parts can learn: + +```text +schema mappings +entity matching +semantic extraction +source reliability +``` + +Other parts should remain deterministic: + +```text +authorization +tenant isolation +retention enforcement +write permissions +source-system contracts +``` + +### 17. SourceBinding + +A useful conceptual object: + +```yaml +SourceBinding: + semantic_entity: Invoice + source_system: SAP + source_type: AccountingDocument + identity_mapping: ... + projection_rule: ... + access_policy: ... + freshness_policy: ... + write_capabilities: ... +``` + +### 18. Evidence + +Every semantic assertion entering the network should ideally be backed by evidence. + +### 19. Conceptual architecture + +```text +┌────────────────────────────────────────────┐ +│ EXISTING ENTERPRISE SYSTEMS │ +│ ERP CRM DMS IAM HR DB Email APIs Files ... │ +└─────────────────────┬──────────────────────┘ + │ + ▼ +╔════════════════════════════════════════════╗ +║ SEMANTIC MEMBRANE ║ +║ observation ║ +║ identity resolution ║ +║ provenance ║ +║ semantic projection ║ +║ policy enforcement ║ +║ data minimization ║ +║ temporalization ║ +║ source binding ║ +║--------------------------------------------║ +║ deterministic authority / write boundary ║ +╚═══════════════════╤════════════════════════╝ + │ + ▼ +┌────────────────────────────────────────────┐ +│ ADAPTIVE INFORMATION PROCESSING NETWORK │ +│ activation │ +│ prediction │ +│ association │ +│ goals │ +│ learning │ +│ chunking │ +└─────────────────────┬──────────────────────┘ + │ + ▼ +╔════════════════════════════════════════════╗ +║ AUTHORITY / ACTUATION GATE ║ +╚═══════════════════╤════════════════════════╝ + │ + ▼ + ENTERPRISE SYSTEMS +``` + +The key invariant: + +> **The adaptive network operates on semantic representations and evidence, not on authoritative enterprise artefacts themselves. Enterprise systems retain ownership of authoritative state; the membrane preserves identity, provenance, governance and controlled actuation between both worlds.** + +The target is not: + +```text +integrate all enterprise data +``` + +but: + +```text +make selected enterprise reality +semantically observable and safely actionable. +``` + +--- + +## User + +Good, this is a very reasonable take. Let me add another idea about the optimal inner kernel of the concept. I would like to think about this in a way of how to establish a minimal kernel that can be connected to an environment and then unfoldes and establishes itself by adapting to the environment. This is like a baby or seed that can be planted in an information environment growing into something like an organizm that is helpful for its environment which shows as the environment feeds the system by providing objectives and resources to reach them. In my mind this translates to prompts and budget for compute. + +## Assistant + +Yes. This changes the framing in a useful way: the kernel should not be a miniature finished intelligence system. It should be a **developmental substrate** capable of attaching to an information environment, discovering regularities, acquiring structure, and becoming useful under externally supplied goals and resource constraints. + +The closest metaphor is less “brain” and more **seed + metabolism + development**. + +A compact formulation: + +> **A minimal adaptive kernel starts with almost no domain structure. It is given access to an environment, objectives, and bounded resources. Through observation, interaction, prediction, feedback, and compression, it develops a semantic model and increasingly effective behaviors specific to that environment.** + +### What must exist at birth? + +#### 1. Boundary + +It must distinguish self from environment operationally. + +#### 2. Observation + +It needs a generic way to receive information: + +```text +observe(environment) → evidence +``` + +The semantic membrane becomes its sensory apparatus. + +#### 3. Memory + +The seed needs to retain what happened, when, under which conditions, what it did, and what followed. + +#### 4. Prediction + +It must be able to predict what happens next. + +Prediction followed by observation yields a learning signal. + +#### 5. Action + +It needs bounded ability to affect its environment. + +Initially this might be ask, retrieve, classify, or recommend. + +#### 6. Objective reception + +The environment must be able to tell the seed what matters. + +This maps naturally to **prompts**. + +A prompt becomes a temporary or persistent **goal activation**. + +#### 7. Resource reception + +The second thing supplied by the environment is energy. + +For the information organism: + +```text +compute +tokens +storage +API calls +human attention +time +money +``` + +So **budget is the metabolic resource of the organism**. + +### A minimal kernel + +```text +K = { + Boundary, + Observation, + Memory, + Prediction, + Goal, + Resource, + Action, + Learning +} +``` + +Possibly with `Identity` as a ninth primitive. + +Everything else could be allowed to emerge. + +### Prompts as nutrients? Not quite + +Distinguish: + +```text +direction +resources +``` + +Prompts provide direction. + +Compute budget provides metabolic capacity. + +```text +Prompt → purpose / objective / constraint +Budget → ability to investigate and act +``` + +The environment effectively says: + +> This matters to me, and I am willing to spend this much energy for you to pursue it. + +### Utility becomes endogenous + +Utility is partly revealed by what the environment repeatedly spends scarce resources on. + +Repeated objective + repeated budget + rewarded outcomes becomes a strong developmental signal. + +### Attention becomes resource allocation + +```text +activation + ↓ +attention allocation + ↓ +compute expenditure +``` + +Attention is the decision to spend scarce information-processing resources on something. + +### A metabolic loop + +```text + ENVIRONMENT + │ + objective + resources + │ + ▼ + perceive + ↓ + understand + ↓ + predict + ↓ + allocate resources + ↓ + act + ↓ + ENVIRONMENT + ↓ + outcome + ↓ + evaluate + ↓ + learn + ↓ + structure changes +``` + +There is also a second loop: + +```text +resources received + ↓ +resources spent + ↓ +usefulness demonstrated + ↓ +environment allocates more resources +``` + +### The environment should not have to fully specify goals + +Explicit goals may be complemented by implicit reinforcement such as acceptance, ignoring, follow-up, correction, additional budget, and wider access. + +Still: + +```text +learned desirability ≠ authority +``` + +### Development rather than training + +Development means gradually learning what entities exist, which distinctions matter, what actions are possible, what consequences follow, and which abstractions are useful. + +### Innate mechanisms versus acquired structure + +The seed should have a small **genotype**, while the deployed system develops a large **phenotype**. + +```text +GENOTYPE +observe +remember +predict +compare +allocate +act +learn +compress + + ↓ development + +PHENOTYPE +Invoice +Supplier +Employee +Department +PaymentRisk +CustomerChurn +... +``` + +### Semantic concepts could emerge from compression + +A seed placed into a company may discover recurring patterns before learning their labels. + +### The seed needs curiosity + +Bounded uncertainty reduction can justify exploration. + +Introduce an **epistemic budget**. + +Possible budget categories: + +```text +goal budget +maintenance budget +exploration budget +``` + +### Metabolism should include return on compute + +Every expensive processing activity should eventually justify its resource use. + +The system can learn the economics of its own cognition. + +### Two fundamental regulators + +**Epistemic regulation** + +> How wrong / uncertain am I? + +**Resource regulation** + +> How much can I afford? + +Combined with: + +> What matters? + +This gives a triad: + +```text +Purpose +Knowledge +Energy +``` + +or: + +```text +Goals +Model +Budget +``` + +### Lifecycle + +```text +1. Attach +2. Observe +3. Orient +4. Assist +5. Specialize +6. Act +7. Regulate +8. Reflect +``` + +### Symbiosis may be a better target than autonomy + +Success is a mutually beneficial coupling with the environment. + +The organization provides: + +```text +information +goals +compute +authority +feedback +``` + +The organism returns: + +```text +predictions +coordination +reduced effort +better decisions +adaptation +``` + +Autonomy is earned through demonstrated viability and usefulness rather than designed in from the beginning. + +### Revised kernel distinction + +**Seed Kernel** + +```text +Identity / Boundary +Observation +Action +Memory +Prediction +GoalInput +ResourceBudget +Learning +``` + +**Developed Semantic Network** + +```text +Node +Edge +Concept +Context +Observer +Goal +ViabilityVariable +Chunk +Process +Capability +Role +... +``` + +A tentative seed formulation: + +\[ +K=(B,O,M,P,A,G,R,L) +\] + +The environment provides: + +\[ +E=(I,G,R,F) +\] + +Development: + +\[ +(K_t,E_t)\rightarrow K_{t+1} +\] + +And a viability condition: + +\[ +\text{value returned to environment} +> +\text{resources consumed} +\] + +over an appropriate time horizon. + +The stronger center is: + +> **not an adaptive semantic graph that we build, but a bounded information organism that develops a semantic graph as its learned internal structure.** + +--- + +## User + +Now envision those systems as organizms that we can organize in an evolutionary sense with mutation and recombination accross generations. Based on the kernel it should be possible to establish and evolved predefined systems for different environments and initial purposes. So the concept potentially allows for the generation of very generic information system problem solvers. + +## Assistant + +Yes. At that point the architecture stops being merely a self-developing information organism and becomes an **evolvable population of information organisms**. + +The most interesting consequence is that we no longer have to choose between a completely generic seed and a heavily engineered application. We can instead let useful intermediate forms emerge and preserve them as **heritable lineages**. + +```text +generic kernel + ↓ +development in environment + ↓ +specialized organism + ↓ +evaluation + ↓ +selection + ↓ +mutation / recombination + ↓ +new generation +``` + +### 1. Genotype versus phenotype + +Three layers: + +```text +Kernel + ↓ +Genotype + ↓ +Phenotype +``` + +**Kernel** + +The almost immutable machinery: + +```text +observe +remember +predict +act +allocate resources +learn +adapt +reproduce +``` + +**Genotype** + +A heritable developmental configuration. + +**Phenotype** + +The actual organism after interacting with an environment. + +\[ +P = Develop(G,E) +\] + +The same genotype can develop differently in different organizations. + +### 2. Breed systems rather than merely configure them + +Different populations may emerge for: + +```text +Document Operations +Customer Service +Security Operations +Software Engineering +Financial Operations +Supply Chain +Knowledge Management +``` + +Specialization is evolutionary rather than architectural fragmentation. + +### 3. Recombination + +A document-understanding organism and a temporal-process reasoning organism may produce offspring inheriting capabilities from both. + +This suggests a modular genotype composed of **Traits**. + +Examples: + +```text +anomaly-sensitive +graph-centric-memory +cautious-actuation +sparse-semantic-chunking +active-human-teaching +document-heavy-environment +``` + +### 4. Inheritance of learned structures + +Possible forms of inheritance: + +- Genetic inheritance +- Epigenetic inheritance +- Cultural inheritance +- Episodic inheritance + +An offspring may inherit how to learn, what usually matters, what others have learned, and selected examples. + +### 5. Optimize developmental potential + +Fitness should include: + +\[ +F = +f( +performance, +resourceEfficiency, +adaptability, +transferability, +robustness, +safety, +developmentSpeed +) +\] + +The most interesting trait may be the ability to become useful in unfamiliar environments quickly and cheaply. + +### 6. Two timescales of adaptation + +Within lifetime: + +```text +learning +``` + +Across generations: + +```text +evolution +``` + +Potentially compressed into minutes, hours, days, and weeks. + +### 7. Third timescale: ecosystem evolution + +Multiple organisms may specialize and cooperate. + +Selection may favor cooperative compatibility. + +### 8. Reproduction should be explicit + +```text +parent phenotype + ↓ +extract heritable state + ↓ +produce genotype + ↓ +mutation / crossover + ↓ +candidate child + ↓ +sandbox development + ↓ +evaluation + ↓ +promotion +``` + +Production organisms can remain stable while descendants are tested. + +### 9. Evolutionary loop + +```text + Population + │ + ▼ + instantiate + │ + ▼ + environments + │ + ▼ + develop + │ + ▼ + evaluate + │ + ┌───────┴────────┐ + ▼ ▼ + survive retire + │ + ▼ + reproduce + │ + ┌─────┴───────┐ + ▼ ▼ +mutation recombination + └─────┬───────┘ + ▼ + next generation +``` + +### 10. Mutation levels + +- Parameter mutation +- Strategy mutation +- Structural mutation +- Developmental mutation + +Developmental mutation changes the rule that determines how structure develops. + +### 11. Recombination should respect interfaces + +Blind crossover is poor for software. + +Recombination should happen across stable interfaces. + +This implies something analogous to a **developmental ABI**. + +### 12. Fitness needs environments, not benchmarks alone + +Evaluate in an ecology of environments: + +```text +quiet enterprise +high-volume enterprise +messy legacy enterprise +strictly regulated enterprise +rapidly changing startup +adversarial environment +resource-constrained environment +``` + +### 13. Generalists and specialists should coexist + +The repository of genotypes becomes a **phylogenetic library of information systems**. + +### 14. Analogy to software distributions + +```text +Information Kernel + ↓ +evolved lineage + ↓ +deployed seed + ↓ +development in environment + ↓ +local organism +``` + +So: + +```text +kernel +lineage +individual +``` + +could become canonical levels. + +### 15. The generic problem solver appears through evolution + +Generality emerges by selecting for: + +```text +rapid environmental understanding +problem decomposition +useful abstraction +efficient experimentation +effective resource use +good transfer +safe action +learning from feedback +``` + +### 16. Artificial “species” + +A species could be a population with compatible genotype interfaces and sufficiently similar developmental machinery. + +### 17. Evolutionary inheritance should include failures + +Lineages may inherit: + +```text +known failure modes +forbidden strategies +bad hypotheses +expensive dead ends +``` + +This enables cumulative negative knowledge. + +### 18. Resource economics becomes selection pressure + +An organism receives: + +```text +objectives +budget +``` + +and selection naturally rewards useful outcome per resource consumed. + +Human attention can also be priced as a scarce resource. + +### 19. Fitness must be multi-dimensional + +Possible dimensions: + +```text +objective_performance +resource_efficiency +adaptability +robustness +transferability +human_attention_cost +safety +explainability +``` + +### 20. Hard constraints should remain outside evolutionary optimization + +Examples: + +```text +tenant isolation +credential boundaries +legal retention +root authority +maximum expenditure +``` + +Evolution optimizes inside the safe envelope. + +### 21. Compact model + +\[ +I = (K,G,P,E) +\] + +Development: + +\[ +P = D(K,G,\mathcal{E}) +\] + +Evaluation: + +\[ +F = Evaluate(P,\mathcal{E},C) +\] + +Reproduction: + +\[ +G' = R(G_1,G_2,\mu) +\] + +### 22. Four nested loops + +**Activation loop** + +```text +observe → activate → respond +``` + +**Learning loop** + +```text +experience → update internal model +``` + +**Development loop** + +```text +environment → phenotype specialization +``` + +**Evolution loop** + +```text +population → selection → reproduction +``` + +Possibly an ecosystem loop: + +```text +species ↔ species +organization ↔ organisms +``` + +### 23. Ecosystem architecture + +```text + Genome Library + │ + ┌─────────────┼─────────────┐ + ▼ ▼ ▼ + lineage A lineage B lineage C + │ │ │ + └──────┬──────┴──────┬──────┘ + │ reproduction + ▼ + Seeds + │ + deploy into environment + ▼ + Organisms + │ + live / learn + │ + ▼ + Fitness Evidence + │ + ▼ + Selection + │ + └──────────────► Genome Library +``` + +The concept becomes: + +> **a hereditary developmental substrate for information-processing organisms that attach to environments, receive purpose and resources, develop internal semantic structures, learn useful behaviors, and contribute their successful adaptations to evolving lineages.** + +Foundational concepts: + +```text +Seed — minimally viable developmental kernel +Organism — developed individual coupled to an environment +Lineage — heritable sequence of related developmental configurations +Ecology — interacting organisms, environments, resources and selection pressures +``` + +--- + +## User + +One final idea to close out this initial exploration of the concept. A very important aspect for such systems is the membrane between the system and its environment. The membrane is an information filter and needs to reduce the vast amount of information potentially available in the environment to what the system effectively samples or accepts as events triggering internal information flows. Establishing and manageing this membrane may be the most relevant control interface to make such an organizm a useful reusable tool or toolkit. + +## Assistant + +Yes. I think that closes the initial exploration around the right center. + +The membrane is not merely an integration layer. It is the **organism’s effective sensorium, attention boundary, and action boundary**. In practice, it may be more important than the internal learning machinery because it determines what world the organism is even capable of perceiving. + +A useful formulation is: + +> **An information organism is defined at least as much by what it can perceive and act upon as by how it processes what it perceives.** + +### The membrane as information filter + +```text +potentially observable information + ↓ +accessibility + ↓ +sampling + ↓ +selection + ↓ +projection + ↓ +event formation + ↓ +internal activation +``` + +The membrane creates an intentional **information bottleneck**. + +Without it, the organism wastes compute, learns irrelevant correlations, becomes harder to govern, and risks crossing information boundaries. + +### The membrane determines the organism's Umwelt + +Two organisms can inhabit the same enterprise but experience radically different worlds. + +A security organism might perceive authentication events, network connections, privilege changes, configuration changes, and security alerts. + +A customer-service organism might perceive customer messages, orders, support cases, contracts, response times, and sentiment. + +Their membranes define different **organizational Umwelten**. + +### Membrane configuration becomes the primary deployment interface + +Configure: + +```text +what it may see +what it should notice +what it may ask for +what it may retain +what it may infer +what it may act upon +``` + +This may shape behavior more strongly than internal business logic. + +### Bidirectional membrane + +The perceptual side asks: + +> What is allowed to become an internal event? + +The actuation side asks: + +> What internal intentions are allowed to become environmental events? + +Together they define the organism's **effective agency**. + +### Filtering should happen before expensive cognition + +Prefer: + +```text +everything + ↓ +deterministic coarse filter + ↓ +cheap semantic filter + ↓ +adaptive attention + ↓ +expensive cognition +``` + +The membrane becomes part of the organism's economics. + +### The membrane should be layered + +#### Constitutional membrane + +Hard boundaries: + +```text +tenant isolation +legal restrictions +credentials +forbidden sources +maximum action authority +privacy +``` + +#### Operational membrane + +Configured scope: + +```text +which systems +which object types +which topics +which event streams +which actions +``` + +#### Adaptive membrane + +Learned relevance: + +```text +this supplier is currently interesting +this event class rarely matters +this pattern predicts failure +``` + +#### Ephemeral membrane + +Current attention. + +Each inner layer can narrow the world further but must not bypass outer layers. + +### Sampling becomes an explicit action + +Observing additional information consumes resources. + +A membrane interaction can itself be an action: + +```text +inspect document +query database +retrieve history +open attachment +ask human +subscribe to event stream +``` + +Perception becomes **active perception**. + +### Membrane evolution may be more important than internal evolution + +Much of evolved intelligence could manifest as: + +> **better selection of what deserves processing.** + +The intelligence problem is partly: + +```text +what should I think about? +``` + +before it is: + +```text +how should I think about it? +``` + +### Habituation and sensitization + +**Habituation** + +Repeated low-value events produce progressively less activation. + +**Sensitization** + +Events associated with significant outcomes receive increased future attention. + +### Learned filtering danger + +If the organism stops sampling a region, it may become blind to change. + +So the membrane needs controlled exploration. + +### Negative space must remain visible + +The organism must distinguish: + +```text +nothing happened +``` + +from: + +```text +I did not observe that region +``` + +Internal knowledge needs observation metadata such as: + +```text +observed +unobserved +filtered +inaccessible +sampled +partially sampled +``` + +### The membrane defines reusable organism classes + +The same evolved core can be specialized through different membranes: + +```text +GenericInformationOrganism + │ + ├── CustomerServiceMembrane + ├── SecurityOperationsMembrane + ├── FinanceMembrane + └── SoftwareEngineeringMembrane +``` + +### Membranes may themselves be heritable + +Lineages can inherit successful perceptual strategies. + +Mutation can affect: + +```text +what is sampled +how frequently +at what resolution +under what conditions +``` + +### Membrane control becomes organism shaping + +> **To deploy an information organism, first define its membrane, not its intelligence.** + +### Compact formalization + +If the environment at time \(t\) contains potential information \(E_t\), the organism does not receive all of \(E_t\). + +Its membrane computes: + +\[ +O_t = M(E_t, G_t, R_t, S_t, C) +\] + +where: + +- \(G_t\) = active goals, +- \(R_t\) = available resources, +- \(S_t\) = organism state, +- \(C\) = constitutional constraints. + +Likewise: + +\[ +A'_t = M_{out}(A_t,C,\text{authority}) +\] + +Only \(A'_t\) reaches the environment. + +### Redrawn concept + +```text + ENVIRONMENT + + information consequences + │ ▲ + ▼ │ + ╔══════════════════════════════╗ + ║ MEMBRANE ║ + ║ ║ + ║ access ║ + ║ sampling ║ + ║ filtering ║ + ║ projection ║ + ║ attention ║ + ║ governance ║ + ║ actuation ║ + ╚══════════════╤═══════════════╝ + │ + ▼ + ┌─────────────┐ + │ ORGANISM │ + │ │ + │ memory │ + │ prediction │ + │ learning │ + │ goals │ + │ planning │ + └─────────────┘ + │ + intention/action + │ + ▼ + MEMBRANE +``` + +Foundational structural concepts: + +```text +Kernel +Membrane +Genotype +Phenotype +Environment +``` + +A stronger definition: + +> **A bounded, resource-constrained, adaptive information-processing system coupled to an environment through a governed membrane. The membrane determines what environmental information becomes experience and which internal intentions may become environmental actions. From sampled experience, externally supplied objectives, feedback, and available resources, the organism develops semantic structures and behaviors that improve its usefulness within that environment. Its developmental configuration may be inherited, mutated, recombined, and selected across generations.** + +And: + +> **The membrane is the governed perceptual and actuation boundary that constructs the organism's effective environment by controlling access, sampling, projection, attention, retention, and action.** + +The more fundamental invention is: + +> **a seedable, governable, evolvable information organism whose intelligence emerges through controlled coupling with an information environment.** + +--- + +## User + +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. + +## Assistant + +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?** + +--- + +## User + +Good, i like the substrate dimensions and the separation of substrate and nutrients. I especially recognized the phrases "Human attention is premium energy" and "Common economic resource". There is a connection between the idea of nutrition and money/cost but they are on different layers of abstraction. Money is an interesting form of high value energy that can easily be transformed into other forms. In the end it is an end towards other means. And it can not substitute human attention. Another point of view is that human attention is valued in economics and regulating this connection can go a long way to establish a healthy/happy situation for humans as scentient beings in economically efficient societies where several dimensions of human capacity are exceeded by super systems like power machines being more physically capable, computing machines providing superhuman speed calculations and not superintelligence providing superhuman reasoning capabilities. + +## Assistant + +Yes. I think this adds an important second layer to the metabolic model: **resource accounting is not the same thing as resource ontology**. + +Money is extraordinarily useful because it acts as a highly fungible claim on many other resources, but it is not itself equivalent to those resources. Human attention makes that distinction especially visible. + +I would frame the system with two layers: + +```text +Physical / operational resources + ↓ +Economic valuation and exchange +``` + +At the lower layer we have actual capacities: + +```text +compute +storage +bandwidth +electricity +machine time +human attention +human judgment +physical labor +land +materials +time +authority +``` + +At the higher layer we have abstract mechanisms for allocating them: + +```text +money +budgets +prices +quotas +credits +contracts +markets +``` + +Money is therefore something like **generalized potential for resource acquisition**. + +It can often be converted into: + +```text +€ → compute +€ → electricity +€ → storage +€ → machine capacity +€ → external services +€ → labor time +``` + +but the conversion is neither perfect nor universal. + +And this is where human attention becomes especially interesting. + +### Human attention is not merely another commodity + +Economically, attention has a price. But ontologically, it is very different from GPU time. + +A person has only: + +```text +24 hours/day +limited waking time +limited sustained concentration +limited emotional capacity +limited cognitive switching capacity +``` + +Money can persuade someone to allocate some of this capacity differently. + +It cannot manufacture an additional hour of that person's conscious life. + +So I would distinguish between **fungible** and **non-fungible metabolic resources**. + +| Resource | Replaceable? | Expandable? | Monetizable? | +|---|---:|---:|---:| +| Compute | highly | highly | highly | +| Storage | highly | highly | highly | +| Electricity | highly | moderately | highly | +| Machine labor | highly | highly | highly | +| Human labor | partially | partially | highly | +| Human attention | weakly | very weakly | partially | +| Trust | weakly | slowly | poorly | +| Expertise | partially | slowly | partially | +| Human lifetime | no | no | imperfectly | + +This distinction should probably matter to the information-organism model. + +### Money as high-grade potential energy + +Money resembles a **portable potential-energy representation** because it preserves optionality. + +A fixed GPU-hour can do only certain things. + +€100 can potentially become: + +```text +GPU time +human consulting +electricity +storage +data access +transport +equipment +``` + +So money has high **resource optionality**. + +That suggests a distinction between: + +```text +specific resource + versus +generalized resource potential +``` + +Money belongs primarily to the latter. + +A useful formulation might be: + +> **Money is a highly fungible coordination token representing socially recognized claims on future resources and capacities.** + +That is why budgets are such an elegant way of constraining information organisms: they do not dictate exactly *how* resources must be consumed. + +They establish a metabolic envelope within which the organism can decide: + +```text +Should I buy more compute? +Should I call an API? +Should I ask a human? +Should I wait? +Should I reuse stored knowledge? +``` + +### Resource exchange needs conversion functions + +We should not model: + +\[ +€1 = X \text{ compute} +\] + +as a universal constant. + +Instead: + +\[ +r_i \xrightarrow{market/context} r_j +\] + +For example, money → compute may be cheap and predictable, while money → expert human attention depends on availability, willingness, relationship, urgency, expertise, time of day, and social norms. + +Money → trust may not be directly possible at all. + +So the resource model requires **convertibility**, not merely price. + +### Hierarchy of resource classes + +#### Commodity resources + +```text +CPU +GPU +storage +bandwidth +electricity +``` + +#### Capability resources + +```text +specific model +specialized tool +expertise +machine capability +``` + +#### Human resources + +```text +attention +judgment +creativity +care +responsibility +presence +``` + +#### Institutional resources + +```text +money +authority +trust +legal rights +reputation +access +``` + +These interact, but should not be collapsed. + +### Human attention deserves special treatment + +> Human attention is a scarce, non-renewable-at-the-individual-timescale, semantically rich resource whose expenditure consumes part of a sentient being's finite lived experience. + +If a system uses 10 additional GPU-hours, the cost is primarily economic/environmental. + +If it unnecessarily consumes 2 hours of a person's concentrated attention, it has consumed two hours of that person's life. + +Money can compensate the person economically, but it does not restore those two hours. + +### Superhuman systems change the comparative advantage landscape + +A useful sequence: + +```text +mechanical machines + → superhuman physical power + +computers + → superhuman arithmetic / speed + +AI systems + → increasingly superhuman information processing and reasoning +``` + +If artificial systems exceed humans across broad cognitive dimensions, then a society organized purely around: + +> economic value = productive superiority + +becomes unstable from the standpoint of human welfare. + +This does not imply that humans become economically valueless. + +It means the **relationship between economic value and human worth has to become more explicit**. + +### Attention regulation may become a core societal control loop + +An economically efficient artificial system might minimize compute cost, storage cost, and latency while externalizing interruptions, human review, decision fatigue, context switching, and emotional burden. + +A healthier architecture treats human attention explicitly as expensive and protected. + +For example: + +\[ +Cost(action)= +C_{compute} ++ +C_{money} ++ +\lambda_h C_{human-attention} +\] + +with \(\lambda_h\) deliberately high. + +Then information organisms learn: + +```text +don't ask a human +unless the expected value of asking +exceeds the cost of consuming their attention +``` + +### Go further than pricing attention + +Price alone is insufficient. + +Human-attention governance needs: + +```text +economic valuation ++ +protective constraints +``` + +Human welfare variables should form viability constraints around economic optimization. + +Possible variables: + +```text +income +autonomy +attention load +rest +social connectedness +health +learning opportunity +meaningful agency +``` + +### A powerful role for superintelligence + +Instead of asking: + +> How do humans compete economically against systems that outperform them? + +ask: + +> How do we use superhuman systems to minimize the amount of involuntary human capacity required to maintain society? + +The goal becomes: + +```text +maximize: + human agency + useful abundance + discretionary attention + safety + opportunity + +minimize: + compulsory cognitive labor + bureaucratic friction + dangerous physical labor + meaningless repetition + involuntary attention capture +``` + +This reframes automation from: + +```text +replace human labor +``` + +to: + +```text +release human capacity +``` + +### Human attention could become the reference scarce resource + +In a world of abundant machine intelligence, **human conscious attention may become one of the least expandable resources in the system**. + +You cannot horizontally scale a person. + +You can horizontally scale inference. + +This suggests: + +> **Compute should be spent to conserve human attention, not the other way around.** + +### This also changes the meaning of efficiency + +Conventional efficiency: + +\[ +Efficiency = +\frac{output}{money} +\] + +A better measure may become: + +\[ +Efficiency = +\frac{useful outcomes}{ +compute + +material resources + +environmental cost + +human attention +} +\] + +with human attention separately visible rather than merely converted into euros. + +Even stronger: + +\[ +Human\ Attention\ Return = +\frac{ +human benefit + human capability released +}{ +human attention consumed +} +\] + +### Sentience introduces a categorical boundary + +Our information organisms may be called “organisms” structurally without implying sentience. + +If humans remain sentient actors while information organisms are non-sentient machinery, then: + +```text +machine compute + instrumental resource + +human attention + resource economically + + + lived experience intrinsically +``` + +That second property prevents full fungibility. + +### A resource ontology could therefore have two axes + +One axis: + +```text +fungibility +``` + +from highly exchangeable to non-substitutable. + +Another: + +```text +moral standing of the resource bearer +``` + +from instrumental substrate to sentient capacity. + +Examples: + +```text +GPU compute + high fungibility + instrumental + +human attention + low fungibility + sentient-associated + +money + very high fungibility + institutional abstraction +``` + +### Resulting societal control loop + +```text + HUMAN PURPOSE + │ + ▼ + objectives + │ + ▼ + economic allocation + │ + ┌───────────────┼───────────────┐ + ▼ ▼ ▼ + money compute machine capacity + │ │ │ + └───────────────┼───────────────┘ + ▼ + information organisms + │ + work + │ + ▼ + abundance + │ + ▼ + human benefit + │ + └──── feedback + +while: + +human attention +human autonomy +human wellbeing + │ + ▼ +protected viability boundaries +``` + +A phrase worth keeping: + +> **Money is generalized resource potential; attention is lived capacity.** + +The former can frequently be transformed. + +The latter can only be allocated once. + +And for information-organism design: + +> **Spend abundant machine resources to preserve scarce sentient resources.**