Topology, isolation, and verification form a causal chain for reliable agent scaling

Type: kb/types/note.md · Tags: computational-model, llm-reliability

This KB treats hierarchical decomposition, scope isolation, and error correction as largely independent design concerns — developed in bounded-context orchestration model, LLM context is composed without scoping, and error correction with above-chance oracles respectively. Tu (2026) argues they form a causal dependency chain instead: topology creates decomposition boundaries, isolation manufactures verifiable atomic units, verification exploits the structure they produce. If the dependency is real, you cannot "just add verification" to a flat system — you must first have decomposition and isolation in place.

The dependency argument

Topology → isolation. Hierarchical decomposition creates the boundaries that make isolation possible. Without decomposition, everything lives in one context — there are no units to isolate. The select/call loop already builds this step: it decomposes work into bounded calls, each with a fresh, scoped context. But the KB frames this as an architectural choice, not a prerequisite for what follows.

Isolation → verification. The error correction framework requires decorrelated checks — the verifier's error modes must differ from the generator's. Isolation plausibly contributes to this (though neither the error correction note nor Tu makes the argument directly): a verifier assessing an isolated unit operates on clean context, so it is less likely to share the generator's biases than one working in the same flat, accumulated state. The coordination guarantees note predicts contamination when frame-local information remains globally visible. This note extends that mechanism into the hypothesis that shared contamination can bias generation and verification toward the same errors.

The combined effect. Sequential reasoning hits a hard ceiling: success probability decays exponentially with the number of steps, because each step has some probability of error. Tu argues that hierarchical structure bypasses this by reducing sequential depth from linear to logarithmic while distributing total work across parallel branches; redundant, decorrelated checks at local gates can then suppress errors exponentially.

Long horizons may accumulate semantic relaxation. A long-running agent does not merely take many steps; it repeatedly concretizes a partly specified state into a plan, action, or artifact. The linked note establishes a single-step mechanism: generation can silently drop an unsatisfied constraint, producing a locally plausible witness for a weaker intermediate problem. This note extends it into a long-horizon hypothesis. If later steps accept that output as settled upstream state, they can remain coherent while compounding the relaxation, so the whole run eventually succeeds at the wrong task. The hypothesis supplies a semantic mechanism for the chain: topology exposes dependency boundaries and shortens unchecked sequential paths; isolation contains an unverified commitment instead of immediately turning it into shared context; verification checks it against the parent constraints before it gains downstream authority. The operative horizon would then be the number of dependent commitments an output can influence before an independent check, not only the number of elapsed steps.

KB evidence for the chain

Several existing notes contain evidence consistent with the dependency ordering, though none name it explicitly:

  • ConvexBench (Liu et al., 2026): the retained extracts report an F1 result of about 0.2 at depth 100 and F1=1.0 across depths for the paper's focused-context agentic framework. This contrast establishes benchmark improvement under the named integrated framework. The extracts do not identify which framework component caused it, so the result cannot establish pruning, verification, or any dependency edge in isolation.

  • MAKER (Meyerson et al., 2025): Maximal decomposition (m=1) with voting achieves zero errors over 1M steps — under the chain framing, all three mechanisms present. The decomposition heuristics call this "exploit clean frames recursively."

  • Scheduler-LLM separation (bounded conjecture): The linked note argues that symbolic scheduling removes bookkeeping from the LLM and keeps semantic work in bounded calls. Under the chain framing used here, that division supplies topology and isolation while leaving semantic error correction to the bounded calls. The two-thirds classification is this note's mapping, not terminology from the linked note. Tu's two-channel failure model (global drift = depth-driven, residual leaf errors = work-driven) offers a different decomposition of the same phenomenon.

  • Kim et al.'s error amplification (synthesis is not error correction): 17.2× amplification when agents solve the same task with outputs merged, not voted. The linked account establishes no task decomposition and no voting. It does not classify the agents' context boundaries, so this target leaves scope isolation unclassified; the evidence cannot isolate which missing mechanism is responsible.

  • Knowledge-Centric Self-Improvement (ingest): all three mechanisms coexist in a knowledge-curation protocol that reports measured gains. Fresh, stateless task-solving agents isolate private conversational state; the task-forum → cross-task-forum → distillation ladder supplies topology; peer challenge filters natural-language claims while benchmark evaluators establish task and artifact outcomes. Because the source evaluates this integrated protocol rather than independently varying those mechanisms, this note treats the case as coexistence evidence, not evidence for their individual effects or dependency order. The paper motivates the design by arguing that conflicting updates can dilute a persistent agent's useful behavior, but does not test that failure mechanism separately.

The protocol also complicates prediction 1 below because shared state crosses the fresh contexts through one mutable knowledge base. It does not place every write behind challenge and distillation: forum agents cite earlier forum posts, and each task-solving agent receives the typed attempt table alongside per-task and cross-task distilled insights. Reusable guidance is distilled before it reaches the next generation, but some shared state is consumed earlier. The case therefore distinguishes private-context isolation from shared-state isolation; it does not instantiate the universal verification gate the frozen note attributed to it.

The simpler account: decomposition with two corollaries

The three mechanisms might reduce to one. If you decompose well enough:

  • Isolation is automatic — each piece gets its own context by construction. Sub-agents in the orchestration model already receive fresh frames; no separate isolation mechanism is needed.
  • Verification becomes tractable — small, atomic pieces are easier to check than large, entangled ones. MAKER's voting works precisely because maximal decomposition produces single-answer steps.

Under this account, "topology → isolation → verification" describes the same thing at three levels of abstraction rather than three genuinely independent mechanisms.

Distinguishing the two framings

The dependency claim makes predictions the simpler account does not:

  1. Decomposition without isolation should fail. A system that decomposes into sub-tasks but shares mutable state across them (e.g., sub-agents writing to a shared scratchpad) should show verification degrading even though topology is present. The coordination guarantees note predicts this via contamination, but no KB source demonstrates it experimentally with decomposition held constant.

  2. Isolation without topology should partially succeed. A flat system with strong scoping conventions (role markers, XML delimiters) but no decomposition should show some verification benefit. If the simpler account is right, this configuration shouldn't exist: you can't have meaningful isolation without decomposition.

  3. Verification without isolation should degrade with scale. An LLM judge reviewing outputs from a flat, unscoped system should see its discriminative power shrink as context grows, because shared context biases the judge toward the generator's errors. Content-effects evidence shows semantic-content effects across several model families and newer or larger models, but it does not study generator/verifier pairs, shared accumulated context, or judge discrimination. This note uses that result only as an analogy motivating the experiment. If the dependency claim is right, shared context should measurably degrade judge accuracy; if verification is independent of isolation, it should not.

Open Questions

  • Tu's two-channel failure model (global drift vs. residual leaf errors) and the KB's three-phenomena model (underspecification, indeterminism, bias) in the scheduler-LLM separation note appear orthogonal. Does one subsume the other, or do they capture different aspects?
  • The linear collapse argument assumes independent per-step errors. The KB's error correction note documents correlated errors extensively (content effects shared across model families). How does the causal chain change under correlated errors?
  • Tu notes that "no current approach fully engages all three mechanisms." Is this because full engagement is hard to achieve, or because the mechanisms are not as independent as the chain suggests?
  • Does "managerial capacity" — a parent agent's ability to manage children, which limits branching factor — belong in the KB's decomposition heuristics as an explicit constraint on topology?

Sources:

Relevant Notes: