BeastJS Project - Implementation of a Homeostatic Creature

Chapter 1: Introduction and Fundamental Principles

BEAST (Browser-based Embodied Agent Simulation and Testing) is a browser application that models individual adaptability. The goal is not to create a "working creature", but to formalize and implement the theory of adaptive systems as software code. The project acts as a tool for learning and debugging the architecture, where every detail of behavior follows strict, documented, and executable algorithms.

In the /demos/ folder there are demos that illustrate the implemented principles.

1.1 Purpose

BEAST is positioned as the most adequate way to implement the theory of individual adaptability. Just as mathematics formalizes physical laws, BEAST serves as a formalization layer for adaptive systems theory. The code is not only a product: it is also a specification and a "working diagram" of how the system works, enabling testing, modification, and debugging of adaptive behavior.

Complex verbal interfaces (phrase recognition, symbols, tone of messages) are intentionally excluded. The focus stays on core layers: homeostasis, basic contexts, stimuli, reflexes, an evidence/condition tree, semantic and episodic memory, the consciousness (awareness) process, and automatisms.

1.2 Architecture Core: From Organism to Consciousness

BEAST is built around a hierarchical model: each new layer abstracts and makes behavior more capable than the layer below.

1. Homeostasis (body): the base level is represented by vitals (_1_Genetic_vitals). It is a set of parameters (wounds, hunger, stress, etc.) whose values change dynamically (via shift) every pulse. The vitals state determines the integral condition importance (IntergalConditionImportance) and the base condition: Poor (1), Normal (2), Well (3) (BadNormWell).
2. Context (emotion): based on vitals output relative to the norm, the system activates basic contexts (_2_Genetic_basic_styles) - behavioral/emotional patterns (Fear, Aggression, Play, Curiosity, Calm, etc.). Their combination forms an emotion (an EmotionId), which together with the base state and the current stimulus defines the perception tree branch (_7_perception_tree). That branch (branchId) is a key identifier of the current situation.
3. Stimuli and reflexes (input-output): the operator interacts through stimulus buttons (_3_perception). The combination of active stimuli forms the final image (FinalImageId). In response, genetic reflexes (_5_Genetic__reflexes) fire and trigger base actions (e.g. Cry, Eat). These actions are registered as action images (an ActionImageId). The system can also form conditional reflexes (_5_2_synonyms_reflexes) by linking the final image to an action under specific context conditions.
4. Memory (experience): each interaction leaves traces.
   • Semantic memory (_6_semantic_memory) stores how important (via meanImportance) a stimulus is in given conditions (base state + emotion). This becomes the basis for evaluating usefulness or harmfulness of stimuli.
   • Episodic memory (_10_Episodic_memory) stores rules: stimulus → action → effect (effect). Each memory frame represents a chain condition (branch) → action → consequence (a change in importance). If the operator provides a stimulus response during waiting, the resulting rule is stored as a teacher rule (responseStimulusImageId).
5. Consciousness (awareness): a central process that manages behavior. It is organized as consciousness cycles registry (ConsciousnessCycles) and an iterative dispatcher (consciousness_dispatcher.js).
   • Orientation Reflex (OR) (_8_Hippocampus) is the trigger. It selects the most relevant stimulus among all active ones by evaluating novelty and importance. When it passes the threshold (OR_well_known), it starts the consciousness process (stimuls_consciousness) and creates an episodic memory frame.
   • Level 1 (elementary): tries to find a ready answer (a positive episodic rule, or a default automatism for the branch).
   • Level 2 (conscience_level_2.js): invoked when no ready solution exists. It sets a goal: survival (critical vitals, sudden worsening) or more complex goals from life experience (a better rule with positive effect), and it also processes the operator response received after an action.
   • Level 3 (conscience_level_3.js): a pipeline for complex solutions: mental automatisms, rules from the semantic structure of abstractions, and a teacher fallback. It is strictly guarded by a waiting gate so it does not repeat searching until feedback is received.
   • Level 4 (conscience_level_4.js, gestalt.js): a gestalt level that works with long-lived dominants (unsolved tasks) and cross-cycle analogies through a resonance buffer.

1.3 Time: Discrete Pulse

The fundamental unit of time in BEAST is the pulse (puls.js). It is an artificial, discrete timeline used to run most system processes.

• Each pulse updates vitals, activates contexts, processes genetic and conditional reflexes, and provides a step for the consciousness dispatcher.
• Important processes tied to waiting (e.g. the waiting period for an operator response in episodic memory) are measured in pulses, not in real time. This ensures determinism and predictability and avoids problems with asynchronous timers.
• Anything that must stay synchronous with state changes (e.g. registering effect after an action) is anchored to the pulse. This prevents race conditions between UI events and internal logic.

1.4 Key Concepts

• Vitals (VitalsArr) ˜ time-varying organism state parameters.
• Basic contexts (BasicContexts) ˜ behavioral/emotional modes activated by vitals outputs relative to the norm.
• Final image (FinalImageId) ˜ a unique identifier for each combination of active stimuli.
• Conditions ˜ a pair of base state (BadNormWell) and emotion (EmotionId) describing the context for stimulus perception.
• Perception tree branch (perceptionNodeId) ˜ a full path across 6 levels (base state → emotion → stimulus → ...), uniquely identifying the situation.
• Action image (ActionImageId) ˜ an abstraction of an action that can include one or more base actions.
• Effect (effect) ˜ quantitative evaluation of how the action changes integral condition importance. Range: [-10, +10].
• Automatism ˜ a rule attached to a perception tree branch (branchId) that prescribes executing a given action image when the branch becomes active. It has usefulness (usefulness).
• Gestalt ˜ a long-lived dominant (an unsolved problem) tied to a goal image. It accumulates analogies and can produce insights.

Chapter 2: Pulse Flow: From Stimulus to Action (Corrected Version)

2.1 Pulse Lifecycle

The central loop is implemented in beast/puls.js via a recursive function sep_of_puls() that simulates a ˜heartbeat˜.

Each pulse follows a fixed sequence of steps:

2.2 Orientation Reflex (OR) as a Trigger

OR (orientation_reflex.js) starts on any change in the set of active stimuli (operator click). It is the central mechanism for deciding what the system should pay attention to.

2.2.1 Winner Selection Algorithm

• Step 1: Collect candidates. Consider the full set of active stimuli as FinalImageId, and each active stimulus separately as candidates (each candidate corresponds to its own FinalImageId).
• Step 2: Compute relevance for each candidate. relevance = novelty × importance.
• Step 3: Competition and hysteresis. Candidates (except the previous winner) are reduced by OR_HYSTERESIS = 0.5, with modifiers such as doubling under an ImportantProblem condition and skipping hysteresis for stimuli from a priority chain.
• Step 4: Post-winner threshold checks. Avoid creating episodic frames during an episodic waiting period, and check ˜sufficient experience˜ (samplesCount < OR_well_known) before running the full episodic flow.
• Step 5: Run the full consciousness cycle (if all checks pass). Save the winner in hippocampus, block reflexes for 2 pulses, queue delayed reflexes by branchId, enter consciousness processing (stimuls_consciousness(context)), and create the episodic memory frame.

2.3 Consciousness Process: From Input to Action

stimuls_consciousness (conscious_attention_channel.js) is a gate that decides whether the system should interrupt the current thought with a new stimulus.

2.3.1 Interrupt Threshold (˜Thinking Silence˜)

If there is an active main consciousness cycle and it is not marked expired, the new stimulus competes with it. The base condition compares effective stimulus significance with the current thinkingImportance and an interrupt ratio (INTERRUPT_THRESHOLD_ATTENTION_RATIO with a default of 1.5). Additional modifiers apply depending on situation/theme mismatch, important problem state, priority chains, or the orientation reflex winner.

2.3.2 Create an Episodic Consciousness Cycle

• If the threshold is passed: push the current main cycle into a background stack (ConsciousnessBackgroundStack).
• Create a new cycle via Consciousness_createCycle with weight equal to stimulus significance.
• Set the new cycle as main (Consciousness_setMainCycle).

2.3.3 Elementary Pass (Levels 1˜2)

• Level 1 ˜ find an automatic solution: check for a positive episodic rule, otherwise start a default automatism for the branch.
• Level 2 ˜ set a goal and solve: fix unsolved_problem as the current stimulus, then call conscience_level_2(context) to determine a goal with priority from survival to life-experience-driven goals. If an automatism is started, the cycle waits for operator feedback.
• When an automatism starts: mark the cycle as expired and set awaitingAutomatismEpisodeFeedback = true, storing the started automatism ID in EpisodicMemory_pendingFeedbackAutomatizmId.

2.4 Reflexes on the Pulse: Genetic and Conditional

Reflex processing (processGeneticReflexes) occurs on each pulse after the consciousness dispatcher. This ensures that if awareness already started an automatism, a reflex for the same branch does not fire in the same pulse.

2.4.1 Processing Order

• 1) delayed reflexes (blocked by OR for 2 pulses), executed if not removed when an automatism started
• 2) conditional reflexes (synonyms_tryRunReflexes()) after maturity checks (tryCount > 3) with stimulus and context match
• 3) genetic reflexes: compare current and previous active stimuli and select actions for each new stimulus

2.4.2 Forming Conditional Reflexes

A conditional reflex is created when synonyms_onGeneticActionFired is called (from startAction), provided:

• the action source is not 'synonym' (no re-trigger of conditional reflex)
• noConditionalReflex flag is not set
• there is no episodic waiting period
• there is more than one active stimulus (so they can be combined)

Core structure:

• context: a string like "well:id1,id2" (base state + basic contexts)
• stimulIds: global stimulus IDs active except the one that triggered the response
• actionId: an ID of a base action
• tryCount: number of learned combinations (maturity threshold = 3)
• isReady: becomes true after tryCount > 3

2.5 Action and Memory Registration

startAction (genetic_reflexes_engine.js) is the final point where an action becomes a fact.

Typical effects:

• Update UI ˜Beast Activity˜ block with action name and stimulus importance
• Switch info panel mode (Info_setMode('target'))
• Register/extend the action image (ActionsImage_registerReaction(finalImageId, actionId))
• Write into the open episodic frame (EpisodicMemory_setLastFrameActionFromActionId(actionId))
• Train conditional reflexes (synonyms_onGeneticActionFired(stimId, sourceType, actionId))
• Optionally register prolonged actions for future vitals influence

2.6 Closing the Episodic Frame and Evaluating Effect

Closing the episodic frame is the moment when feedback is obtained. It can happen in three ways:

Inside closeLastFrame, the effect is computed (conceptually): effect = clamp(diffAfter - diffBefore, -10, +10), missing parts of the rule are filled with 0 markers, and the effect is passed to automatisms as usefulness updates. It then notifies modules (gestalt, abstractions cloning, semantic/mental rules updates).

Chapter 3: Memory Models and Abstractions (Episode ? Knowledge)

3.1 Three Memory Levels

3.2 Semantic Memory: Importance of an Image

Semantic memory answers: ˜How important is this stimulus in these circumstances?˜. A semantic record stores a running average of effect-based usefulness.

Semantic record (structure):

{
  wellNormaBad: 1|2|3,   // Poor/Normal/Well
  emotionId: number,    // Emotion (combination of basic contexts)
  finalImageId: number,// Stimulus image ID
  meanImportance: number, // average importance (smoothed effect)
  samplesCount: number,   // number of observations
  lastImportance: number   // last stored value
}

Semantic records are updated in two places:

• During OR stimulus activation: register semantic sample before the system reacts.
• When an episodic frame closes: use addUsefulnessSample as clones average importance based on effect.

3.3 Episodic Memory: Rules and Their Closure

Episodic memory stores frames describing what happened: in which conditions, what stimulus, what action, what effect, and how the operator responded.

Episodic frame (structure):

{
  perceptionNodeId: number,      // perception tree branch ID (conditions)
  stimulusImageId: number,      // stimulus image ID
  situationId: number,          // situation ID (from situations tree)
  actionImageId: number|null,  // action image ID (null until executed)
  effect: number|null,         // effect (-10..+10, null while open)
  responseStimulusImageId: number|null, // operator answer image ID
  diffBefore: number,          // importance before activation (for effect calculation)
  createdAt: number            // timestamp
}

A frame has a lifecycle: created after OR threshold passes (waiting starts), filled with actions during startAction, and closed by operator response, timeout, or a new OR winner.

3.4 Abstractions: Clones of Hard Images

Abstractions are ˜clones˜ of hard perception/action images. Unlike their hard prototypes, they can be freely combined and exist as long-lived structures. Abstractions maintain a semanticStructure, a set of rules bound to specific conditions (branch + situation).

3.4.1 Two clone types

3.4.2 Rule priorities inside semanticStructure

• teacher has highest priority
• episodic has medium priority
• fantasy has lowest priority

3.5 Mental Automatisms and ˜Symbols˜

Over abstractions, an additional mental layer is built: symbols (abstractions) and mental automatisms (MentalAutomatizms). Mental rules are created from episodic feedback and link the semantic abstraction to a mental action. After operator feedback with positive effect, mental automatisms can be created from semanticStructure rules.

Chapter 4: Gestalts, Dominants, and Insights

4.1 What is a Gestalt in BEAST

A gestalt is a long-lived dominant: a record about an unsolved task. Unlike an episodic frame (˜what happened˜ within one cycle), a gestalt lives across many cycles and can accumulate information about attempts to solve the problem.

• Tied to a goal image (goalImageId)
• Stores a list of tried automatisms (automatismIds)
• Has a status from 0 (new) to 3 (successfully closed)
• Accumulates analogies in an analogyPool
• Can generate insights that change understanding of the task

4.4 Gestalt Resonance Buffer

A gestalt has a FIFO resonance buffer containing signatures of closed episodic frames. Each signature is an ˜experience snapshot˜ that can later support analogy-based reasoning.

Resonance buffer rules (summary)

• Maximum size: MAX_RESONANCE_BUFFER (48 entries)
• On overflow: oldest entries are evicted
• Filled only when an episodic frame closes (inside closeLastFrame)

4.5 Insights and Analogies

Insights link a gestalt˜s goal-image representation to a concrete candidate solution (an automatism/analogy), changing how the system understands the problem.

• pre: a preliminary re-interpretation when effect is not positive
• local: an insight when the meaning forecast supports a local match
• analogy: created when resonance buffer signatures match the open gestalt
• feedback: triggered by episodic feedback with sufficiently strong effect

4.10 Current Implementation Limits

1. No gestalt re-opening: if a gestalt is closed successfully (status=3), a new record for the same goal is not created.
2. No full ˜gestalt building˜: analogyPool accumulates analogies, but does not necessarily synthesize a new rule from them yet.
3. Gestalts do not directly influence goal selection: they provide context for level 3 but do not initiate a goal switch by themselves.
4. No ˜forgetting˜: archived gestalts (status=4) are not deleted/cleaned.

Chapter 5: Persistence and State Saving

5.1 Two Persistence Strategies

5.2 IndexedDB: Automatic Background Saving

The wrapper and saver registration mechanism are implemented in sys/IndexedDB/indexeddb.js. Each module registers a function via registerIndexedDBSaver.

• On each pulse: call runIndexedDBSavesForPulse().
• Execute all registered save functions.
• Each module decides whether it needs to save (via a dirty flag).

5.2.3 Optimization: dirty flag + state signature

Modules use a combination of:

• *Dirty flag (e.g. epDirty)
• last*SavedSig (a JSON signature of the last saved state)
• serializeState() to obtain a state snapshot

If the signature did not change, the system avoids writing again even if some metadata changed ˜semantically˜.

5.3 Saving to File: Full Memory Snapshot

In date/saving_ui.js there is a registry of BEAST.persistentModules. Each module registers:

• key (the JSON file key)
• serialize (returns the state for saving)
• apply (applies loaded state)

Examples of registered modules:

End of manual.