When should a holon stop and rethink? Bounded reconsideration

Understand how a source paper quantifies the cost of deciding when to reconsider intentions, why learning to tell relevant events from irrelevant ones has provable economic value, and — just as important — exactly what the paper has and has not demonstrated empirically.

Track

Research

Module

5 · Research case studies

Prerequisites

When do many agents become one? Holonic composition · What is an autonomous agent

Commitment is the whole point of an intention: once an agent intends something, it stops re-deliberating and gets on with the plan. But the world changes, and sometimes a change really does invalidate the plan. So every BDI agent faces a governance question on each incoming event: reconsider, or hold the commitment? Reconsider too eagerly and the agent thrashes; hold too stubbornly and it acts on a plan the world has already broken.

The source paper refuses to treat this as a vibe. It models the stream of events the holon sees as typed — partitioned into classes like state-change, deadline, exception, cross-holon, external-stimulus — and attaches to each class two numbers: how often events of that class occur, and how often such an event is genuinely relevant (i.e. would actually require rethinking an intention to stay coherent). A reconsideration policy then decides, per event, whether to trigger a rethink. The question becomes quantitative: what does a given policy cost, and what coherence does it buy?

Two structural pieces support the result. First, a sensor: the paper formalises the perception layer as a mapping from raw environment states to typed events — an observation step, a classifier that assigns an event class, and an encoder that emits the typed event. Second, a reconsideration policy that is class-typed: it runs a separate decision per class rather than one global rule. For each class the paper defines a true-positive rate (it correctly triggers on relevant events) and a false-positive rate (it triggers on irrelevant ones).

Typed event

An event tagged with a class, exposed by the substrate. Typing is a refinement of the event space, not an extra component — it partitions what the substrate already shows.

Relevance density (of a class)

The conditional probability that an event of that class actually requires reconsidering an intention to preserve means–end coherence.

Relevance-blind policy

One whose trigger rate is the same on relevant and irrelevant events of a class (true-positive rate equals false-positive rate) — it cannot tell them apart.

Relevance-informed policy

One with a positive gap between its true-positive and false-positive rates on at least one class — it has learned to discriminate relevance.

Sensor soundness

The classifier assigns the correct class to each state; the paper shows soundness makes the estimated class frequencies and relevance densities converge to their true values, which is what the bounds below rely on.

The paper's reconsideration result (it labels it T5) bundles several claims. A cost claim: the expected per-event reconsideration cost decomposes cleanly across classes in terms of each class's frequency, relevance density, and the policy's true/false-positive rates. A concentration claim: over an independent window of events, the empirical miss rate stays close to its mean with an exponential (Hoeffding-style) tail — so the miss rate you measure on a sample is a trustworthy estimate of the real one. And a coherence claim: a policy whose true-positive rate is high enough on every class keeps the miss rate below any target you set, preserving means–end coherence in expectation to within that target.

The sharpest part is the informed–blind separation. A relevance-informed policy that discriminates perfectly can reach zero miss rate at a cost bounded by the intrinsic "relevance budget" of the environment (how much genuinely relevant stuff there is) plus a small false-positive surcharge. A relevance-blind policy that wants the same low miss rate is forced to pay a cost bounded below by a quantity that grows without limit as the target miss rate shrinks — in the regime where every class is equally relevant, blind filtering pays linearly in how aggressively it must trigger, while informed filtering pays only the intrinsic budget. In short: the ability to tell relevant from irrelevant events has provable, quantifiable economic value, and that value diverges as you demand more coherence.

synthetic — the two policies, same miss-rate target
goal: keep miss rate <= delta (as delta -> 0)

relevance-informed (learns to discriminate):
    cost ~ intrinsic relevance budget  +  small false-positive surcharge
    reaches miss rate 0 at bounded cost

relevance-blind (cannot discriminate):
    cost grows without bound as delta -> 0
    (to miss fewer relevant events it must trigger on more of everything)

Status: PROVEN (proof sketches given), resting on mild structural assumptions — a class decomposition of events and conditional independence of the per-class decisions. The paper notes the typing assumption is cheap: any substrate that exposes events together with their class metadata satisfies it, so the sharper exponential concentration replaces a weaker generic bound at no architectural cost.

A document-processing holon receives a torrent of events: files arriving (state-change), SLA timers (deadline), parser errors (exception), signals from a sibling holon (cross-holon). Most file-arrival events are routine; most deadline events are relevant. A blind policy applies one trigger rate to all of them and must choose between thrashing on routine arrivals or missing live deadlines. A class-typed informed policy learns a high trigger rate on the deadline class and a low one on routine arrivals.

synthetic — per-class policy beats one global rule
class           frequency   relevance   informed trigger   blind trigger
state-change    high        low         low                 same for all
deadline        low         high        high                same for all
exception       medium      high        high                same for all

blind:     one rate -> either misses deadlines OR thrashes on arrivals
informed:  per-class -> catches deadlines, ignores routine arrivals

The payoff is exactly the separation theorem in miniature: the informed policy buys low miss rate cheaply by spending its attention where relevance density is high, while the blind policy cannot, because it has thrown away the very distinction that makes attention efficient.

This recasts the classic resource-bounded-rationality intuition with a number attached. "Don't reconsider everything" is not just prudent; the paper shows that relevance discrimination is the operational source of an agent's cognitive-economic value, and that the value is realised only when the policy actually conditions on relevance — a property you can measure in production from the per-class true/false-positive rates. For a holon, the same typed-event machinery routes the mutual-responsiveness channel of case lesson 1: cross-holon events are their own class with their own relevance density.

There is a security reading too. An attacker who floods a holon with low-relevance events is attacking its reconsideration economics — a denial-of-service against attention. A relevance-blind agent is cheap to overwhelm; an informed one degrades gracefully because it has already learned to down-weight the noisy class. And because reconsideration governs when the agent revisits commitments, a poisoned event stream that suppresses triggers on a genuinely relevant class is a way to keep an agent committed to a plan the world has broken — related to memory-poisoning and excessive-agency failure modes.

This is the honesty section for the whole three-part case study. Keep these categories strictly apart:

• ▸PROVEN (deductive, proof sketches): all six theorems across the three lessons — composition, hierarchical persistence, emergence by topology jump, Topology 6 closure, bounded reconsideration with the informed–blind separation, and arbitrated composition. These are results about the formal model.
• ▸MEASURED (preliminary feasibility only): the paper reports a reference deployment running two heterogeneous holons concurrently on consumer-grade hardware, sustaining a throughput on the order of tens of multi-page documents per minute with no observed substrate contention. This demonstrates that the runtime can host heterogeneous holons at a practical rate.
• ▸EXPLICITLY NOT VALIDATED: the paper states that this feasibility run does NOT test the composition or emergence theorems. Those require interventional experiments that are deferred — the full empirical programme is contingent on large-scale compute the authors did not yet have.
• ▸OPEN: whether Type 5 is closed under composition; the spectrum of attainable topology jumps; a learning-theoretic analysis of the interface (sample complexity, regret); adversarial sub-holons; and non-stationary event distributions.
• ▸SCOPE / ASSUMPTIONS: finite intention sets; a global (stationary) event distribution; the interface treated abstractly rather than as a concrete learning algorithm.

Expected direction: (a) The six theorems (composition, persistence, emergence/topology-jump, Topology 6 closure, bounded reconsideration, arbitrated composition) are proven deductively via proof sketches — results about the formal model. (b) The only measured result is a preliminary feasibility run: two heterogeneous holons on consumer hardware sustaining on the order of tens of multi-page documents per minute with no substrate contention — i.e. the runtime can host heterogeneous holons at a practical rate. (c) The paper explicitly says this feasibility run does not validate the composition or emergence theorems; presenting a throughput measurement as a "benchmark proving composition/emergence" would misrepresent a proven model property as an empirically validated one and a runtime feasibility number as a theorem test.

What makes an event stream "typed," and why does typing help?

Events are partitioned into classes (state-change, deadline, exception, cross-holon, etc.), each with its own frequency and relevance density. Typing lets a policy decide per class instead of with one global rule, and it sharpens the concentration bound on the miss rate.

State the informed–blind separation in one sentence.

A relevance-informed policy reaches zero miss rate at a cost bounded by the intrinsic relevance budget plus a small false-positive surcharge, while a relevance-blind policy aiming at the same low miss rate pays a cost that grows without bound as the target tightens.

Which of the paper's claims were empirically validated?

None of the theorems. The only empirical result is a preliminary feasibility measurement of runtime throughput for two heterogeneous holons; the paper explicitly defers validation of the composition and emergence theorems to future interventional experiments.

What does the single measured throughput figure actually establish?

That the runtime/substrate can host heterogeneous holons concurrently at a production-relevant rate (on the order of tens of multi-page documents per minute, no observed contention) — nothing about whether the composition theorems hold in practice.