Globality Necessity Theorem

Summary: Why evaluative feedback must be globally available (not merely local)

This document proves a structural necessity claim about architecture, not an identity claim about consciousness.

Theorem (Globality Necessity). Let an agent operate with bounded representational/compute capacity and face novelty (task-relevant factors can change in ways not perfectly predictable from a fixed schedule). If the agent sustains integrated competence on tasks requiring coordinated tradeoffs across multiple internal operators, then some evaluative signal must be globally available: it must causally influence at least two distinct control/update operators. If evaluative feedback is purely local (private to each operator), then there exists a task family for which the agent either (i) thrashes/oscillates, (ii) remains persistently misallocated, or (iii) implicitly reconstructs a shared global evaluative variable (broadcast) under another name.

1. Setup

We model an agent as a collection of interacting operators/modules indexed by i ∈ {1, ..., m}.

Each module i controls an internal decision variable u_i(t) (examples: attention allocation, retrieval choice, compute routing, memory write gate, plan selection, action policy), and updates according to some rule:

u_i(t + 1) = F_i(u_i(t), x(t), z(t); params_i)

where:
- x(t) is the current input and/or world observation,
- z(t) is the shared internal state (messages, activations, memory) that may be exchanged,
- params_i are fixed parameters.

Bounded capacity (super-threshold)

The agent cannot represent, compute, or optimize over all relevant latent factors simultaneously. Therefore it must allocate limited resources among competing demands.

A consequence of bounded capacity is that many tasks inherently involve tradeoffs: improving one subsystem’s local objective can degrade another subsystem’s objective.

2. Local vs global evaluation

Definition 1 (Local evaluation)

Module i may compute a local evaluative signal E_i(t) (mismatch, uncertainty, value proxy, stability cost, etc.). Local evaluation affects only that module’s update:

$$\frac{\partial u_i(t+1)}{\partial E_i(t)} \neq 0$$

Purely local evaluation means evaluation does not affect other modules:

$$\frac{\partial u_j(t+1)}{\partial E_i(t)} = 0 \text{ for all } j \neq i$$

So each module can have feedback, but the feedback remains private.

Definition 2 (Global evaluative availability)

There exists some evaluative signal E(t) (scalar, vector, field, broadcast message) such that it influences at least two distinct modules:

There exist i ≠ j such that

$$\frac{\partial u_i(t+1)}{\partial E(t)} \neq 0 \text{ and } \frac{\partial u_j(t+1)}{\partial E(t)} \neq 0$$

This is the minimal meaning of globality: evaluation is readable and usable by multiple operators.

3. Integrated competence requirement

We say the agent must maintain integrated competence when:

Success requires coordinating multiple operators (not just solving a single-module prediction problem).
The world exhibits novelty: task-relevant factors can shift in ways not perfectly predictable from a fixed internal schedule.
The agent must remain stable (avoid chronic oscillation, fragmentation, or persistent misallocation).

The key point is that coordination problems arise precisely because of bounded capacity: there is no free lunch where every module can optimize its own local proxy without harming others.

4. The core failure mode

If evaluation is purely local, then the architecture lacks a mechanism to compute and enforce the correct cross-module tradeoff.

This produces a generic failure mode:

Module A improves its own proxy objective.
Module B improves its own proxy objective.
The joint behavior violates the global objective because the proxies conflict.

This is a structural form of cross-module Goodharting and typically manifests as:

thrashing/oscillation (modules fight each other), or
persistent error (one module suppresses necessary adaptation), or
pathological local optima (each module is locally happy, globally wrong).

We now prove existence of tasks where this failure is unavoidable.

5. Task family: the coordination-with-switching problem

We construct a task that requires the agent to coordinate two operators:

Operator S: a Selector (attention / retrieval / routing) choosing which channel to use.
Operator P: a Planner/Stabilizer controlling persistence (whether to keep current plan stable or allow switching).

World state

There are two latent regimes, A and B. At any time, one regime is active.

In regime A, the correct channel is A.
In regime B, the correct channel is B.

Regime changes occur unpredictably (not on a fixed known schedule), but not adversarially in real time. You can model this as a fixed stochastic switching process with nonzero hazard.

Agent controls

At time t the agent chooses:

selection action s(t) ∈ {A, B}
stability action p(t) ∈ {STAY, SWITCH}

Interpretation:
- STAY means keep the current plan/context stable.
- SWITCH means permit a rapid update/reconfiguration.

Payoff

The agent gets reward 1 iff both conditions hold:

s(t) matches the true regime at time t
the agent does not destabilize unnecessarily

Destabilization cost is incurred whenever SWITCH is used, and repeated switching causes cumulative harm (loss of coherence, wasted compute, corrupted memory, etc.).

Thus the global best behavior is:

keep STAY by default (stability),
switch selection only when mismatch evidence is strong enough to justify the stability cost.

This is an explicit cross-module tradeoff.

6. Why purely local evaluation fails on this task

Assume purely local evaluation:

Selector S has local mismatch signal E_S(t) that increases when it selects the wrong channel.
Planner P has local stability cost signal E_P(t) that increases when switching occurs.

Crucially:

Planner P cannot see E_S(t).
Selector S cannot see E_P(t).

Lemma 1 (Planner becomes a universal switch inhibitor)

Because switching carries local stability penalty, Planner P learns to suppress SWITCH whenever possible.

But P cannot distinguish:
- switching that is necessary (regime actually changed), from
- switching that is noise.

So the best policy from P’s local perspective is to reduce switching in general.

Therefore, in a purely local architecture, P trends toward being a generic inhibitor of adaptation.

Lemma 2 (Selector cannot choose the correct tradeoff boundary)

When regimes change, Selector S experiences increased mismatch. To recover reward, it must switch selection.

But if switching is inhibited by P, then S remains wrong for extended periods, producing persistent error.

Alternatively, S may attempt more aggressive switching to overcome persistent mismatch, which increases destabilization cost and can cause oscillation.

Because S cannot see the stability penalty, it cannot learn the correct boundary:

“switch only when mismatch exceeds stability cost.”

Thus the system either:

under-switches (stays wrong too long), or
over-switches (thrashes),

and cannot reliably achieve the integrated policy needed for high reward.

Lemma 3 (Any successful solution implicitly creates a shared evaluative signal)

Suppose the agent does achieve stable high reward.

Then it must implement some internal computation that compares mismatch evidence against stability cost and gates switching accordingly.

That comparison function is a shared tradeoff signal T(t) that both operators effectively obey.

But if both operators obey T(t), then T(t) is globally available evaluation in the relevant sense: it influences both selection and stabilization updates.

7. Theorem (Globality Necessity)

Theorem. Under bounded capacity and novelty, there exist coordination tasks such that purely local evaluation cannot yield integrated competence. Therefore, any agent that does sustain integrated competence must implement global evaluative availability (evaluation that influences at least two operators).

Proof. Consider the task family in Section 5.

To obtain high reward, the agent must implement the joint rule:

remain stable most of the time,
reconfigure only when mismatch evidence justifies the stability cost.

This rule depends on combining two evaluative concerns:

mismatch/accuracy (E_S)
stability cost (E_P)

In a purely local evaluation architecture, there is no mechanism to compute and enforce the correct cross-module tradeoff boundary, because E_S is not available to P and E_P is not available to S.

By Lemmas 1 and 2, the joint system either suppresses necessary adaptation (persistent misallocation) or produces instability (thrashing/oscillation).

If the system succeeds anyway, it must implement an internal tradeoff variable T(t) that jointly constrains both operators (Lemma 3), which is exactly a globally available evaluative signal.

Therefore integrated competence implies global evaluative availability. QED.

8. Corollaries

Corollary 1 (Local feedback prevents local collapse, not global coherence)

Local evaluation can stabilize a single module, but cannot guarantee whole-agent coherence when success requires coordinated tradeoffs.

Corollary 2 (Global broadcast is a minimal coordination primitive)

Global evaluation is not an optional extra. Under bounded resources, it is the simplest architectural way to prevent cross-module Goodharting and thrashing.

Corollary 3 (Closure emerges as necessity)

If an agent is super-threshold competent and integrated, then some evaluative object must be readable by multiple operators.

9. What this does NOT claim

This theorem does not claim:

that global evaluation is consciousness,
that a single scalar reward is required,
that local evaluation is useless,
that all systems must have the same broadcast mechanism.

It claims only:

For a bounded-capacity agent under novelty, integrated competence requires some evaluative signal to be globally available to multiple control/update operators.

10. Optional strengthening

The two-operator task generalizes to m operators:

each operator optimizes a local proxy,
the global objective requires satisfying multiple constraints simultaneously,
without a shared evaluative tradeoff signal, modules Goodhart each other.

Thus globality is not a special feature of the toy task; it is a generic coordination requirement under limited resources.