assembly-economics/history/20261011-InitialExploration.md

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

Invoice ──submitted-to──> AccountsPayable
Employee ──occupies──> EmployeeRole
EmployeeRole ──uses──> WorkstationClass
PurchaseOrder ──precedes──> Invoice

These are relatively stable relationships between types/concepts.

Concrete activation

Invoice #4711
Employee "Alice"
Workstation WS-328
PurchaseOrder #9912

These are tokens moving through or activating that structure.

And finally:

Network state

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:

                  ┌─────────────┐
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:

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:

Supplier:X
   +
Invoice
   +
MonthEnd

may eventually strongly activate:

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:

A activated
B activated
+
later success/error signal
──────────────────────────
change A → B

This maps beautifully to business systems.

Suppose:

Invoice
 → OCR
 → VendorMatching
 → AutoApproval
 → Payment

Twenty minutes later:

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:

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:

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.

Customer observer
Finance observer
Security observer
Compliance observer
Operations observer

There may therefore be no universally "good" path.

A path can be:

fast        +0.9
cheap       +0.8
secure      +0.3
reliable    +0.6

while another is:

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:

Goal
 ├── MinimizeProcessingCost
 ├── MinimizeCustomerWaitingTime
 ├── AvoidFraud
 ├── MaintainCompliance
 └── PreserveHumanAttention

And instantiate them contextually:

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:

given A,
how likely is B?

Example:

PurchaseOrder
     ↓ 0.94
Delivery
     ↓ 0.91
Invoice
     ↓ 0.97
Payment

Suppose this happens:

PurchaseOrder
Delivery
Invoice
<no Payment>

Nothing explicitly needs to say "error."

The network expected Payment.

Its absence is information.

Likewise:

Invoice
 → LegalComplaint

may be extremely surprising.

So each processing episode naturally generates:

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:

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:

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

A ──0.3──▶ B

Learn:

0.3 → 0.47

Level 1 — edge discovery

Repeated correlation creates:

A ─────▶ C

Level 2 — inhibition

Learn:

A ──| B

Level 3 — contextual relationships

Discover:

A + context:X → B

Level 4 — concept formation

Repeated pattern:

A → B → C
A → B → C
A → B → C

becomes:

       ┌─────────────┐
A ───▶ │ Pattern P17 │ ───▶ C
       └─────────────┘

Eventually the system may discover that P17 corresponds to something humans call:

"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:

Invoice → Validate → Approve → Pay

At another:

AccountsPayableProcess

And higher:

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:

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:

input
 ↓
latent representation
 ↓
latent representation
 ↓
output

The internal units intentionally have no stable human interpretation.

Your network would instead preserve semantic identity:

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

                  ENVIRONMENT
                      │
                      ▼
                 observations
                      │
                      ▼
              ┌─────────────────┐
              │ semantic ingest │
              └────────┬────────┘
                       │
                       ▼
                   ACTIVATE
                       │
                       ▼
             ┌──────────────────┐
             │ spread activation│
             │ predict          │
             │ select           │
             └────────┬─────────┘
                      │
                    action
                      │
                      ▼
                  ENVIRONMENT
                      │
                  consequences
                      │
                      ▼
                  OBSERVERS
                      │
       ┌──────────────┼──────────────┐
       ▼              ▼              ▼
     error          success       surprise
       └──────────────┬──────────────┘
                      │
                      ▼
                   LEARNING
                      │
             ┌────────┴────────┐
             ▼                 ▼
          weights           structure

And crucially:

learning → changes future activation

rather than:

learning → writes another business rule

14. I would separate four kinds of learning

Associative learning

What tends to occur together?

EmployeeRole ↔ WorkstationClass

Predictive learning

What follows what?

ApprovedInvoice → Payment

Instrumental learning

What actions produce desirable consequences?

Invoice → AutoApprove → good outcome

Structural learning

What new concepts or processes should exist?

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:

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:

error = desired_range - observed_state

produces regulatory activation.

For example:

operator_load > 0.85

activates:

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

              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:

Invoice

may persist for years.

A concrete invoice:

Invoice #4711

may activate that node during a processing episode.

The persistent network accumulates knowledge from many such episodes.

The foundational processing cycle is:

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:

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:

Invoice → Approval

does not imply that either node is currently active.

3.3 Observation and evaluation are distinct

The system MUST distinguish:

what happened

from:

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:

Complaint → ManualEscalation

may have:

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:

MinimizeCost
ReduceLatency
AvoidFraud
MaintainCompliance
PreserveHumanAttention

Goal activation may vary with context.

3.8 Viability precedes optimization

The network SHOULD distinguish:

remaining within viable operating bounds

from:

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:

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:

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:

Invoice
EmployeeRole
WorkstationClass
OCRCapability
FraudRisk
HumanReview
CustomerComplaint

A node SHOULD possess stable identity independent of its temporary activation state.

Conceptually:

node:
  id: Invoice
  kind: DocumentType

Useful semantic kinds include:

EntityType
State
Role
Capability
Process
Resource
Context
Goal
Risk
Observer
Policy
Concept

A node MAY maintain learned or temporary state including:

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:

Invoice #4711
Employee Alice
Workstation WS-328
Shipment #91284
Customer Request #882

A token MAY activate multiple nodes simultaneously.

Example:

Invoice #4711

might activate:

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:

Invoice → requires → Approval

Edges SHOULD be typed.

Possible examples include:

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:

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:

MonthEnd
EmergencyOperation
HighSystemLoad
CustomerFacing
ProductionEnvironment
NightShift

The network SHOULD be capable of distinguishing:

A → B

from:

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:

RouteToHumanReview
SendNotification
ApproveDocument
RequestMissingData
DelayProcessing
Escalate

The canon distinguishes:

something happened

from:

the network caused something to happen.

An action MAY be:

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:

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:

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:

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:

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:

Invoice #4711

Semantic interpretation activates:

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:

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:

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

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:

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

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:

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

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:

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:

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

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:

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:

semantic representation ≠ authoritative state

The network may infer something while the enterprise system records something else.

A useful information classification:

OBSERVED
DECLARED
INFERRED
PREDICTED
PROPOSED
AUTHORITATIVE

5. The membrane should be bidirectional, but asymmetrical

Inbound:

Enterprise System
    ↓
observe / subscribe / query
    ↓
normalize
    ↓
semantic projection
    ↓
network activation

Outbound:

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

1. Observe
2. Identify
3. Project
4. Govern
5. Actuate

7. Artefact vs representation

Distinguish:

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:

source artefact
  ↓
sensor
  ↓
semantic activation

Outbound:

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:

schema mappings
entity matching
semantic extraction
source reliability

Other parts should remain deterministic:

authorization
tenant isolation
retention enforcement
write permissions
source-system contracts

17. SourceBinding

A useful conceptual object:

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

┌────────────────────────────────────────────┐
│         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:

integrate all enterprise data

but:

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:

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:

compute
tokens
storage
API calls
human attention
time
money

So budget is the metabolic resource of the organism.

A minimal kernel

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:

direction
resources

Prompts provide direction.

Compute budget provides metabolic capacity.

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

activation
   ↓
attention allocation
   ↓
compute expenditure

Attention is the decision to spend scarce information-processing resources on something.

A metabolic loop

             ENVIRONMENT
                  │
          objective + resources
                  │
                  ▼
              perceive
                  ↓
             understand
                  ↓
              predict
                  ↓
        allocate resources
                  ↓
                act
                  ↓
             ENVIRONMENT
                  ↓
              outcome
                  ↓
              evaluate
                  ↓
               learn
                  ↓
        structure changes

There is also a second loop:

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:

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.

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:

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:

Purpose
Knowledge
Energy

or:

Goals
Model
Budget

Lifecycle

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:

information
goals
compute
authority
feedback

The organism returns:

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

Identity / Boundary
Observation
Action
Memory
Prediction
GoalInput
ResourceBudget
Learning

Developed Semantic Network

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.

generic kernel
     ↓
development in environment
     ↓
specialized organism
     ↓
evaluation
     ↓
selection
     ↓
mutation / recombination
     ↓
new generation

1. Genotype versus phenotype

Three layers:

Kernel
  ↓
Genotype
  ↓
Phenotype

Kernel

The almost immutable machinery:

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:

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:

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:

learning

Across generations:

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

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

              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:

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

Information Kernel
    ↓
evolved lineage
    ↓
deployed seed
    ↓
development in environment
    ↓
local organism

So:

kernel
lineage
individual

could become canonical levels.

15. The generic problem solver appears through evolution

Generality emerges by selecting for:

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:

known failure modes
forbidden strategies
bad hypotheses
expensive dead ends

This enables cumulative negative knowledge.

18. Resource economics becomes selection pressure

An organism receives:

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:

objective_performance
resource_efficiency
adaptability
robustness
transferability
human_attention_cost
safety
explainability

20. Hard constraints should remain outside evolutionary optimization

Examples:

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

observe → activate → respond

Learning loop

experience → update internal model

Development loop

environment → phenotype specialization

Evolution loop

population → selection → reproduction

Possibly an ecosystem loop:

species ↔ species
organization ↔ organisms

23. Ecosystem architecture

                    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:

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

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:

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:

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:

tenant isolation
legal restrictions
credentials
forbidden sources
maximum action authority
privacy

Operational membrane

Configured scope:

which systems
which object types
which topics
which event streams
which actions

Adaptive membrane

Learned relevance:

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:

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:

what should I think about?

before it is:

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:

nothing happened

from:

I did not observe that region

Internal knowledge needs observation metadata such as:

observed
unobserved
filtered
inaccessible
sampled
partially sampled

The membrane defines reusable organism classes

The same evolved core can be specialized through different membranes:

GenericInformationOrganism
        │
        ├── CustomerServiceMembrane
        ├── SecurityOperationsMembrane
        ├── FinanceMembrane
        └── SoftwareEngineeringMembrane

Membranes may themselves be heritable

Lineages can inherit successful perceptual strategies.

Mutation can affect:

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

                  ENVIRONMENT

        information        consequences
             │                  ▲
             ▼                  │
     ╔══════════════════════════════╗
     ║          MEMBRANE            ║
     ║                              ║
     ║ access                       ║
     ║ sampling                     ║
     ║ filtering                    ║
     ║ projection                   ║
     ║ attention                    ║
     ║ governance                   ║
     ║ actuation                    ║
     ╚══════════════╤═══════════════╝
                    │
                    ▼
             ┌─────────────┐
             │   ORGANISM  │
             │             │
             │ memory      │
             │ prediction  │
             │ learning    │
             │ goals       │
             │ planning    │
             └─────────────┘
                    │
             intention/action
                    │
                    ▼
                MEMBRANE

Foundational structural concepts:

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:

information artifacts
+ compute
+ storage
+ runtime capacity
+ external services
+ human attention
+ authority
+ time

and produces:

interpretations
predictions
decisions
actions
new information artifacts
learned structure
coordination
environmental change

plus waste:

obsolete memory
failed hypotheses
redundant representations
logs
temporary embeddings
dead branches
unused intermediate results
compute heat/cost

At the highest level:

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

runtime environment
storage
execution engine
network connectivity
identity
credentials
resource accounting
semantic membrane

Nutrients

documents
events
messages
prompts
data
compute budget
API allowance
human feedback

3. Six fundamental substrate layers

1. Information substrate
2. Computational substrate
3. Memory substrate
4. Execution substrate
5. Interaction substrate
6. Governance substrate

4. Information substrate

Raw informational material:

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:

CPU
GPU
accelerator time
LLM tokens
database queries
network transfer
external API calls

These can often be translated into a common economic resource:

cost

or:

compute credits

6. Prompts are more like hormones than nutrients

Prompts modulate processing.

They alter:

goal activation
attention
sampling
resource allocation

So:

Prompt → metabolic direction
Budget → metabolic capacity

7. Runtime is the physical habitat/body substrate

The organism must exist somewhere:

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:

storage
indexing
retrieval
maintenance
security
context pollution

The organism should decide when to retain, compress, summarize, generalize, forget, or archive.

9. Information digestion

raw artifact
    ↓
accessible representation
    ↓
decoded content
    ↓
semantic claims
    ↓
relevant observation
    ↓
internal activation

This suggests information digestibility.

10. Metabolic pathways

Examples:

Retrieval pathway

question
→ identify information need
→ query source
→ retrieve artifact
→ project semantics
→ answer

Classification pathway

incoming artifact
→ decode
→ extract features
→ compare patterns
→ classify
→ emit event

Planning pathway

goal
→ construct alternatives
→ predict consequences
→ evaluate
→ select

Learning pathway

episodes
→ detect regularity
→ form hypothesis
→ test
→ strengthen structure

11. Enzymes have a useful computational analogue

Equivalent computational enzymes:

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:

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:

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:

more reuse
more compression
less exploration
cheaper models
more selective sensing

Under abundance:

more exploration
more simulation
deeper evidence retrieval
parallel hypotheses
structural learning

18. Metabolic waste

Waste includes:

temporary scratch data
stale embeddings
expired caches
obsolete hypotheses
unused branches
duplicate facts
low-value logs
superseded models

Needed processes:

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:

doing work

from:

growing

Possible budget split:

maintenance metabolism
task metabolism
growth metabolism
exploration metabolism

21. A plausible metabolic budget

budget:
  operations: 60%
  learning: 15%
  exploration: 10%
  consolidation: 5%
  maintenance: 10%

22. Minimal substrate stack

┌─────────────────────────────────────┐
│  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

runtime
basic storage
network
identity

Allocated substrate

compute budget
LLM tokens
API quota
storage quota

Acquired substrate

additional compute
new data access
new tools
human attention
increased authority

24. Self-reasoning about metabolism

The organism can learn:

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

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:

Physical / operational resources
    ↓
Economic valuation and exchange

At the lower layer we have actual capacities:

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:

money
budgets
prices
quotas
credits
contracts
markets

Money is therefore something like generalized potential for resource acquisition.

It can often be converted into:

€ → 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:

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:

GPU time
human consulting
electricity
storage
data access
transport
equipment

So money has high resource optionality.

That suggests a distinction between:

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:

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

CPU
GPU
storage
bandwidth
electricity

Capability resources

specific model
specialized tool
expertise
machine capability

Human resources

attention
judgment
creativity
care
responsibility
presence

Institutional resources

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:

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:

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:

economic valuation
+
protective constraints

Human welfare variables should form viability constraints around economic optimization.

Possible variables:

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:

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:

replace human labor

to:

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:

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:

fungibility

from highly exchangeable to non-substitutable.

Another:

moral standing of the resource bearer

from instrumental substrate to sentient capacity.

Examples:

GPU compute
  high fungibility
  instrumental

human attention
  low fungibility
  sentient-associated

money
  very high fungibility
  institutional abstraction

Resulting societal control loop

                   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.