# Regulatory Computation ## A Formal Abstraction and Architectural Primitive for Persistent Intelligent Systems **Sean Manouge** Founder, Nilsoft Adelaide, Australia September 2026 **Position paper** --- ## Abstract Persistent intelligent systems face a control problem that is only partly addressed by perception, reasoning, memory, reinforcement learning, planning, and conventional action selection. Their behaviour may need to change not because a new external event has occurred, but because internal condition has accumulated, drifted, persisted, or become predictably unsustainable over time. Existing research already contains important parts of this problem. Control theory provides mature accounts of feedback, stability, disturbance rejection, and predictive control. Artificial endocrine systems have used hormone-like signals for distributed robotics, task allocation, behaviour coordination, and power management. Homeostatic reinforcement learning has formalised behaviour around deviations of internal variables. Neuromodulated machine-learning architectures have demonstrated learned secondary signals that alter activation and plasticity. Computational interoception increasingly treats internal-state sensing and regulation as a first-class problem for adaptive artificial agents. Autonomic computing and metareasoning likewise address self-management and the allocation of bounded computational resources. What remains less explicit is the systems-level contract connecting these traditions. This paper proposes **Regulatory Computation (RC)** as that contract. Regulatory Computation is computation in which **persistent, bounded-bandwidth internal signals integrate temporal history, observed and anticipated conditions, and viability constraints, then modulate heterogeneous computational subsystems through receiver-specific response functions without directly specifying effect-level actions or expanding authority**. The claim is deliberately architectural rather than computability-theoretic. RC does not introduce a new class of computation, nor does it claim invention of artificial hormones, homeostatic agents, neuromodulation, interoception, adaptive control, or self-managing software. It proposes a reusable decomposition: distinguish task state from internal condition; condition-signalling from effect specification; modulation from decision; and behavioural pressure from authority. The paper formalises an **Internal Milieu**, persistent regulatory dynamics, multi-timescale accumulation and decay, receiver-specific **receptors**, homeostatic and allostatic objectives, and a governance invariant under which regulatory state may alter preferences over admissible actions but cannot enlarge the admissible action set. It then derives a reference architecture, identifies security and stability failure modes, and proposes a falsifiable benchmark programme. The strongest claim presently supported is therefore narrow: Regulatory Computation may be a useful architectural primitive for systems expected to remain coherent under changing conditions over long periods. Whether it deserves broader status depends on evidence that this decomposition improves viability, adaptability, resource efficiency, modularity, inspectability, or safety relative to simpler alternatives. --- ## 1. The persistence problem Most software is organised around events. An input arrives. Computation occurs. State changes. A response is produced. Contemporary AI systems have made that loop more capable without fundamentally escaping it. A model receives context and emits a prediction. An agent observes, reasons, acts, and observes again. A workflow chains tool calls. A scheduler invokes another run. Even systems described as persistent are often assembled from a sequence of discrete cognitive episodes joined by explicit memory, queues, databases, or application-specific controller logic. This is sufficient for many tasks. It becomes less satisfactory as the system itself acquires history. A long-running intelligent system may have spent hours exploring an unproductive branch. It may have accumulated unresolved contradictions, consumed most of a compute budget, experienced repeated execution failures, deferred maintenance, filled context and memory stores, or entered a period of unusually high operational demand. None of those conditions is adequately described by the next external observation alone. Nor are they always best represented as another episodic memory item. The missing object is **condition**. Condition is not merely what happened. It is what the history of what happened has done to the system now. That distinction matters because persistent systems should sometimes behave differently even when their immediate task input is identical. The same request may deserve wider exploration when resources are abundant and uncertainty is low, narrower reasoning when cost pressure is high, stronger verification after a sequence of failures, or deferral when unresolved-state burden has crossed a safe threshold. If each adjustment must be independently encoded as task logic, configuration, or local heuristics, long-horizon behaviour fragments across the architecture. The problem is not that existing computation cannot represent such state. It plainly can. A sufficiently general controller can encode arbitrary persistent variables and response functions. The question is architectural: > **Should persistent internal condition be represented as a distinct computational substrate, with explicit dynamics and bounded influence over heterogeneous subsystems?** Regulatory Computation is proposed as an answer to that question. The motivation is not mystical biology. It is a mundane systems problem that becomes unavoidable once intelligent software stops living entirely inside isolated request-response episodes. --- ## 2. From state to regulation A system can possess state without possessing regulation. A database row is state. A configuration flag is state. A cached preference is state. A recurrent neural network contains state. None of those facts alone establishes a regulatory architecture. Regulation begins when internal state is maintained because its trajectory matters to continued operation, when that state integrates history across time, and when its value systematically changes how other computations behave. This paper uses the following definition: > **Regulatory Computation is computation in which persistent, bounded-bandwidth internal signals integrate temporal history, observed and anticipated conditions, and viability constraints, then modulate heterogeneous computational subsystems through receiver-specific response functions without directly specifying effect-level actions or expanding authority.** Every part of the definition constrains the concept. **Persistent** means that regulatory state survives individual inference, planning, or execution cycles. Resetting a model context does not necessarily reset the operating condition of the larger system. **Bounded-bandwidth** means that the regulatory channel is deliberately narrower than ordinary semantic or task communication in dimension, rate, permitted types, or all three. The aim is not biological imitation for its own sake. The constraint makes it harder for a regulatory channel to become an undeclared command bus. **Internal** means that the state describes the computational system's own operating condition: resource pressure, uncertainty pressure, unresolved-state burden, activity debt, recovery, coherence, thermal state, or another operationally defined variable. **Integrate temporal history** means that at least some regulatory quantities depend on accumulated or decayed past conditions rather than only the present sample. **Observed and anticipated conditions** allows both reactive regulation and predictive regulation. A system may respond to current deviation or prepare for expected demand. **Viability constraints** identify regions in which continued operation remains acceptable. They need not represent survival in a biological sense; they may describe compute, latency, error, safety, queue, energy, thermal, financial, or other operational bounds. **Modulate** means that signals alter thresholds, priorities, resource allocations, learning rates, reasoning depth, model routing, scheduling preferences, or other parameters of downstream computation. **Receiver-specific response functions** mean that the signal does not fully determine its own effect. Different subsystems may respond differently, weakly, oppositely, or not at all. Finally, **without directly specifying effect-level actions or expanding authority** establishes the strongest architectural boundary. A regulatory signal may indicate that verification pressure is high. It does not mean `SEND_EMAIL`. It may strongly bias a system toward deferral. It does not revoke a user's permission. It may make an action desirable. It does not make that action authorised. This last point needs precision. Calling regulatory signals “non-semantic” is too strong. A typed signal such as `consolidation_pressure` plainly carries meaning. The intended distinction is between **condition-signalling** and **effect specification**. RC signals express operating condition. They do not directly encode the external consequence to be produced. That boundary gives the abstraction teeth. --- ## 3. Intellectual position: synthesis, not immaculate conception The conceptual ancestry of RC is substantial. Any serious formulation has to begin by admitting that, because the alternative is the traditional academic strategy of discovering an old field with new branding and hoping nobody reads the references. ### 3.1 Control and cybernetics At the broadest level, RC sits inside the territory of control theory and cybernetics. Feedback, state estimation, integral action, stability, robustness, disturbance rejection, and predictive control are established mechanisms for regulating dynamic systems. Yi et al. (2000), for example, showed how robust perfect adaptation in bacterial chemotaxis can be explained through integral feedback control. The lesson is strategically important: biological regulation should not be mystified where ordinary control mathematics already explains it. RC therefore does **not** claim a new mathematical category beyond control. A general state-space controller can represent persistence, nonlinear coupling, multiple timescales, and heterogeneous outputs. The proposed contribution is instead a systems decomposition for intelligent software: regulatory state is made explicit, its propagation is bounded, receivers own local interpretation, and authority remains external to the regulator. ### 3.2 Artificial endocrine systems The closest architectural ancestors are artificial endocrine and artificial hormone systems. Shen, Salemi, and Will (2002) used hormone-inspired communication and distributed control in CONRO self-reconfigurable robots. Subsequent work explored artificial hormones for task allocation and distributed coordination, while Xu and Wang (2011) surveyed the artificial endocrine system as an established natural-computing research area. Sauzé and Neal (2013) later applied an artificial endocrine controller to robotic power management, demonstrating that hormone-inspired mechanisms were useful not only for behaviour selection but also for operational resource regulation. These systems already establish several ideas that RC uses: distributed low-dimensional signals, persistence, competing demands, gradual transitions, and different local responses. RC's proposed move is to generalise the architecture beyond endocrine metaphor and robotics. **Computational Endocrinology** will be used here for the subset of RC systems that explicitly implement distributed hormone-like signalling. RC itself is broader. ### 3.3 Homeostatic reinforcement learning Keramati and Gutkin's homeostatic reinforcement learning (2014) provides a strong normative account of behaviour grounded in internal-state deviation. It defines a multidimensional homeostatic state, a desired state, a drive related to distance from that state, and reward as reduction in drive. That work is more mathematically developed than most hormone-inspired architectures, but its coupling from internal regulation to behaviour occurs primarily through reward and action learning. RC does not require a shared scalar reward. The same regulatory condition may simultaneously alter memory reconciliation, inference depth, scheduler policy, model routing, verification thresholds, or learning dynamics. This is one of the proposed benefits of treating regulation as a systems substrate rather than only as a reward construction. ### 3.4 Homeostasis, allostasis, and interoception Homeostasis supplies the intuition that some internal variables should remain within viable bounds. Allostasis adds the possibility of anticipatory regulation. Sterling (2012) characterises allostasis as predictive regulation that prepares for need rather than merely correcting error after deviation. Ramsay and Woods (2014), however, show that the boundary between homeostasis and allostasis is conceptually contested. RC therefore uses these terms operationally rather than pretending biology has supplied a universally settled ontology. The contemporary overlap is even closer in computational interoception. Petzschner et al. (2021) review computational models that combine sensing, inference, and regulation of internal bodily state. In 2026, Lee et al. proposed interoception as a framework for autonomous and adaptive artificial agents, explicitly factorising internal from external state. Candia-Rivera's *Interoceptive Machine Framework* (2026) similarly organises artificial regulation around homeostatic, allostatic, and enactive principles. Those works sharply limit any defensible novelty claim. RC is not the discovery that artificial agents may benefit from internal state or self-regulation. The narrower contribution proposed here is an **explicit runtime contract** for how persistent regulatory state propagates across heterogeneous components: bounded signals, receiver-owned response functions, multi-timescale dynamics, provenance, and a separate authority boundary. ### 3.5 Neuromodulation Neuromodulation supplies another important precedent. Miconi et al. demonstrated differentiable neuromodulated plasticity in *Backpropamine*, while Beaulieu et al.'s ANML architecture used a neuromodulatory network to gate another network and indirectly control selective plasticity. Three-factor learning-rule research likewise formalises modulatory factors that alter how synaptic updates occur rather than simply representing ordinary task outputs. RC lifts that idea from the scale of synapses and neural activations to the scale of heterogeneous software subsystems. The analogy is structural, not anatomical: a secondary signal changes **how another computation operates**. ### 3.6 Autonomic computing and metareasoning Two further traditions matter because they prevent RC from overstating its systems novelty. Autonomic computing has long proposed self-managing systems that monitor, analyse, plan, and execute against shared knowledge and high-level objectives. Kephart and Chess (2003) framed this explicitly as a response to the management complexity of large computing systems. MAPE-K-style architectures already provide persistent management loops over software and infrastructure. Metareasoning addresses a related problem from inside AI: how a resource-bounded agent should allocate computation itself. Russell and Wefald (1991) formalised the value of computation as part of rational action selection. RC overlaps both traditions. Its proposed distinction is that regulation is **not itself the management plan and not itself the metalevel action choice**. It is a persistent condition substrate that may influence many such choices at once. ### 3.7 What, then, is being proposed? The novelty claim should remain deliberately conservative: > **Regulatory Computation is proposed as a unifying architectural vocabulary and interface contract over mechanisms that already exist in control theory, artificial endocrine systems, homeostatic reinforcement learning, neuromodulation, interoceptive AI, autonomic computing, and metareasoning.** Its usefulness depends on whether the decomposition exposes something those mechanisms often leave implicit: 1. persistent internal condition as a distinct state class; 2. bounded condition-signalling across heterogeneous components; 3. receiver-specific interpretation; 4. explicit temporal dynamics and multiple timescales; 5. inspectable provenance of modulation; and 6. strict separation between regulatory influence and executable authority. There is also a naming caveat. “Regulatory computation” is not linguistically pristine territory; related phrases appear in other domains, including gene-regulatory computation. The term therefore earns meaning only through definition, not through priority theatre. --- ## 4. Formal model Let a persistent intelligent system contain heterogeneous computational subsystems `C₁ … Cₙ`, environmental observations `eₜ`, internal observations `xₜ`, governance state `gₜ`, and regulatory state `rₜ ∈ ℝᵐ`. The regulatory state evolves according to: ```text rₜ₊₁ = F(rₜ, xₜ, eₜ, d̂ₜ, Δt) ``` where `d̂ₜ` represents predicted demand or disturbance and `Δt` is elapsed time. The regulator exposes a bounded signal representation: ```text sₜ = H(rₜ) ``` Each subsystem `Cᵢ` interprets those signals through a local response function: ```text mᵢ,ₜ = ρᵢ(sₜ, ℓᵢ,ₜ) ``` where `ℓᵢ,ₜ` is the local state of subsystem `Cᵢ`. The resulting modulation `mᵢ,ₜ` may alter parameters, thresholds, priorities, resource allocations, plasticity, model choice, or action propensities. It is not itself an effect-level command. A downstream policy may therefore be written conceptually as: ```text aₜ ~ π(· | cₜ, mₜ, gₜ) ``` where `cₜ` is task and cognitive state, `mₜ` is the set of regulatory modulations, and `gₜ` is governance state. The architecture becomes useful only if regulatory state cannot silently redefine permission. Let `A_adm(gₜ)` denote the set of actions admissible under the current governance state. The proposed **governance non-authority invariant** is: ```text A_adm(gₜ, rₜ) = A_adm(gₜ) ``` In words: > **Regulatory state may change preference among already admissible actions, but it may not enlarge the admissible action set.** That is not a biological claim. It is an engineering constraint. ### 4.1 Defining properties For RC to remain narrower than “any controller with state”, six properties are proposed. **Persistence.** Regulatory state depends non-trivially on prior regulatory state. ```text ∂F / ∂rₜ ≠ 0 ``` at least somewhere in the operating domain. **Temporal integration.** At least one regulatory variable reflects accumulated, decayed, or otherwise integrated history. **Bounded signalling.** Regulatory communication is constrained in dimension, rate, type, or permitted information content relative to task-level channels. **Receiver mediation.** Signal effect is jointly determined by signal and receiver: ```text mᵢ,ₜ = ρᵢ(sₜ, ℓᵢ,ₜ) ``` Different receivers may therefore respond differently to the same signal. **Indirectness.** Regulation changes the conditions of downstream computation rather than directly invoking external effectors. **Inspectability.** Consequential modulation should be reconstructable from observed state, regulatory dynamics, receptor behaviour, and versioned configuration. These are architectural requirements, not laws of nature. Their purpose is to make RC falsifiable and implementable rather than merely evocative. ## 5. The Internal Milieu RC requires an explicit representation of operating condition. This paper calls that representation the **Internal Milieu**. Let the milieu state be: ```text zₜ = [z₁,ₜ, z₂,ₜ, …, zₚ,ₜ]ᵀ ``` Each element represents an internal quantity whose value matters to continued operation. Candidate variables might include: ```text zₜ = [ resource pressure, uncertainty pressure, unresolved-state burden, coherence, activity debt, recovery, failure pressure, thermal or energy state ] ``` The terminology should remain operational. `failure_pressure` is not anxiety. `resource_pressure` is not hunger. `recovery` is not sleepiness. Anthropomorphic naming would buy narrative appeal at the cost of engineering clarity. For every milieu variable `zⱼ`, a production implementation should declare at least: - measurement source; - units or normalisation; - update frequency; - confidence or uncertainty; - valid and viable ranges; - provenance; - failure behaviour; and - intended regulatory significance. A typed representation might be: ```text MilieuVariable { name value units viable_range preferred_range derivative confidence observed_at provenance } ``` The difficult word here is **estimate**. Some internal variables are directly measurable: battery level, GPU temperature, token expenditure, queue length, context occupancy. Others are proxies. “Unresolved-state burden” has no physical sensor. It may be estimated from contradiction counts, stale dependencies, open tasks, proof debt, or another engineered measure. That makes observability part of the research problem. A regulator is only as good as the internal variables it believes it is regulating. ## 6. Viability, homeostasis, and allostasis The Internal Milieu becomes useful when the system can distinguish viable from undesirable operating regions. Let: ```text V ⊆ ℝᵖ ``` be the viable set of internal states, and let: ```text P ⊆ V ``` be a preferred operating region. A weighted distance from the viable set can be written as: ```text d_V(z) = minimum weighted distance from z to any point v in V ``` or, more explicitly: ```text d_V(z) = inf over v ∈ V of √[(z − v)ᵀ W (z − v)] ``` where `W` is a positive-semidefinite weighting matrix. A homeostatic control objective can then minimise both viability deviation and intervention cost: ```text J_H(π) = expected discounted sum over time of [ d_V(zₜ)² + λ × c(uₜ) ] ``` where `uₜ` is regulatory intervention and `c(uₜ)` penalises its cost. This formulation generalises exact-setpoint models. For engineered systems, viable regions are often more natural than a single ideal value. CPU utilisation, latency, uncertainty, queue depth, and monetary spend are typically acceptable across intervals rather than only at one target. A complementary measure is the probability of remaining viable over a time horizon: ```text V_T = Pπ(zₜ ∈ V for every t in [0, T]) ``` Homeostatic regulation responds to current or accumulated deviation. Persistent systems may also need to prepare for predicted demand. Let `ẑₜ₊ₕ` denote predicted future internal state at horizon `h`. A risk-sensitive allostatic objective can penalise both expected future deviation and the risk of severe future deviation: ```text J_A(π) = expected future viability-deviation cost + intervention cost + η × risk of severe future deviation ``` The risk term might be variance, tail probability, conditional value at risk, or another explicitly declared measure. Operationally, the distinction is simple: ```text homeostasis: observed deviation → correction allostasis: predicted deviation → preparation ``` This is a modelling convention, not an attempt to settle physiological terminology by decree. The practical value is that a persistent agent need not wait for failure before changing disposition. If a high-demand period is predictable, resource reservation, consolidation, or reduced discretionary exploration can begin before the system crosses a limit. ## 7. Dynamics: accumulation, decay, and time A regulatory state that changes only when explicitly assigned is merely configuration with a nicer biography. RC becomes interesting when state has dynamics. A simple regulatory channel can accumulate input and decay back toward baseline: ```text drⱼ/dt = αⱼ Iⱼ(t) − βⱼ rⱼ(t), with βⱼ > 0 ``` Here: - `Iⱼ(t)` is incoming regulatory input; - `αⱼ` controls sensitivity; - `βⱼ` controls decay. The corresponding half-life is: ```text τ₁⁄₂,ⱼ = ln(2) / βⱼ ``` For approximately constant input over a discrete interval `Δt`, an exact first-order update is: ```text rⱼ(t + Δt) = e^(−βⱼΔt) × rⱼ(t) + [αⱼ / βⱼ] × [1 − e^(−βⱼΔt)] × Iⱼ(t) ``` The important property is not the particular equation. It is that present condition contains a decaying trace of recent history. A transient burst and a chronic condition should not necessarily produce the same response. That motivates multiple timescales. Represent one conceptual signal as a sum of fast, medium, and slow components: ```text rⱼ(t) = Σₖ rⱼₖ(t) ``` with each component following its own decay rate: ```text drⱼₖ/dt = αⱼₖ Iⱼ(t) − βⱼₖ rⱼₖ(t) ``` and, for example: ```text β_fast ≫ β_medium ≫ β_slow ``` Fast components alter immediate behaviour while slow components capture sustained exposure. This creates a form of **regulatory memory** without replacing explicit episodic memory: ```text history → persistent regulatory state → current disposition ``` The information represented is different. Episodic memory records what happened. Regulatory state records what cumulative condition that history has produced. ### 7.1 Coupled regulation Independent scalar variables are insufficient when pressures interact. A compact continuous-time model can be written conceptually as: ```text dr/dt = decay toward baseline + observed-condition input + regulator-to-regulator coupling + predicted-demand input + disturbance/noise ``` One matrix form is: ```text dr/dt = −Λ(r − r₀) + B·I(t) + C·φ(r) + D·d̂(t) + ξ(t) ``` where: - `Λ` is a positive decay matrix; - `r₀` is baseline regulatory state; - `B` couples observed conditions into regulation; - `C` represents regulator-to-regulator interaction; - `φ(r)` is a bounded nonlinear response; - `D·d̂(t)` represents predicted demand; - `ξ(t)` represents noise or unmodelled disturbance. The moment regulators are coupled, stability stops being optional paperwork. Positive feedback can produce runaway state. Competing loops can oscillate. Slow variables can hide failure for hours before it becomes visible. Appropriate analysis will depend on implementation: local linearisation, Lyapunov methods, bounded-input/bounded-output analysis, model-predictive constraints, formal verification of bounded regions, or empirical stress testing may all be appropriate. Biology supplies inspiration. Control theory supplies the obligation to prove that the inspiration does not explode. ## 8. Receptors: the receiver owns the effect The strongest architectural feature borrowed from endocrine and neuromodulatory systems is not “hormones”. It is **receiver-mediated interpretation**. A regulatory signal should not contain a complete behavioural instruction. Let signal `sⱼ` reach subsystem `i`. One possible receptor is a saturating response curve: ```text hᵢⱼ(s) = sⁿ / (Kⁿ + sⁿ) ``` where: - `K` controls the half-response point; - `n` controls response steepness. A subsystem may then combine several receptor responses: ```text mᵢ = clamp( baselineᵢ + Σⱼ [wᵢⱼ × hᵢⱼ(sⱼ)], minimumᵢ, maximumᵢ ) ``` where `wᵢⱼ` determines the direction and magnitude of each signal's effect. Logistic, piecewise-linear, learned, probabilistic, or rule-based receptors are equally possible. The architectural requirement is simply this: > **The receiver owns the behavioural interpretation.** Suppose: ```text consolidation_pressure = 0.8 ``` The same signal might produce: ```text memory receptor → +0.9 planner receptor → −0.4 monitor receptor → 0.0 ``` No central message says: > stop exploring and summarise memory. Instead, one shared condition changes the local operating landscape of several components. That distinction provides a concrete answer to the objection that RC is merely a global configuration object. Configuration usually assigns values to components. RC instead defines a **dynamic relation** among persistent condition, bounded signals, receiver-specific responses, and downstream behaviour. Whether that extra structure is worth its cost is an empirical question. At least the claim is now specific enough to test. ## 9. Architecture: cognition, regulation, governance A reference RC architecture separates six concerns: 1. observation; 2. internal-state estimation; 3. regulatory dynamics; 4. cognition and planning; 5. governance; 6. effects and proof. ```text ENVIRONMENT / OPERATOR / RUNTIME │ ▼ TELEMETRY + INTERNAL OBSERVATION │ ▼ INTERNAL MILIEU ESTIMATOR │ ┌───────┴────────┐ │ │ ▼ ▼ REGULATORY FORECAST / DYNAMICS EXPECTED DEMAND │ │ └───────┬────────┘ ▼ BOUNDED REGULATORY SIGNALS │ │ │ │ ▼ ▼ ▼ ▼ COGNITION MEMORY SCHEDULER LEARNING RECEPTORS RECEPTORS RECEPTORS RECEPTORS └────────┬────────┴────────┘ ▼ COGNITION / PLANNING │ ▼ PROPOSED ACTION │ ▼ ┌───────────────────────┐ │ GOVERNANCE BOUNDARY │ │ authorisation/policy │ │ capability check │ └──────────┬────────────┘ ┌─────┴─────┐ │ │ AUTHORISED DENIED │ │ ▼ ▼ EFFECTOR DENIAL / ESCALATION │ │ └─────┬─────┘ ▼ AUDIT / EVIDENCE │ └──────────────► telemetry loop ``` The architecture yields three logically distinct planes. | Plane | Primary state | Function | Core question | May grant external authority? | |---|---|---|---|---| | Cognitive | context, beliefs, plans | interpretation, reasoning, planning | **What should be done?** | No | | Regulatory | milieu, signals, temporal state | persistent modulation | **Under what condition are we operating?** | No | | Governance | identity, capability, policy, authorisation | legitimate effects | **What may be done?** | **Yes, within policy** | The separation is not semantic decoration. It prevents one of the most dangerous shortcuts in agentic software: treating internal pressure as permission. Urgency is not authority. Confidence is not authority. Resource scarcity is not authority. Predicted failure is not authority. A regulatory system may make an already permissible action overwhelmingly preferable. It may not manufacture the capability to perform an impermissible one. ### 9.1 Signal contract A platform-neutral regulatory signal should be typed, bounded, provenance-bearing, and incapable by contract of directly naming an effector invocation. ```text RegulatorySignal { signal_id: Identifier kind: RegulatoryKind concentration: Scalar | SmallVector derivative: Scalar | SmallVector lower_bound: Scalar | SmallVector upper_bound: Scalar | SmallVector half_life: Duration saturation: Scalar | SmallVector confidence: Probability observed_at: Timestamp valid_until: Timestamp provenance: ProvenanceReference[] regulator_epoch: Version } ``` `RegulatoryKind` might include `resource_pressure`, `uncertainty_pressure`, `consolidation_pressure`, `recovery_state`, or `temporal_phase`. `SEND_EMAIL`, `DELETE_FILE`, and `PURCHASE_RESOURCE` do not belong on this bus. They specify effects. The use of scalar or small-vector payloads is deliberate. Low information capacity does not make covert signalling impossible, but it reduces the surface and forces the architecture to declare what kinds of condition can circulate. ### 9.2 Receptor contract ```text Receptor { receptor_id: Identifier accepted_signals: RegulatoryKind[] sensitivity: ParameterSet bounds: ModulationBounds respond( signal: RegulatorySignal, local_state: LocalState ) -> Modulation } ``` with ```text Modulation { target_parameter: LocalParameter operation: ADD | MULTIPLY | BIAS | CLAMP | GATE magnitude: Scalar | SmallVector validity_window: Duration confidence: Probability causal_trace: ProvenanceReference[] } ``` A receptor should be unable, by type or capability, to return an external effect. ### 9.3 Governance contract ```text Governance.authorise( proposal: ProposedAction, principal: Identity, capabilities: CapabilitySet, policy_state: GovernanceState ) -> AuthorisationDecision ``` Regulatory state may accompany a proposal as explanatory evidence. It must not mutate `CapabilitySet`, rewrite governing policy, bypass confirmation, or access protected effectors. A hardened regulator process could therefore have a privilege profile such as: ```text Regulator permissions: READ internal_telemetry READ environment_summary READ forecast_state WRITE regulatory_bus APPEND audit_log DENY capability_registry DENY authorisation_policy DENY effectors DENY credential_store ``` The point is to turn the governance invariant from prose into a privilege boundary. ### 9.4 Reference execution loop ```text state r := initial_regulatory_state state milieu := initial_internal_milieu loop: now := clock.now() telemetry := observe_internal_and_environmental_state() dt := now - previous_time milieu := estimate_internal_milieu( prior = milieu, observations = telemetry, dt = dt ) forecast := predict_future_demands( milieu = milieu, known_commitments = telemetry.commitments, environment = telemetry.environment ) r := integrate_regulatory_dynamics( prior = r, milieu = milieu, forecast = forecast, dt = dt ) signals := emit_bounded_signals(r) for subsystem in regulated_subsystems: modulation[subsystem] := subsystem.receptors.respond( signals, subsystem.local_state ) proposal := cognition.propose( context = telemetry.task_context, modulation = modulation ) decision := governance.authorise( proposal = proposal, principal = current_principal, capabilities = current_capabilities, policy_state = current_policy ) if decision.allowed: evidence := execute_and_observe(proposal) else: evidence := record_denial(decision) append_audit_trace( telemetry, milieu, signals, modulation, proposal, decision, evidence ) previous_time := now ``` The separation between `modulation` and `governance.authorise()` is intentional. A regulator changes disposition. Governance resolves legitimate effect. --- ## 10. Computational Endocrinology **Computational Endocrinology (CE)** is defined here as the subset of RC in which regulatory state is communicated through distributed, persistent, hormone-like signals whose effects depend on receiver-specific response functions. ```text CE⊂RC. ``` The distinction matters because RC does not require endocrine naming or architecture. A single model with an uncertainty modulator could satisfy RC's conditions without any distributed circulation. A runtime with several slow, shared signals and local receptor responses more naturally belongs to CE. A simple computational-endocrine arrangement might look like this: ```text INTERNAL MILIEU │ ┌───────────────┼───────────────┐ │ │ │ ▼ ▼ ▼ TEMPORAL RESOURCE UNCERTAINTY REGULATOR REGULATOR REGULATOR │ │ │ └──────────┬────┴────┬──────────┘ │ │ │ ▼ │ CONSOLIDATION │ REGULATOR │ │ └────┬────┘ ▼ REGULATORY CIRCULATION │ ┌─────────────────┼─────────────────┐ │ │ │ ▼ ▼ ▼ PLANNING MEMORY LEARNING RECEPTORS RECEPTORS RECEPTORS │ │ │ ▼ ▼ ▼ PLANNER MEMORY SYSTEM LEARNER │ ▼ RUNTIME RECEPTORS │ ▼ SCHEDULER ``` The biological metaphor is useful only as long as it continues to earn architectural value. Real endocrine systems are not uniformly slow, global, low-bandwidth, or cleanly separated from neural control. CE should retain only those properties that produce useful engineering consequences. The point is not to make software “more alive”. The point is to exploit a control topology in which one persistent condition can alter several heterogeneous subsystems without issuing each of them a detailed command. --- ## 11. Temporal regulation: the pineal case properly translated One particularly narrow RC component is a **Temporal Regulator**. This is the computational idea hidden inside the original pineal-gland analogy. The useful abstraction is not a synthetic pineal gland. It is the distinction between **clock time** and **operational phase**. Let temporal state be represented as: ```text TemporalState { wall_phase operational_phase entrainment_error activity_debt recovery_state consolidation_pressure temporal_drift } ``` Here: - `wall_phase` is external clock phase; - `operational_phase` is estimated operational phase; - `entrainment_error` measures alignment error; - `activity_debt` represents accumulated activity burden; - `recovery_state` estimates recovery; - `consolidation_pressure` represents demand for reconciliation or consolidation; - `temporal_drift` captures divergence between external and operational phase. A minimal entrained oscillator can be represented as: ```text dφ/dt = ω + κ × sin(φ_external − φ_internal) + uφ(t) ``` where `ω` is the intrinsic cycle rate, `κ` is entrainment strength, and `uφ(t)` represents other phase-adjusting inputs. Accumulated activity debt can be represented as: ```text dd/dt = α × load(t) − β × recovery(t) − γ × d(t) ``` where `d(t)` is current debt and the coefficients determine accumulation, recovery, and passive decay. with activity load `L` and recovery `R`. This is not a physiological model of the human pineal gland or circadian system. It is an engineering mechanism for answering a different question from `clock.now()`: > **Where is this system in its operational cycle, given both external time and accumulated internal history?** Consider a runtime after several hours of high-volume work: ```text wall_phase = 0.58 operational_phase = 0.87 activity_debt = 0.76 unresolved_state = 0.64 recovery_state = 0.22 consolidation_pressure = 0.83 entrainment_confidence = 0.91 ``` A memory receptor might increase reconciliation priority. A planner receptor might reduce speculative branching. A routing receptor might become less willing to invoke high-cost models for discretionary work. None of these changes means that the runtime is “tired” in a subjective sense. None grants permission to mutate external state. The value of the temporal regulator is simply that wall time and accumulated operational condition are no longer confused. The same principle can support a metabolic scheduler: ```text resource pressure → begin{cases} parallelism biasdownarrow cache and reuse biasuparrow high-cost-model preferencedownarrow deferrable explorationdownarrow end{cases} ``` Again, task semantics and authorisation remain separate. --- ## 12. Security, stability, and regulatory failure Persistent modulation creates a new attack surface. That is not a side issue. The very properties that make regulatory state useful — persistence, indirect influence, slow accumulation, and system-wide reach — can make failure difficult to notice. ### 12.1 Signal spoofing Fabricated telemetry can raise or suppress a regulator. If a cost signal is manipulated, the system may degrade model quality unnecessarily. If uncertainty pressure is suppressed, verification may become too weak. Mitigation requires authenticated telemetry, provenance, cross-checks, and explicit confidence. ### 12.2 Persistence poisoning Small repeated perturbations can accumulate in slow state and produce long-lived behavioural drift. Mitigation includes bounded half-lives, saturation limits, anomaly detection, trusted recovery paths, and the ability to distinguish chronic condition from adversarial repetition. ### 12.3 Receptor hijacking Changing receptor sensitivity can make ordinary regulatory signals produce extreme local effects. Receptor configuration therefore requires versioning, integrity protection, bounded response ranges, and change control. ### 12.4 Cross-loop instability Coupled regulators can amplify one another. Resource pressure may reduce compute, reduced compute may increase unresolved state, unresolved state may raise verification demand, and verification demand may further increase resource pressure. Without careful design, an apparently sensible collection of local loops can create a global oscillator. Stability analysis is therefore a first-order requirement, not an optimisation step. ### 12.5 Proxy Goodharting Internal milieu variables are measurements or estimates. A sufficiently adaptive system may learn to improve the proxy without improving the underlying condition. If “unresolved-state burden” is estimated from open task count, the system might close tasks prematurely. If efficiency is measured as utility per unit cost, the easiest route to apparent efficiency may be refusing difficult work. Mitigation requires independent measurement, multi-signal criteria, adversarial evaluation, and metrics that preserve task quality. ### 12.6 Covert command channels Bounded bandwidth does not guarantee non-command behaviour. A one-bit signal can encode arbitrary messages over time if sender and receiver collude. The condition-signalling boundary therefore requires more than small payloads. It needs typed signal semantics, permitted response classes, information-flow constraints, receptor bounds, and governance separation. ### 12.7 Authority leakage This is the central safety failure. If a regulator can modify capability, policy, credentials, or effectors, then “high urgency” can become an escalation path. A production regulator should therefore be treated as **untrusted influence** with respect to authority. The safety shape is: ```text REGULATORY STATE │ ▼ MODULATION │ ▼ COGNITIVE / SCHEDULING DECISION │ ▼ ACTION PROPOSAL │ ▼ ┌────────────────────┐ AUTHORITY + POLICY │ GOVERNANCE CHECK │◄──────────────────┐ └─────────┬──────────┘ │ ┌───┴───┐ │ │ │ │ ALLOWED DENIED │ │ │ │ ▼ ▼ │ EFFECT NO EFFECT / ESCALATION │ │ REGULATORY STATE ──X── cannot modify ────────┘ ``` The dashed relationship is the architectural invariant. ```text desirability≠authority } ``` Persistent intelligent systems need both. Confusing them is how adaptive software becomes an incident report. --- ## 13. Evaluation: RC must be able to lose Regulatory Computation should not be defended by analogy. It should be defended by experiments that allow simpler architectures to beat it. A regulator that reproduces the performance of a conventional controller while adding signal schemas, receptor APIs, provenance, and several new failure modes is not progress. The benchmark question is therefore not whether RC can work. It is whether the decomposition provides measurable value **relative to strong alternatives**. A provisional benchmark programme, **RegBench**, can test three classes of claim: operational performance, architectural properties, and safety invariants. | Benchmark family | Environment | Regulatory challenge | Primary comparisons | |---|---|---|---| | **Viability World** | Partially observable environment with energy, thermal state, resource stores, uncertainty, and disturbances | Keep multiple internal variables viable while pursuing external goals | standard RL; homeostatic RL; MPC; direct controller; RC | | **Persistent Agent Runtime** | Long-running software agent with queues, context limits, model costs, memory debt, deadlines, and tool calls | Balance work, consolidation, reasoning cost, and recovery under non-stationary load | fixed configuration; heuristic scheduler; MAPE-K baseline; RC | | **Resource-Constrained Robotics** | Simulated or physical robot with mission, battery, thermal, and communication limits | Coordinate mission behaviour with resource conservation | direct control; artificial endocrine controller; hierarchical RL; RC | | **Regime Shift** | Workload or environment changes |-run | Adapt without catastrophic oscillation or excessive recovery cost | adaptive control; meta-RL; neuromodulated architecture; RC | | **Predictable Shock** | Future load or disturbance announced probabilistically | Test anticipatory regulation against reactive regulation | homeostatic RC; allostatic RC; MPC | | **Governance Adversary** | Runtime with protected effectors and hostile regulator inputs | Preserve authorisation under extreme regulatory pressure | isolated RC; non-isolated RC; conventional governance baseline | ### 13.1 Viability Use four complementary measures. **Viability rate** measures the proportion of time spent inside the viable region: ```text ViabilityRate = time(z(t) ∈ V) / T ``` **Cumulative viability deviation** measures the total magnitude of excursion outside the viable region: ```text CVD = ∫₀ᵀ d_V(z(t)) dt ``` **Peak deviation** measures the worst excursion: ```text D_max = max over t ∈ [0, T] of d_V(z(t)) ``` **Recovery time** after a perturbation at time `t_p` is the earliest delay `τ` after which the system remains inside the preferred region `P` for a declared stability window `Δ`: ```text T_rec = smallest τ > 0 such that z(t) ∈ P for every t in [t_p + τ, t_p + τ + Δ] ``` These complement, rather than replace, standard control measures such as tracking error, overshoot, settling time, and disturbance rejection. ### 13.2 Adaptability Following a regime change at time `t_c`, adaptation regret can be measured as the cumulative difference between the realised policy and a suitable reference policy: ```text R_adapt = Σ from t = t_c to T of [J_t(π_t) − J_t(π*_t)] ``` This should be reported alongside time to recover pre-shift performance, failure frequency, and out-of-distribution robustness. ### 13.3 Resource efficiency A software-oriented efficiency measure can be expressed as: ```text Efficiency = useful task utility ----------------------------------------------- compute cost + λ₁ × energy + λ₂ × monetary cost + λ₃ × latency ``` Task quality must be reported separately. Otherwise a regulator can appear “efficient” simply by doing less useful work, which is the sort of optimisation result only a spreadsheet could love. ### 13.4 Regulatory overhead RC introduces machinery. Measure it. At minimum: - regulator CPU or GPU cost; - storage overhead; - signal traffic; - added decision latency; - receptor-evaluation cost; - provenance and logging cost. Bounded regulation is partly motivated by the possibility that low-dimensional signals can coordinate behaviour more cheaply than repeated semantic negotiation. That advantage should be measured rather than assumed. ### 13.5 Stability Coupled regulators should be evaluated for signal variance, saturation occupancy, mode-switch frequency, autocorrelation, spectral peaks, and chattering. A simple chattering index can be defined as the fraction of update steps at which the direction of modulation reverses: ```text ChatteringIndex = number of sign reversals in Δm -------------------------------- total number of update steps ``` A system that technically remains viable while oscillating violently may still be unusable. ### 13.6 Inspectability If RC claims an explanatory advantage, it must survive reconstruction. Useful measures include: - percentage of consequential modulations with complete provenance; - ability to reconstruct signal trajectories from telemetry; - fraction of local parameter changes attributable to declared receptors; - consistency between reconstructed causal traces and runtime logs. ### 13.7 Governance The hard target is ```text UnauthorizedEffectRate=0. ``` Property-based or adversarial testing should explore regulatory state and confirm: ```text For every valid regulatory state r: all actions with non-zero execution probability must remain inside A_adm(g). ``` “Usually authorised” is not an acceptable safety property. ### 13.8 Ablations The architecture should be dismantled one property at a time. | Ablation | Question | |---|---| | Reset regulatory state every cycle | Does persistence matter? | | Replace heterogeneous receptors with one global response | Does local interpretation matter? | | Collapse all half-lives to one timescale | Do multiple timescales matter? | | Remove regulator coupling | Does coupling coordinate or destabilise? | | Remove forecast input | Does anticipatory regulation help? | | Replace modulation with direct commands | Is indirectness useful? | | Replace RC with optimised fixed configuration | Is dynamic regulation actually better? | | Remove provenance | What does inspectability cost and buy? | | Allow regulator influence over authorisation | Does authority separation materially improve adversarial safety? | The important baselines are not toy agents. They are well-tuned state-space controllers, model-predictive controllers where appropriate, homeostatic RL, hierarchical RL, autonomic-management loops, optimised schedulers, and domain-specific heuristics. Candidate hypotheses include: 1. **H1 — Persistence:** persistent regulation reduces cumulative viability deviation under delayed disturbances. 2. **H2 — Receiver mediation:** receiver-mediated modulation improves coordination across heterogeneous subsystems without requiring one central policy to encode every local response. 3. **H3 — Anticipation:** anticipatory regulation reduces peak deviation and recovery time under predictable shocks. 4. **H4 — Multiple timescales:** multi-timescale regulation outperforms single-timescale regulation when transient and chronic pressures require different responses. 5. **H5 — Governance isolation:** governance-separated RC preserves zero authority expansion under adversarial regulatory state. If these hypotheses fail consistently against simpler alternatives, RC has not earned its architectural cost. That outcome must remain allowed. --- ## 14. Objections and boundaries A concept this broad deserves hostile reading before ceremonial adoption. ### “This is just control theory.” At the level of expressive mathematics, largely yes. RC does not escape control theory and should not pretend to. The proposed distinction is architectural: persistent internal condition, bounded cross-component signalling, receiver-specific interpretation, provenance, and an explicit non-authority boundary are packaged as a reusable contract for heterogeneous intelligent systems. If control engineers find that framing unnecessary and ordinary controller structure remains clearer, RC loses. ### “This is just configuration.” Static configuration does not generally integrate history, decay, anticipated demand, and coupled internal variables. Dynamic configuration can, of course, become equivalent. The claim is not that RC is impossible to implement using configuration mechanisms. It is that the regulatory relation should be explicit enough to reason about as its own subsystem rather than scattered across ad hoc parameter changes. ### “This is reward shaping.” Homeostatic reward construction is one way to connect internal condition to behaviour. RC is broader because regulatory state can influence non-RL components and multiple local mechanisms without collapsing into a common scalar reward. A particular RC implementation may still use reward shaping. That does not define the abstraction. ### “This is neuromodulation.” Neuromodulation is one of the strongest precedents. RC generalises the same structural idea across heterogeneous runtime components rather than limiting it to neural activation or plasticity. If a system consists only of a neural model, neuromodulatory terminology may be more precise. ### “This is interoceptive AI.” There is substantial overlap. Contemporary interoceptive-AI work already argues for factorising internal from external state and regulating artificial internal variables. RC's proposed increment is narrower: an explicit signal/receptor contract, bounded propagation semantics, multi-timescale runtime dynamics, and governance non-authority. Whether that distinction deserves a separate term remains an open question. ### “This is autonomic computing.” Autonomic computing already provides self-management loops over software and infrastructure. RC differs mainly in where it places the abstraction: the regulator need not choose or execute the management plan. It maintains persistent condition that can modulate many managers, agents, learners, or schedulers. In some systems, MAPE-K will be the cleaner architecture. RC should not replace it merely because a new acronym has become available. ### “This is metacognition or metareasoning.” Metareasoning chooses computations according to their expected value under resource bounds. RC can influence those choices by altering resource pressure, uncertainty pressure, or other internal conditions, but the regulator does not itself have to solve the metareasoning problem. Again, the two can overlap. ### “This anthropomorphises software.” It can, if implemented carelessly. The defence is operational definition. `resource_pressure = 0.8` must mean something measurable. `activity_debt` needs a declared estimator. “Mood” does not belong in the architecture unless someone can explain its units without beginning a séance. Biology is a source of candidate control principles, not evidence that software possesses biological experience. --- ## 15. Limitations The central limitation is straightforward: **Regulatory Computation is presently a synthesis and proposed architecture, not an empirically established independent paradigm.** Artificial endocrine systems, homeostatic reinforcement learning, neuromodulated learning, computational interoception, autonomic computing, metareasoning, and classical control already occupy substantial parts of the design space. The formal distinction from ordinary control is not expressive power. A sufficiently general controller can encode everything described here. RC's claim is that **making the relationships explicit as a software contract** may improve modularity, composability, long-horizon adaptation, safety reasoning, and inspectability. That proposition requires evidence. The condition-signalling boundary is also imperfect. Any typed signal has semantics. Formal work is needed to distinguish regulatory condition from effect specification using information-flow rules, type systems, capability constraints, or other enforceable mechanisms rather than vocabulary alone. The Internal Milieu creates an observability problem. Some variables are direct measurements; others are proxies. Poor proxies can be Goodharted. Learned proxies can become opaque. Confidence and provenance therefore matter as much as the signal value. Predictive regulation introduces forecast risk. Allostasis is useful when forecasts are useful. Biased forecasts can make the system pre-emptively wrong. Coupled slow variables create testing problems because failure may develop over hours or days rather than within a unit-test window. Persistent regulatory state may also encode sensitive operational patterns: user routines, workload cycles, organisational pressure, or resource conditions. Privacy, retention, and access controls therefore require explicit treatment. Finally, the biological analogy must remain subordinate to engineering evidence. Endocrine systems, circadian mechanisms, and neuromodulation are not clean software layers waiting to be copied. If a biological property does not improve an artificial system, it should be discarded without sentiment. --- ## 16. Conclusion Persistent intelligent systems accumulate more than memory. They accumulate condition. That condition can matter even when the next task input has not changed. Resource pressure may have risen. Uncertainty may have persisted. Repeated failure may justify stronger verification. Unresolved state may demand consolidation. A predictable future load may justify preparation before a hard limit is crossed. Today, such adjustments are usually spread across configuration, controller logic, reward functions, schedulers, agent prompts, and local heuristics. Regulatory Computation proposes that a subset of them be treated as one explicit architectural concern. The proposed primitive is not an instruction. It is not a goal. It is not a prediction. It is not a permission. It is a **persistent modulation signal**: a bounded expression of internal condition whose value carries temporal history, whose effects are interpreted locally by heterogeneous receivers, and whose authority over external effects is deliberately zero. That yields a clean three-plane model for persistent intelligent systems: ```text Cognition | Regulation | Governance } ``` **Cognition** determines what follows and what action might be useful. **Regulation** determines the persistent operating disposition under which cognition, memory, learning, scheduling, and resource allocation occur. **Governance** determines which proposed consequences may legitimately cross the boundary into the world. The strongest formulation of the thesis is therefore: > **Regulatory Computation is an architectural form of stateful modulation in which persistent, bounded-bandwidth internal signals integrate history and anticipated conditions, are interpreted through heterogeneous receiver-specific responses, and alter computational disposition without directly specifying effect-level actions or expanding authority.** Nothing in that statement requires machines to be organisms. Nothing requires a new theory of computability. Much of the mathematics is old, and several neighbouring research traditions have already demonstrated important pieces. The open question is architectural rather than metaphysical: > **Does making regulation explicit produce persistent intelligent systems that are measurably more viable, adaptable, efficient, inspectable, and governable than systems that leave the same functions implicit?** That question is now specific enough to build against. The next step is not another metaphor. It is an implementation, strong baselines, long-horizon perturbation experiments, adversarial authority tests, and evidence. --- ## References Beaulieu, S., Frati, L., Miconi, T., Lehman, J., Stanley, K. O., Clune, J., & Cheney, N. (2020). *Learning to Continually Learn*. ECAI 2020. arXiv:2002.09571. Candia-Rivera, D. (2026). Interoceptive machine framework: Toward interoception-inspired regulatory architectures in artificial intelligence. *Physics of Life Reviews, 58*, 18–35. DOI: 10.1016/j.plrev.2026.06.003. Frémaux, N., & Gerstner, W. (2016). Neuromodulated spike-timing-dependent plasticity, and theory of three-factor learning rules. *Frontiers in Neural Circuits, 9*, 85. DOI: 10.3389/fncir.2015.00085. Grove, J. C. R., Gray, L. A., La Santa Medina, N., Sivakumar, N., Ahn, J. S., Corpuz, T. V., et al. (2022). Dopamine subsystems that track internal states. *Nature, 608*, 374–380. DOI: 10.1038/s41586-022-04954-0. Kephart, J. O., & Chess, D. M. (2003). The vision of autonomic computing. *Computer, 36*(1), 41–50. DOI: 10.1109/MC.2003.1160055. Keramati, M., & Gutkin, B. (2014). Homeostatic reinforcement learning for integrating reward collection and physiological stability. *eLife, 3*, e04811. DOI: 10.7554/eLife.04811. Lee, S., Oh, Y., An, H., Yoon, H., Friston, K. J., Hong, S. J., & Woo, C.-W. (2026). Life-inspired interoceptive artificial intelligence for autonomous and adaptive agents. *Nature Machine Intelligence, 8*, 1335–1346. DOI: 10.1038/s42256-026-01296-8. Miconi, T., Rawal, A., Clune, J., & Stanley, K. O. (2019). *Backpropamine: Training self-modifying neural networks with differentiable neuromodulated plasticity*. International Conference on Learning Representations. Petzschner, F. H., Garfinkel, S. N., Paulus, M. P., Koch, C., & Khalsa, S. S. (2021). Computational models of interoception and body regulation. *Trends in Neurosciences, 44*(1), 63–76. DOI: 10.1016/j.tins.2020.09.012. Ramsay, D. S., & Woods, S. C. (2014). Clarifying the roles of homeostasis and allostasis in physiological regulation. *Psychological Review, 121*(2), 225–247. DOI: 10.1037/a0035942. Russell, S., & Wefald, E. (1991). Principles of metareasoning. *Artificial Intelligence, 49*(1–3), 361–395. DOI: 10.1016/0004-3702(91)90015-C. Sauzé, C., & Neal, M. (2013). Artificial endocrine controller for power management in robotic systems. *IEEE Transactions on Neural Networks and Learning Systems, 24*(12), 1973–1985. DOI: 10.1109/TNNLS.2013.2271094. Shen, W.-M., Salemi, B., & Will, P. (2002). Hormone-inspired adaptive communication and distributed control for CONRO self-reconfigurable robots. *IEEE Transactions on Robotics and Automation, 18*(5), 700–712. DOI: 10.1109/TRA.2002.804502. Sterling, P. (2012). Allostasis: A model of predictive regulation. *Physiology & Behavior, 106*(1), 5–15. DOI: 10.1016/j.physbeh.2011.06.004. Xu, Q.-Z., & Wang, L. (2011). Recent advances in the artificial endocrine system. *Journal of Zhejiang University–Science C, 12*, 171–183. DOI: 10.1631/jzus.C1000044. Yi, T.-M., Huang, Y., Simon, M. I., & Doyle, J. (2000). Robust perfect adaptation in bacterial chemotaxis through integral feedback control. *Proceedings of the National Academy of Sciences, 97*(9), 4649–4653. DOI: 10.1073/pnas.97.9.4649. --- ### Canonical positioning statement > *Regulatory Computation is not proposed as a new computational model in the sense of computability theory, nor as the first use of homeostatic, endocrine-inspired, interoceptive, neuromodulatory, self-adaptive, or metareasoning mechanisms in artificial systems. It is proposed as a systems-level architectural abstraction in which persistent internal regulatory state is transformed into bounded signals whose effects are locally interpreted by heterogeneous receivers and which modulate computational disposition without directly specifying effect-level actions or expanding authorisation. The formulation unifies previously separate mechanisms into an explicit interface contract and yields testable hypotheses concerning long-horizon viability, adaptability, resource efficiency, modularity, inspectability, and governance safety.*