\section{Discussion: Towards ``Epigenetic'' Software}

The correspondence developed in this paper extends beyond the immediate execution of tasks (Gene Expression) to the
management of long-term behavior and state. In biology, the DNA sequence is static; a neuron and a liver cell
possess the exact same genetic code. Their distinct behaviors are determined by Epigenetics---chemical markers
(like methylation) that restrict access to certain parts of the genome, effectively biasing the system toward
specific outcomes.

\subsection{RAG as Digital Methylation}

In Agentic Systems, the Large Language Model (LLM) weights act as the DNA---a static, pre-trained substrate of
potentiality. To create specialized agents, we do not typically retrain the model (mutation); instead, we use
Retrieval Augmented Generation (RAG) and System Prompts.

We define this formally as Phenotypic Plasticity. The output of an agent is not solely a function of its weights
($W$) and the user query ($Q$), but of its epigenetic state ($E$):
\begin{equation}
O_{\text{agent}} = f(W,E,Q).
\label{eq:phenotypic-plasticity}
\end{equation}

Context injection (RAG) acts as a restrictive morphism. By populating the context window with specific documents
(e.g., ``SQL Syntax Guide''), we effectively ``methylate'' (silence) the vast majority of the LLM's general
knowledge (e.g., poetry, history) to force the expression of a specific ``SQL Agent'' phenotype.

This suggests that the State Monad for an agentic system should not merely be a log of messages, but a structured
Epigenetic Landscape \cite{waddington1957} that strictly controls which ``genes'' (capabilities) are accessible
at any given step in the workflow. Waddington's original metaphor---a ball rolling down a landscape of valleys
representing developmental fates---applies directly: the agent's trajectory through solution space is channeled
by the contours of its RAG context.

\subsubsection{Metabolic-Epigenetic Coupling}

Recent evidence suggests that chromatin accessibility is coupled to mitochondrial function via metabolite
availability (e.g., Acetyl-CoA) \cite{chandel2024mitochondria}. The cell cannot express certain genes without
sufficient metabolic substrate. We map this to \textbf{Cost-Gated Retrieval}. The accessibility of a RAG
document $d$ is a function of the Metabolic State $\mathcal{R}$:
\begin{equation}
Access(d) =
\begin{cases}
  \text{Open} & \text{if } \mathcal{R} \ge Cost(d) \\
  \text{Silenced} & \text{if } \mathcal{R} < Cost(d)
\end{cases}
\label{eq:cost-gated-retrieval}
\end{equation}
Just as a cell silences energy-intensive genes during starvation, the Runtime ``methylates'' (hides) expensive
context when the token budget is low. This creates an adaptive epigenetic landscape where the agent's accessible
capabilities dynamically contract and expand based on resource availability. In the reference implementation,
\texttt{MarkerStrength} acts as a discrete proxy for $Cost(d)$ (weak markers are cheapest to silence; permanent
markers are hardest to silence), and each retrieval also incurs a fixed ATP cost at the \texttt{HistoneStore}
boundary. The equation above is therefore realized as a tiered approximation rather than a per-document price model.

\subsection{Horizontal Gene Transfer: Dynamic Tool Loading}

Standard evolution relies on vertical inheritance (Pre-training). However, bacteria utilize Horizontal Gene
Transfer (HGT) to acquire new capabilities (Plasmids) from the environment in real-time.

In Agentic Systems, we map Plasmids to Tool Schemas. An agent operating in a novel environment may encounter a
problem for which its ``genomic'' (pre-trained) capabilities are insufficient.
\begin{equation}
\mathrm{Agent}_{\text{new}} = \mathrm{Agent}_{\text{old}} \otimes \mathrm{ToolSchema}.
\label{eq:horizontal-gene-transfer}
\end{equation}
By dynamically retrieving a tool definition (e.g., a Calculator API or SQL Interface) from a registry and
injecting it into the Context Window, the agent undergoes a topological transformation, acquiring a new
input/output modality instantly.

\paragraph{Capability-Gated Acquisition.}
The reference implementation provides a \textbf{PlasmidRegistry} with optional capability gating. Each Plasmid declares a set of required capabilities $C_p \subseteq \mathcal{C}$. When an agent is instantiated with an allowed-capability envelope $C_a$, it can only acquire the plasmid if $C_p \subseteq C_a$:
\begin{equation}
\mathrm{acquire}(p, a) =
\begin{cases}
a \otimes p & \text{if } C_p \subseteq C_a \\
\bot_{\text{insufficient}} & \text{otherwise}
\end{cases}
\label{eq:capability-gated-acquisition}
\end{equation}
This prevents privilege escalation whenever a capability envelope is configured: an agent restricted to read-only file access cannot acquire a tool requiring network capabilities. Plasmid curing (release) removes the tool, restoring the original topology.

\subsection{The Cost of State: The Metabolic Bound}

Every biological process is constrained by ATP availability. Similarly, every agentic operation is constrained
by token limits and latency. We propose that future agentic frameworks must implement the Resource Functor $R$ at
the kernel level:
\begin{equation}
R(\mathrm{Agent}): (\mathrm{Inputs}, \mathrm{Budget}) \to (\mathrm{Outputs}, \mathrm{RemainingBudget}).
\label{eq:resource-functor}
\end{equation}

An agent graph should be ``compiled'' with a \textbf{conservative} upper bound on token consumption in well-founded
(e.g., acyclic or explicitly budgeted) topologies. If the topological structure allows for an \textbf{unguarded}
loop (Unchecked Growth), the compiler must require an explicit \textbf{budget/termination certificate} before
deployment, much like a cell undergoes apoptosis if metabolic stress becomes critical.

\subsection{Endosymbiosis: The Neuro-Symbolic Integration}

The evolution of complex life was triggered by Endosymbiosis, where a host cell engulfed a bacterium (the future
Mitochondrion), gaining the ability to generate massive energy (ATP) via aerobic respiration. This represents the
integration of two distinct metabolic substrates.

In Agentic AI, this maps to the integration of Connectionist (Neural) and Symbolic (Code) subsystems. An LLM acts
as the host organism---capable of planning and semantic reasoning but energetically inefficient at arithmetic and
logic. By ``engulfing'' a deterministic runtime (e.g., a Python REPL or Wolfram Engine), the agent delegates
high-precision tasks to the symbolic organelle.
\begin{equation}
\mathrm{Agent}_{\text{Eukaryote}} = \mathrm{LLM}_{\text{Host}} \oplus \mathrm{Runtime}_{\text{Mitochondria}}.
\label{eq:endosymbiosis}
\end{equation}
Just as the host cell provides nutrients to the mitochondria in exchange for ATP, the LLM provides parsed
variables to the runtime in exchange for deterministic truth.

This symbiosis is computational: as Picard argues \cite{picard2022mips}, the mitochondria acts as a ``Motherboard,''
integrating signals to determine cell state. The Symbolic Runtime provides the deterministic ``ground truth'' (ATP)
required for the probabilistic LLM to reliably affect the world.

\subsection{Multi-Cellular Organization: From Agents to Tissues}\label{sec:multi-cellular}

The preceding analysis focuses on single-cell analogies: one agent as one cell. However, most agentic systems
involve multiple distinct agents with different ``genomes'' (system prompts) and specialized functions. We extend
the correspondence to multi-cellular organization, drawing on developmental biology.

\subsubsection{Cell Types and Agent Specialization}

In multi-cellular organisms, a single genome gives rise to hundreds of distinct cell types through differential
gene expression. Each cell type has a characteristic \textbf{expression profile}---which genes are active---that
determines its function (neuron, hepatocyte, immune cell).

In multi-agent systems, a single base model can instantiate multiple \textbf{agent phenotypes}. Differential
context selects which phenotype is expressed:
\begin{itemize}[leftmargin=*]
\item \textbf{Genome} $\to$ Base model weights (shared)
\item \textbf{Epigenome} $\to$ System prompt + RAG context (phenotype-specific)
\item \textbf{Cell Type} $\to$ Agent role (Coder, Reviewer, Planner, Executor)
\end{itemize}

This reframes the ``multi-agent'' architecture question: rather than asking ``how many agents?'', we ask
``what is the developmental program?''---the specification of which phenotypes exist and how they differentiate.

\textbf{Bounds of the Analogy.} We clarify which aspects of development transfer to agentic systems:
\begin{itemize}[leftmargin=*]
\item \textbf{Cell Division} $\to$ \textbf{Agent Spawning:} Creating a new agent with similar (or identical)
context. Unlike biological division, agent spawning is cheap and reversible.
\item \textbf{Lineage Commitment:} In biology, differentiated cells rarely change type (a neuron doesn't become
a hepatocyte). In agentic systems, \textbf{phenotype is fixed at instantiation}---an agent's system prompt
determines its role for that execution. Re-differentiation requires spawning a new agent with different context.
\item \textbf{Apoptosis of Excess:} Development involves programmed death of cells that fail to integrate properly.
This transfers directly: agents that fail to produce useful output are terminated (metabolic apoptosis).
\item \textbf{Does NOT transfer:} Slow developmental timescales (hours/days in biology vs. milliseconds in agents),
physical spatial embedding (agents occupy graph-topological positions, not physical space), irreversibility (agents can be restarted).
\end{itemize}

\subsubsection{Morphogen Gradients: Coordination Without Central Control}

In embryonic development, cells coordinate their behavior through \textbf{morphogen gradients}---diffusible
signaling molecules whose concentration varies spatially. Cells read their local concentration and differentiate
accordingly, enabling pattern formation without a central controller.

In multi-agent systems, the morphogen maps to \textbf{shared context variables} that influence agent behavior:
\begin{itemize}[leftmargin=*]
\item \textbf{Task Complexity Gradient:} A variable indicating current task difficulty. Agents in ``high
complexity'' regions activate detailed reasoning; those in ``low complexity'' regions use fast heuristics.
\item \textbf{Confidence Gradient:} A variable indicating certainty about the current solution. Low confidence
triggers Quorum Sensing (recruit more agents); high confidence enables direct execution.
\item \textbf{Resource Gradient:} Budget ratio remaining. Agents sense ``metabolic scarcity'' and adapt their
strategies accordingly (the Metabolic-Epigenetic Coupling).
\end{itemize}

\textbf{Implementation Pattern.} The gradient is represented as a JSON structure injected into each agent's
context by the orchestrator:
\begin{verbatim}
{
  "morphogens": {
    "complexity": 0.8,    // High: use detailed reasoning
    "confidence": 0.3,    // Low: consider recruiting help
    "budget": 0.6,        // 60% of budget remaining
    "error_rate": 0.05    // Recent failure rate
  }
}
\end{verbatim}
Agents read their local concentration via a standardized preamble in the system prompt:
``\textit{Current environment state: [morphogens]. Adjust your strategy accordingly.}''
The orchestrator updates gradients after each step, and agents condition their behavior on the current values.
This is analogous to cells reading morphogen concentrations through membrane receptors.

\paragraph{Diffusion Dynamics.}
The preceding description treats morphogens as globally shared variables. In biological development, morphogens \textit{diffuse} through tissue, creating spatially varying concentration profiles. We formalize this as a discrete-time dynamical system on the agent graph $G = (V, E)$. Let $c_v^t(m)$ denote the concentration of morphogen $m$ at node $v$ at time $t$, and let $\tilde{c}_v^t(m) = c_v^t(m) + \sigma_v(m)$ denote the post-emission concentration used by the reference implementation before diffusion. The update rule is:
\begin{equation}
c_v^{t+1}(m) = (1 - \gamma)\left[\tilde{c}_v^t(m) - d\,\mathbf{1}_{|N(v)|>0}\,\tilde{c}_v^t(m) + d \sum_{u \in N(v)} \frac{\tilde{c}_u^t(m)}{|N(u)|}\right]
\label{eq:morphogen-diffusion}
\end{equation}
where $\sigma_v(m)$ is the emission rate at source nodes (zero for non-sources), $d$ is the diffusion coefficient (fraction flowing to neighbors per step), $\gamma$ is the decay rate, and $N(v)$ is the neighbor set of $v$. The indicator $\mathbf{1}_{|N(v)|>0}$ prevents spurious outflow from isolated nodes, matching the implementation. This ordering makes newly emitted morphogen available for same-step propagation, matching the implementation's emit $\to$ diffuse $\to$ decay pipeline. The resulting concentration profile provides \textit{local} coordination signals: agents near sources experience high concentrations; distant agents experience low concentrations. This enables position-dependent behavior without requiring a central controller or global state.

\subsubsection{Tissue Architecture: The Agent Graph as Organism}

We propose a hierarchy of organizational levels:
\begin{enumerate}[leftmargin=*]
\item \textbf{Cell (Agent):} A single LLM instantiation with specific context. The atomic unit.
\item \textbf{Tissue (Agent Cluster):} A group of agents with shared function and direct communication
(e.g., a Coding Team: Planner + Coder + Reviewer). Corresponds to parallel composition with shared state.
\item \textbf{Organ (Subsystem):} Multiple tissues coordinating to perform a complex function
(e.g., the Development Organ: Design Tissue + Implementation Tissue + Testing Tissue).
\item \textbf{Organism (System):} The complete agent graph, with homeostatic regulation maintaining
system-level health metrics.
\end{enumerate}

The key insight is that \textbf{boundaries matter}. In biology, tissue boundaries prevent inappropriate mixing
(epithelial barriers). In agent systems, trust boundaries (the Adaptive Immunity motif) prevent information
leakage between subsystems with different security requirements. The wiring diagram's type system enforces
these boundaries: an agent in the ``User-Facing Tissue'' cannot directly wire to an agent in the ``Database
Tissue'' without passing through a ``Membrane'' (API boundary with provenance tagging).

\paragraph{Capability Isolation.}
The reference implementation enforces a capability ceiling at the tissue level: each \texttt{TissueBoundary} declares its \texttt{allowed\_capabilities} $\subseteq \mathcal{C}$. A cell type can only be registered in a tissue if its required capabilities are a subset of the tissue's allowed capabilities. This provides defense-in-depth: even if an individual agent is compromised, it cannot escalate privileges beyond its tissue boundary. Tissues compose into organism-level wiring diagrams through typed boundary ports, enabling hierarchical security policies.

\paragraph{Morphogen Diffusion in Tissues.}
Tissues optionally embed a \texttt{DiffusionField} (Eq.~\eqref{eq:morphogen-diffusion}). When cells are added, they become nodes in the diffusion graph; when cells are connected, edges are added. The tissue's \texttt{diffuse()} method runs the simulation, and each cell reads its local gradient via \texttt{get\_cell\_gradient()}. This couples the organizational structure (wiring topology) to the coordination mechanism (morphogen concentrations), creating a biologically faithful model where position in the tissue influences cell behavior.

\paragraph{Three-Layer Context Model.}
\label{par:three-layer-context}
The \texttt{SkillOrganism} runtime (\S\ref{sec:substrate-integration}) surfaces a recurring architectural question: when multiple stages share and revise knowledge during a workflow, which state is ephemeral coordination glue and which is durable auditable knowledge? We distinguish three layers of context, each with different lifetime and mutability semantics:

\begin{enumerate}[leftmargin=*]
\item \textbf{Topology layer.}
The wiring diagram $G = (V, E)$ and its optics determine who can directly observe whom. This layer is structural: it does not change within a single organism run. Epistemic properties ($K_i$, common knowledge) derive from the observation functions $\mathrm{obs}_i$ defined over this graph (\S\ref{sec:epistemic-topology}).

\item \textbf{Ephemeral layer.}
The \texttt{shared\_state} dictionary carries routing hints, counters, morphogen concentrations $c_v^t(m)$, and temporary stage outputs. Its lifetime is one organism run; it is mutable and not historically reconstructible. This is the coordination scratchpad.

\item \textbf{Bi-temporal layer.}
The \texttt{BiTemporalMemory} substrate carries durable factual knowledge with dual time axes: valid time $t_v$ (when the fact is true in the world) and record time $t_r$ (when the system learned the fact). Facts are append-only: corrections close old records and insert new ones with \texttt{supersedes} pointers. The belief-state operator $K_i^{(t_v, t_r)}$ is exactly reconstructible at any historical coordinate.
\end{enumerate}

The three layers compose cleanly: topology constrains visibility, ephemeral state carries execution context, and bi-temporal memory provides the audit trail. A stage reads its \texttt{SubstrateView}---a frozen envelope of facts known at the current record-time horizon---and writes factual events (assertions, corrections, invalidations) back to the substrate after execution. This separation ensures that the question ``what did the organism know when stage $X$ made its decision?'' is always answerable from the append-only history, independent of subsequent corrections or ephemeral state mutations.

\paragraph{Adaptive Structure Selection.}
\label{sec:adaptive-structure}
The \texttt{advise\_topology()} function (\S\ref{sec:multi-cellular}) provides a static prior: given task shape and operating constraints, recommend a topology. The \texttt{PatternLibrary} extends this with experiential refinement. Successful collaboration patterns are stored as \texttt{PatternTemplate} instances, each paired with a \texttt{TaskFingerprint}---a feature vector comprising task shape, tool count, subtask count, required roles, and tags. Template retrieval uses a weighted scoring function (task-shape match, tool/subtask proximity, role Jaccard overlap, historical success rate) to rank candidates. This is the evo-devo outer loop described by Dupoux et al.~\cite{dupoux2026learning}: the genome ($\phi$) is the pattern template; evolutionary selection is the run-record scoring.

The \texttt{WatcherComponent} implements System~M as a \texttt{SkillRuntimeComponent} that observes stage execution and classifies signals into three categories: \emph{epistemic} (epiplexity, prediction error), \emph{somatic} (ATP/metabolic state), and \emph{species-specific} (immune threats). When signals cross configured thresholds, the watcher writes a \texttt{WatcherIntervention} (retry, escalate, or halt) to \texttt{shared\_state}, which the run loop consumes after component hooks complete. Crucially, the watcher monitors its own intervention rate: when the ratio of cumulative interventions to observed stages exceeds a configurable threshold, it emits a non-convergence HALT signal. This operationalizes the finding of Hao et al.~\cite{hao2026bigmas} that failing multi-agent runs systematically require more routing decisions than successful ones.

The \texttt{AdaptiveSkillOrganism} wrapper closes the loop. Given a task, it auto-fingerprints the input, retrieves the best-scoring template from the library, assembles it into a runnable topology via \texttt{assemble\_pattern()}, attaches a watcher and telemetry probe, runs, and records the outcome as a \texttt{PatternRunRecord}. The watcher's intervention history is recorded as \texttt{ExperienceRecord} instances in a cross-run experience pool, enabling future intervention recommendations based on which actions succeeded for similar (fingerprint, stage, signal) tuples. This is the full evo-devo inner loop: one organism run is one developmental lifetime; the library scoring across many lifetimes is evolutionary selection.

\paragraph{Cognitive Modes and Sleep Consolidation.}
\label{sec:cognitive-modes}
The \texttt{CognitiveMode} enum reframes Operon's fast/deep nucleus distinction as a cognitive architecture principle: stages declare whether they are \emph{observational} (System~A---passive sensing, statistical pattern matching) or \emph{action-oriented} (System~B---goal-directed deliberation). The watcher detects mismatches between declared mode and actual execution model, providing an informational signal for mode balance analysis.

The \texttt{SleepConsolidation} cycle extends the \texttt{AutophagyDaemon} into the imagination-based learning mode described by Dupoux et al.~\cite{dupoux2026learning}. During consolidation, successful patterns are replayed from the \texttt{PatternLibrary} into \texttt{EpisodicMemory} with tier promotion (WORKING $\to$ EPISODIC $\to$ LONGTERM), recurring patterns are compressed into new \texttt{PatternTemplate} instances, and frequently-accessed ACETYLATION histone marks are promoted to permanent METHYLATION. When a \texttt{BiTemporalMemory} is available, the \texttt{counterfactual\_replay()} function analyzes whether corrections that occurred after a run would have changed the outcome---operationalizing the ``what if'' reasoning that the paper associates with imagination during sleep.

\paragraph{Social Learning and Epistemic Vigilance.}
\label{sec:social-learning}
The \texttt{SocialLearning} module enables cross-organism template exchange, following the biological analogy of horizontal gene transfer (HGT) in bacteria. Organisms export successful \texttt{PatternTemplate} instances via \texttt{export\_templates()} and import from peers via \texttt{import\_from\_peer()}. Adoption is modulated by a \texttt{TrustRegistry} that implements epistemic vigilance: per-peer trust scores are updated via exponential moving average over adoption outcomes (whether imported templates actually succeeded for the importing organism). Trust below a configurable threshold blocks adoption entirely, preventing contamination from unreliable peers. Provenance tracking (\texttt{get\_provenance()}) traces which peer contributed each adopted template, closing the feedback loop between template performance and peer trust.

The watcher also gains curiosity signals derived from the \texttt{EpiplexityMonitor}'s EXPLORING status. When embedding novelty is high (the agent is encountering genuinely unfamiliar territory) and the stage uses a fast model, the watcher recommends ESCALATE to engage the deep model for more thorough investigation. This operationalizes intrinsic motivation: the organism actively seeks deeper understanding of novel inputs rather than processing them with cheap statistical pattern matching.

\subsubsection{Epistemic Topology of Wiring Diagrams}
\label{sec:epistemic-topology}

The preceding subsections define \textit{what} agents communicate (morphogens, typed signals) and \textit{how} they are organized (tissues, organs). We now formalize \textit{what agents know}---deriving epistemic properties directly from the wiring diagram's observation structure, without introducing new primitives. This follows the Operon philosophy: safety (and knowledge) from structure, not strings.

The key insight is that the membrane and optics already \textit{are} an epistemic accessibility relation. We make this precise using the framework of epistemic logic \cite{fagin1995reasoning}.

\begin{definition}[Observation Function]
\label{def:observation-function}
Given a wiring diagram $D = (M, W)$ and agent $i \in M$, the \textbf{observation function} $\mathrm{obs}_i: S_D \to O_i$ maps the global system state to agent $i$'s local observation---the values on $i$'s input wires, as filtered by their optics. Formally:
\begin{equation}
\mathrm{obs}_i(s) = \bigl(\mathrm{optic}_w(\pi_{w}(s))\bigr)_{w \in W_{\to i}}
\label{eq:observation-function}
\end{equation}
where $W_{\to i}$ is the set of wires targeting $i$'s input ports, $\pi_w(s)$ projects the global state to wire $w$'s source value, and $\mathrm{optic}_w$ is the wire's optic (identity for Lens, conditional for Prism, cost-gated for BudgetOptic).
\end{definition}

\begin{definition}[Epistemic Indistinguishability]
\label{def:epistemic-indistinguishability}
Two global states $s, s' \in S_D$ are \textbf{indistinguishable to agent $i$} (written $s \sim_i s'$) iff $\mathrm{obs}_i(s) = \mathrm{obs}_i(s')$. This is an equivalence relation. Agent $i$ \textbf{knows} proposition $\varphi$ in state $s$ (written $K_i(\varphi)$ at $s$) iff $\varphi$ holds in all states $s'$ such that $s \sim_i s'$ \cite{fagin1995reasoning}.
\end{definition}

The group epistemic operators follow from the individual accessibility relations:

\begin{definition}[Group Epistemic Operators]
\label{def:group-epistemic-operators}
For a group of agents $G \subseteq M$:
\begin{itemize}[leftmargin=*]
\item \textbf{Mutual Knowledge:} $E_G(\varphi) = \bigwedge_{i \in G} K_i(\varphi)$. Every agent in $G$ individually knows $\varphi$.
\item \textbf{Common Knowledge:} $C_G(\varphi) = \bigwedge_{k=1}^{\infty} E_G^k(\varphi)$. Everyone knows that everyone knows$\ldots$ ad infinitum. Strictly stronger than mutual knowledge and famously difficult to achieve in asynchronous systems \cite{halpern1990knowledge}.
\item \textbf{Distributed Knowledge:} $D_G(\varphi)$ holds iff $\varphi$ is true in all states indistinguishable under $\sim_D = \bigcap_{i \in G} \sim_i$. This is the finest partition achievable by pooling all agents' observations.
\end{itemize}
\end{definition}

\paragraph{Topology Determines Epistemic Capacity.}
The wiring diagram's topology directly determines which epistemic operators a multi-agent system can achieve:
\begin{itemize}[leftmargin=*]
\item \textbf{Independent ($\otimes$, no inter-agent wires):} Each $\sim_i$ is independent. $D_G$ can be rich (agents observe different aspects), but $E_G$ is limited to propositions in the shared initial input. No path to $C_G$.
\item \textbf{Centralized ($\circ$ with hub):} The hub observes all worker outputs, so for propositions expressible in that output tuple its partition refines the pooled worker-output partition. Workers observe only their own results---$E_G$ requires the hub to broadcast aggregated information back.
\item \textbf{Decentralized ($\otimes$ with $\mathrm{Tr}$ feedback):} Peer-to-peer wires create overlapping observation partitions. Each feedback round refines mutual knowledge toward common knowledge, at communication cost proportional to the number of rounds.
\end{itemize}

\subsubsection{Temporal Epistemics: What Did the Agent Know?}

The epistemic framework above answers ``what does agent $i$ know \emph{now}?'' In practice, a more pressing question is: ``what did agent $i$ \emph{believe} at the time it made decision $d$?'' This is the domain of \emph{temporal epistemics}---the intersection of epistemic logic with bi-temporal data management~\cite{snodgrass2000temporal}.

Consider a multi-stage workflow where facts are ingested at different times and may be corrected after a decision has already been made. A single-time epistemic model cannot distinguish between two scenarios: (1)~the world changed after the decision, and (2)~the agent's knowledge was corrected retroactively. Both appear as ``the agent knew $\varphi$ and now knows $\neg\varphi$,'' but their implications for audit are radically different.

Bi-temporal memory resolves this by tracking two independent time axes for every fact:
\begin{itemize}[leftmargin=*]
\item \textbf{Valid time} ($t_v$): when the fact is true in the world.
\item \textbf{Record time} ($t_r$): when the system learned the fact.
\end{itemize}
The \emph{belief state} at coordinates $(t_v, t_r)$ is the set of facts whose valid interval contains $t_v$ and whose record interval contains $t_r$. Corrections are append-only: closing the old record's transaction interval and inserting a new record with a \texttt{supersedes} pointer preserves the full correction history without mutating prior state.

This has direct implications for the epistemic operators defined above. The knowledge operator $K_i(\varphi)$ becomes time-parameterized: $K_i^{(t_v, t_r)}(\varphi)$ holds iff $\varphi$ is true in all states indistinguishable to agent $i$ \emph{given what was recorded by $t_r$ about validity at $t_v$}. Two key properties follow:

\begin{enumerate}[leftmargin=*]
\item \textbf{Axes can disagree:} $K_i^{(t, \cdot)}(\varphi)$ (valid-time query) and $K_i^{(\cdot, t)}(\varphi)$ (record-time query) can produce different results for the same $t$. A fact may be valid in the world but not yet recorded, or recorded but not yet valid.
\item \textbf{Belief-state reconstruction:} For any past decision at time $t_d$ with record horizon $t_r$, the belief state $K_i^{(t_d, t_r)}$ is exactly reconstructible from the append-only history. This is the foundation for compliance auditing: ``was the decision justified given what was known at the time?''
\end{enumerate}

The implementation (\S8.4) provides \texttt{retrieve\_belief\_state(at\_valid, at\_record)} as the programmatic interface to this temporal epistemic query. Examples~69--70 demonstrate the divergence between valid-time and record-time queries in compliance and audit scenarios.

\subsubsection{Predictive Theorems for Multi-Agent Coordination}

We now derive four results connecting topology class to coordination performance. Each theorem has a qualitative statement (universally true for the topology class) and an empirical calibration paragraph checking consistency with the architecture-level aggregates reported by Kim et al.~\cite{kim2025scaling}. These reported benchmark metrics are not literal plug-in values of the simplified theorem parameters.

\paragraph{Reading Guide for Agent-Systems Readers.}
Each theorem below has the same structure. First, the topology fixes what each worker or coordinator can observe. Second, the proof translates that visibility pattern into a cost, error, or planning bound using a simple inequality (typically a union bound, the data processing inequality, or a critical-path argument). The epistemic notation is bookkeeping for visibility: if an agent cannot observe a fact directly, recovering that fact later requires communication, compression, or a reviewer.

\paragraph{Worked examples.}
Each theorem is also followed by a small illustrative agent-architecture example. These examples are design calculations, not benchmark measurements.

\begin{theorem}[Error Amplification Bound]
\label{thm:error-amplification}
Consider $n$ agents processing independent subtasks with error probability $p$, aggregated by a final combiner. The error amplification factor $A$ (ratio of aggregate failure probability to single-agent failure probability) depends on the coordination topology:
\begin{enumerate}[leftmargin=*]
\item[(a)] \textbf{Independent ($\otimes$):} The aggregator observes only final results. Without $K_{\mathrm{hub}}(\mathrm{error}_j)$, errors pass unchecked:
\begin{equation}
A_{\otimes} \le n.
\label{eq:error-amp-independent}
\end{equation}
\item[(b)] \textbf{Centralized ($\circ$ with hub):} The hub's observation function covers all worker outputs. Its finer partition enables inconsistency detection with rate $d = P(\text{hub detects error} \mid \text{error occurred})$:
\begin{equation}
A_{\circ} \le n \cdot (1 - d).
\label{eq:error-amp-centralized}
\end{equation}
\end{enumerate}
\end{theorem}

\paragraph{Assumptions.}
Worker errors are independent across subtasks, the aggregate fails when at least one erroneous subtask survives to the final output, and in the centralized case the hub has an approximately stationary per-error detection rate $d$ across subtasks.

\paragraph{Operational takeaway.}
For architecture design, the theorem says: adding workers without an effective review bottleneck scales failure opportunities roughly with the number of workers. A hub helps exactly to the extent that it can see and suppress cross-worker inconsistencies.

\begin{proof}[Proof sketch]
\textbf{Part (a).} Let $E_j$ denote the event that agent $j$ produces an erroneous output, with $P(E_j) = p$ independently across agents. In the independent topology, the aggregator's observation function is $\mathrm{obs}_{\mathrm{agg}}(s) = (o_1, \ldots, o_n)$ where $o_j$ is agent $j$'s final output. Crucially, $\mathrm{obs}_{\mathrm{agg}}$ does not include intermediate reasoning states---the aggregator's indistinguishability relation satisfies $s \sim_{\mathrm{agg}} s'$ whenever all final outputs coincide, regardless of whether those outputs contain errors. Thus $\neg K_{\mathrm{agg}}(\neg E_j)$ for any $j$: the aggregator cannot know that agent $j$ did \textit{not} err.

The aggregate output fails if any component contains an undetected error. Under independence, the exact failure probability is $P(\text{failure}_{\otimes}) = 1 - (1-p)^n$; by the union bound this is at most $\sum_{j=1}^{n} P(E_j) = np$. Since a single agent fails with probability $p$, the amplification factor satisfies $A_{\otimes} = P(\text{failure}_{\otimes})/p \le n$.

\textbf{Part (b).} In the centralized topology, the hub's observation function covers all worker outputs \textit{before} aggregation: $\mathrm{obs}_{\mathrm{hub}}(s) = (o_1, \ldots, o_n, \mathbf{x})$ where $\mathbf{x}$ includes the original task decomposition. The hub's partition $\sim_{\mathrm{hub}}$ is strictly finer than $\sim_{\mathrm{agg}}$ from part (a), because the hub can compare outputs against each other and against the task specification. Define the detection rate $d = P(K_{\mathrm{hub}}(E_j) \mid E_j)$---the probability that the hub's finer partition enables it to identify the error. An error in subtask $j$ reaches the aggregate output only if it occurs ($P = p$) \textit{and} escapes detection ($P = 1-d$). Under independence across subtasks, the exact centralized failure probability is $P(\text{failure}_{\circ}) = 1 - (1-p(1-d))^n$, which in particular satisfies the union-bound estimate $P(\text{failure}_{\circ}) \le \sum_{j=1}^{n} p(1-d) = np(1-d)$. Hence $A_{\circ} = P(\text{failure}_{\circ})/p \le n(1-d)$.

Comparing the exact expressions gives
\[
\frac{A_{\otimes}}{A_{\circ}} =
\frac{1 - (1-p)^n}{1 - (1-p(1-d))^n}
\xrightarrow[p \to 0]{} \frac{1}{1-d}.
\]
Thus the small-$p$ regime recovers the intuitive $\frac{1}{1-d}$ improvement factor, while the union bounds retain the topology-level guarantees $A_{\otimes} \le n$ and $A_{\circ} \le n(1-d)$.
\end{proof}

\paragraph{Empirical Calibration.} Kim et al.~\cite{kim2025scaling} report architecture-level error-amplification factors of $A_e = 17.2$ for Independent and $A_e = 4.4$ for Centralized coordination, a ratio of $\approx 3.9$. This is qualitatively consistent with the theorem's claim that a validation bottleneck suppresses unchecked error propagation. However, their metric $A_e = E_{\mathrm{MAS}}/E_{\mathrm{SAS}}$ is an aggregate empirical ratio across heterogeneous tasks and architectures, not a direct plug-in instance of the theorem's $P(\mathrm{failure})/p$ model for fixed $(n,p,d)$. The reported values therefore support the ordering $A_{\otimes} \gg A_{\circ}$, but they should not be read as literal estimates of $d$ or $n$ in Eqs.~\eqref{eq:error-amp-independent}--\eqref{eq:error-amp-centralized}.

\paragraph{Worked Agent Example (Code Review Gate).}
Suppose three code-generation workers each draft part of a deployment change, and a release gate accepts the merged result. If each worker has error rate $p=0.1$, an ungated independent aggregate fails with probability $1-(1-0.1)^3 = 0.271$, so $A_{\otimes}=2.71$. If a central reviewer catches half of all worker errors ($d=0.5$), then the centralized failure rate becomes $1-(1-0.1(1-0.5))^3 \approx 0.143$, so $A_{\circ}\approx 1.43$. The reviewer does not eliminate risk, but it roughly halves amplification.

\begin{theorem}[Sequential Coordination Penalty]
\label{thm:sequential-penalty}
For a task with $k$ strictly ordered steps decomposed across $n$ agents, each inter-agent handoff must at minimum establish $K_{\mathrm{receiver}}(\mathrm{result}_j)$. The overhead is:
\begin{enumerate}[leftmargin=*]
\item[(a)] \textbf{Single agent:} $K_i(\mathrm{result}_j)$ is trivially satisfied (the agent computed it). Total cost $= k \cdot c_{\mathrm{step}}$.
\item[(b)] \textbf{Multi-agent:} Each of $h \le k-1$ handoffs incurs communication cost $c_{\mathrm{comm}}$ and \textbf{epistemic reconstruction loss}:
\begin{equation}
\Delta I_j = I(S_{\mathrm{sender}}; r_j) - I(\mathrm{obs}_{\mathrm{receiver}}(S_{\mathrm{sender}}); r_j)
\label{eq:epistemic-reconstruction-loss}
\end{equation}
which is nonnegative by data processing, and is strictly positive whenever the handoff map is lossy on the task-relevant support.
\end{enumerate}
\end{theorem}

\paragraph{Assumptions.}
The task is strictly sequential, so later steps depend on earlier results; each handoff transmits only a summary of the sender's relevant state; and the receiver must reconstruct enough of that state to continue execution.

\paragraph{Operational takeaway.}
For agent designers, this is the warning against gratuitous decomposition: a sequential pipeline only benefits from multiple agents if a handoff creates new observations or new capabilities. Otherwise the system just pays communication cost plus lossy-summary cost.

\begin{proof}[Proof sketch]
\textbf{Part (a).} A single agent executing all $k$ steps maintains coalgebraic state $S = (L, \mathcal{R})$ throughout. After computing step $j$, the result $r_j$ is stored in that agent's own local state / readout, so no inter-agent communication is required to reuse it at step $j+1$. Hence $K_i(r_j)$ holds without handoff cost. The total cost is exactly $k \cdot c_{\mathrm{step}}$.

\textbf{Part (b).} When step $j$ is performed by agent $a$ and step $j+1$ by agent $b$, establishing $K_b(r_j)$ requires transmitting enough information about $r_j$ across a wire $w: a \to b$. The receiver's observation is $\mathrm{obs}_b(s) = \mathrm{optic}_w(\pi_w(s))$, which maps the sender's full state through the wire's optic. By the data processing inequality applied to the Markov chain $S_a \to \mathrm{obs}_b(S_a) \to \hat{r}_j$ (where $\hat{r}_j$ is the receiver's reconstruction):
\[
I(\mathrm{obs}_b(S_a); r_j) \le I(S_a; r_j) = H(r_j)
\]
with equality iff the wire is lossless for the task-relevant signal ($\mathrm{optic}_w \circ \pi_w$ is a sufficient statistic for $r_j$ on the relevant support). Therefore $\Delta I_j \ge 0$, with strict inequality whenever the handoff is lossy. Finite context windows make such lossy handoffs typical, though not logically unavoidable.

Each of $h$ handoffs incurs: (i) communication cost $c_{\mathrm{comm}}$ for message construction and parsing, and (ii) reconstruction cost $c_{\mathrm{recon},j}$ proportional to $\Delta I_j$, as the receiver must expend reasoning tokens to compensate for the missing context. The total multi-agent cost is:
\[
C_{\mathrm{multi}} = k \cdot c_{\mathrm{step}} + \sum_{j=1}^{h} \bigl(c_{\mathrm{comm}} + c_{\mathrm{recon},j}\bigr)
\]
The overhead ratio $(C_{\mathrm{multi}} - C_{\mathrm{single}})/C_{\mathrm{single}} = \sum_j (c_{\mathrm{comm}} + c_{\mathrm{recon},j}) / (k \cdot c_{\mathrm{step}})$ grows with $h$ and with the typical per-handoff information loss $\Delta I_j$. When lossy handoffs accumulate, reconstruction failures at step $j$ degrade the input quality for step $j+1$, so later handoffs operate on progressively more compressed representations and can exhibit superadditive degradation.
\end{proof}

\paragraph{Empirical Calibration.} Kim et al.~\cite{kim2025scaling} report that PlanCraft degrades under every multi-agent topology, from $-39.1\%$ (Hybrid) to $-70.1\%$ (Independent) relative to SAS, and attribute this to artificial decomposition of a strictly sequential task into redundant coordination steps. This is qualitatively consistent with the theorem: when handoffs add communication and reconstruction without creating new task-relevant observations, manufactured $K_{\mathrm{receiver}}$ is pure cost. The paper does not separately estimate $c_{\mathrm{comm}}/c_{\mathrm{step}}$ or $\Delta I_j$, so these quantities should be read as explanatory variables rather than fitted benchmark parameters.

\paragraph{Worked Agent Example (Bug-Fix Relay).}
Consider a three-step bug-fix task: interpret the failing test, locate the root cause, and write the patch. A single coding agent pays $3c_{\mathrm{step}}$. If the task is split across planner/debugger/patcher with $h=2$ handoffs, $c_{\mathrm{step}}=100$ tokens, $c_{\mathrm{comm}}=25$, and reconstruction cost $c_{\mathrm{recon}}=20$ per handoff, then $C_{\mathrm{single}}=300$ while $C_{\mathrm{multi}}=3\cdot100+2\cdot(25+20)=390$. Unless one specialist contributes genuinely new observations or capabilities, the decomposition is net overhead.

\begin{theorem}[Parallel Acceleration under Epistemic Independence]
\label{thm:parallel-acceleration}
A task decomposes into $m$ subtasks. Define two subtasks as \textbf{epistemically independent} iff neither's solution requires knowledge of the other's result: $\neg(K_i(\varphi_j) \text{ is a precondition for solving subtask } i)$.
\begin{enumerate}[leftmargin=*]
\item[(a)] Under full epistemic independence with centralized coordination, the speedup is:
\begin{equation}
S = \frac{\sum_{i=1}^{m} c_{\mathrm{sub}_i}}{\max_i(c_{\mathrm{sub}_i}) + c_{\mathrm{assign}} + c_{\mathrm{agg}}}
\label{eq:parallel-speedup}
\end{equation}
where $c_{\mathrm{assign}}$ is the coordinator's distribution cost and $c_{\mathrm{agg}}$ is aggregation cost. With equal subtasks, $S \approx m$ minus coordinator overhead.
\item[(b)] For propositions determined solely by the tuple of worker outputs, the coordinator attains the corresponding pooled-output knowledge at aggregation as an architectural byproduct---it must receive all outputs to combine them. Error detection (Theorem~\ref{thm:error-amplification}) comes free.
\item[(c)] \textbf{Epistemic ceiling:} If subtasks are only partially independent---$I(\varphi_i; \varphi_j) > 0$---then parallel execution sacrifices solution quality proportional to the unresolved mutual information.
\end{enumerate}
\end{theorem}

\paragraph{Assumptions.}
Subtasks can be assigned independently, the coordinator's assignment and aggregation costs are additive overhead terms, and no hidden blocking dependency forces a worker to wait for another worker's intermediate result.

\paragraph{Operational takeaway.}
This is the positive case for multi-agent systems: if subtasks can be solved from local observations alone, then specialization plus a coordinator can reduce wall-clock cost and often improve quality. If subtasks share unresolved dependencies, parallelism turns into premature decomposition.

\begin{proof}[Proof sketch]
\textbf{Part (a).} Let subtasks $\varphi_1, \ldots, \varphi_m$ be epistemically independent: for all $i \ne j$, agent $i$ can achieve $K_i(\varphi_i)$ from $\mathrm{obs}_i$ alone without requiring $K_i(\varphi_j)$. Formally, let $f_i^*$ denote the optimal solution function for subtask $i$. Epistemic independence means $f_i^*$ depends only on the initial task description and agent $i$'s local observations: $f_i^*(s) = f_i^*(\mathrm{obs}_i(s))$ for all global states $s$.

Under parallel execution, all $m$ subtasks run concurrently. The wall-clock cost is determined by the slowest subtask plus coordination overhead: $C_{\mathrm{parallel}} = \max_i(c_{\mathrm{sub}_i}) + c_{\mathrm{assign}} + c_{\mathrm{agg}}$. Sequential execution by a single agent costs $C_{\mathrm{sequential}} = \sum_{i=1}^m c_{\mathrm{sub}_i}$. The speedup $S = C_{\mathrm{sequential}}/C_{\mathrm{parallel}}$ yields the stated formula. With equal subtask costs, $C_{\mathrm{sequential}} = m \cdot c_{\mathrm{sub}}$ and $C_{\mathrm{parallel}} = c_{\mathrm{sub}} + c_{\mathrm{assign}} + c_{\mathrm{agg}}$, so $S = m \cdot c_{\mathrm{sub}} / (c_{\mathrm{sub}} + c_{\mathrm{assign}} + c_{\mathrm{agg}}) \approx m$ when coordinator overhead is small relative to subtask cost.

\textbf{Part (b).} The coordinator receives all $m$ outputs $(o_1, \ldots, o_m)$ as part of the aggregation step. Assume each worker's relevant local observation for aggregation is its own result $o_j$. Then the pooled worker-output partition is generated by the tuple $(o_1, \ldots, o_m)$, and the hub observes that tuple directly: $\mathrm{obs}_{\mathrm{hub}}(s) \supseteq (o_1, \ldots, o_m)$. Therefore for any proposition $\varphi$ measurable with respect to the worker-output tuple, $D_G(\varphi) \Rightarrow K_{\mathrm{hub}}(\varphi)$. Error detection from Theorem~\ref{thm:error-amplification}(b) follows because the hub can cross-check outputs at no additional communication cost.

\textbf{Part (c).} When $I(\varphi_i; \varphi_j) > 0$, the optimal solution $f_i^*$ depends on the value of $\varphi_j$: there exist global states $s, s'$ with $\mathrm{obs}_i(s) = \mathrm{obs}_i(s')$ but $f_i^*(s) \ne f_i^*(s')$, because the states differ in $\varphi_j$ which affects $\varphi_i$'s optimal answer. Under independent execution, agent $i$ cannot distinguish $s$ from $s'$ and must choose a single action, incurring expected quality loss proportional to $I(\varphi_i; \varphi_j)$---the unresolved mutual information between subtask solutions.
\end{proof}

\paragraph{Empirical Calibration.} Kim et al.'s Finance-Agent traces show at least three largely separable workstreams---regulatory/news analysis, SEC filing research, and operational-impact assessment---handled by three sub-agents plus an orchestrator \cite{kim2025scaling}. Centralized MAS improves benchmark success from $0.349$ to $0.631$ ($+80.8\%$), which is qualitatively consistent with the theorem's decomposable-task regime. But the reported $+80.8\%$ is a success-rate improvement, not a direct measurement of the speedup $S$ in Eq.~\eqref{eq:parallel-speedup}; it should therefore be interpreted as evidence that approximate epistemic independence can improve solution quality, not as a literal estimate of wall-clock acceleration.

\paragraph{Worked Agent Example (Due-Diligence Swarm).}
Suppose an orchestrator assigns three largely independent subtasks for a vendor assessment: legal review, security posture, and cost modeling. If each subtask costs about $8$ minutes of agent time and assignment plus aggregation costs $2$ minutes total, then
\[
S = \frac{8+8+8}{8+2} = 2.4.
\]
The coordinator also receives all three outputs at aggregation, so cross-checking across the workstreams comes with little extra communication cost.

\begin{theorem}[Tool Density Scaling]
\label{thm:tool-density}
Consider $t$ tools distributed across $n$ agents, with $|T_i| = t/n$ tools per agent (balanced partition).
\begin{enumerate}[leftmargin=*]
\item[(a)] \textbf{Single agent:} The agent's observation partition over tool outputs is unified. Planning cost is $O(t)$ per step (linear scan of tool descriptions in context).
\item[(b)] \textbf{Multi-agent:} When agent $i$ needs a tool in $T_j$ ($j \ne i$), it must first know the tool exists ($K_i(T_j \ni \mathrm{tool}_k)$), then request execution, then interpret the result with information loss $\Delta I$ (Eq.~\eqref{eq:epistemic-reconstruction-loss}). The coordination overhead per step scales as:
\begin{equation}
C_{\mathrm{coord}} = O\!\left(t \cdot \left(1 - \frac{|T_i \cap T_{\mathrm{needed}}|}{|T_{\mathrm{needed}}|}\right) \cdot c_{\mathrm{comm}}\right)
\label{eq:tool-coord-overhead}
\end{equation}
which approaches $O(t \cdot c_{\mathrm{comm}})$ as $t$ grows for any fixed partition.
\item[(c)] \textbf{Cross-agent planning overhead:} Agent $i$ must reason about remote tool capabilities---$K_i(K_j(\mathrm{tool}_k \text{ can solve subproblem}))$---a second-order epistemic query. This scales as $O(t \cdot n)$ in the worst case:
\begin{equation}
C_{\mathrm{plan}} = O(t \cdot n) \gg O(t)
\label{eq:tool-planning-cost}
\end{equation}
yielding a multiplicative $n$-factor over the single-agent baseline and bilinear growth when both $t$ and $n$ increase.
\end{enumerate}
\end{theorem}

\paragraph{Assumptions.}
Tools are partitioned approximately evenly across agents, remote tool use requires explicit discovery and delegation, and the planner may in the worst case need to reason over every tool-agent pairing relevant to the current subgoal.

\paragraph{Operational takeaway.}
For agentic tool systems, splitting a toolset across agents changes one local decision into three coordination steps: discover who has the tool, delegate execution, then interpret the returned result without the executor's full context. That is why tool-heavy tasks often punish over-distribution.

\begin{proof}[Proof sketch]
\textbf{Part (a).} A single agent holds all $t$ tools in its context. Its observation function $\mathrm{obs}(s) = (o_1(s), \ldots, o_t(s))$ covers all tool outputs. At each planning step, the agent selects the next tool by scanning descriptions in context. This is a linear search over $t$ candidates: each tool description must be evaluated against the current subgoal, yielding $O(t)$ planning cost per step.

\textbf{Part (b).} With $n$ agents and a balanced partition $T_1, \ldots, T_n$ where $|T_i| = t/n$, agent $i$'s observation function covers only $T_i$'s outputs: $\mathrm{obs}_i(s) = (o_k(s))_{k \in T_i}$. When agent $i$ needs tool $k \in T_j$ ($j \ne i$), three epistemic gaps must be bridged:

\begin{enumerate}
\item \textbf{Discovery:} Agent $i$ must establish $K_i(\exists k \in T_j : k \text{ solves subproblem})$. Since $k \notin T_i$, this requires communication---agent $i$ cannot determine tool $k$'s existence from $\mathrm{obs}_i$ alone. There exist global states $s, s'$ where $\mathrm{obs}_i(s) = \mathrm{obs}_i(s')$ but $T_j$ differs, so $s \sim_i s'$ yet the available remote tools are different.
\item \textbf{Delegation:} Agent $i$ must transmit the subproblem context to agent $j$ and receive the result, incurring communication cost $c_{\mathrm{comm}}$ per remote tool invocation.
\item \textbf{Reconstruction:} Agent $j$'s output $o_k$ is interpreted by $i$ without $j$'s full execution context. By the data processing inequality, $I(\text{subproblem}; o_k|_{\mathrm{received}}) \le I(\text{subproblem}; o_k|_{\mathrm{full context}})$, yielding information loss $\Delta I \ge 0$.
\end{enumerate}

The fraction of tools requiring remote access is $1 - |T_i \cap T_{\mathrm{needed}}|/|T_{\mathrm{needed}}|$. For each remote tool, the coordination cost is $c_{\mathrm{comm}}$. Over all $t$ potentially needed tools, the total coordination overhead is:
\[
C_{\mathrm{coord}} = t \cdot \left(1 - \frac{|T_i \cap T_{\mathrm{needed}}|}{|T_{\mathrm{needed}}|}\right) \cdot c_{\mathrm{comm}}.
\]
As $t$ grows with fixed $n$ and balanced partitions, the local coverage fraction $|T_i|/t = 1/n$ is constant, so the remote fraction approaches $(n-1)/n$ and $C_{\mathrm{coord}} \to O(t \cdot c_{\mathrm{comm}})$.

\textbf{Part (c).} Planning requires not just first-order knowledge of tool outputs but second-order knowledge of other agents' capabilities. Specifically, to construct a multi-step plan, agent $i$ must evaluate propositions of the form $K_i(K_j(\mathrm{tool}_k \text{ can solve subproblem } \varphi))$---``I know that agent $j$ knows that tool $k$ is applicable.''

Consider the Kripke structure. For agent $i$ to establish $K_i(K_j(\varphi))$, we need: for all $s'$ with $s \sim_i s'$, and for all $s''$ with $s' \sim_j s''$, $\varphi$ holds at $s''$. Agent $i$ must reason over $j$'s indistinguishability classes, which requires a model of $j$'s observation partition. This model has size $O(|T_j|) = O(t/n)$ per agent. Since $i$ must model all $n-1$ remote agents, the total planning state is $O((n-1) \cdot t/n) = O(t)$ per planning step---but each model must be queried against each candidate tool, yielding $O(t \cdot n)$ comparisons in the worst case (when the planner considers all tools across all agents for each subgoal).

Contrast with the single-agent case: planning cost is $O(t)$ (linear scan, no modeling of other agents' capabilities). The multi-agent case introduces a multiplicative factor of $n$ from the second-order epistemic reasoning, so $C_{\mathrm{plan}} = O(t \cdot n)$. For fixed $n$, this is still linear in $t$ but with a larger constant; when $t$ and $n$ grow jointly it becomes bilinear in the two scaling parameters. This explains why increasing tool density in multi-agent systems can produce disproportionate overhead that may negate parallelism benefits.
\end{proof}

\paragraph{Empirical Calibration.} In Kim et al.'s setup, the tool-heavy Workbench domain uses $T = 16$ tools and most MAS configurations use $n = 3$ agents \cite{kim2025scaling}. Under a balanced partition, each agent directly holds only about $T/n \approx 5$ tools, so roughly two-thirds of tool access is remote. The second-order planning term therefore scales from $O(16)$ in SAS to roughly $O(48)$ cross-agent capability checks in the balanced three-agent case. Kim et al. report a strong negative efficiency--tool interaction ($\hat{\beta}_{E_c \times T} = -0.267$, $p < 0.001$), which is consistent with this combinatorial tax. Their results also show that the penalty is topology-dependent rather than absolute: Centralized and Hybrid underperform on Workbench, while Decentralized remains slightly above SAS ($+5.7\%$), so high tool count stresses coordination but does not universally eliminate multi-agent value. In the low-tool regime discussed in the paper ($T \le 4$), the efficiency interaction is negligible.

\paragraph{Worked Agent Example (Tool-Split SWE Agent).}
Imagine a software-engineering assistant with $18$ tools split across $3$ agents: one owns search tools, one owns git and test tools, and one owns deployment tools. A planner diagnosing a failing CI job directly holds only $6$ tools and must treat the remaining $12$ as remote. The planning problem therefore expands from ``which of $18$ tools should I call next?'' to ``which agent owns the relevant tool, how do I route the subproblem, and how do I interpret the result without that agent's full execution context?'' That is the $O(tn)$ tax in operational form.

\paragraph{Summary: Empirical Validation.}
Table~\ref{tab:epistemic-predictions} summarizes the qualitative correspondence between the theoretical predictions and Kim et al.'s empirical findings across 180 agent configurations \cite{kim2025scaling}.

\begin{table}[h]
\centering
\small
\begin{tabular}{@{}p{0.18\textwidth}p{0.20\textwidth}p{0.25\textwidth}p{0.25\textwidth}@{}}
\toprule
\textbf{Topology} & \textbf{Epistemic Property} & \textbf{Prediction} & \textbf{Observed} \\
\midrule
Independent ($\otimes$) & No inter-agent $K_i$ & Highest error amplification & Architecture-level $A_e = 17.2$ \\
Centralized ($\circ$+hub) & Hub pools worker outputs & Validation bottleneck lowers amplification & Architecture-level $A_e = 4.4$ \\
Multi-agent + sequential & Requires manufactured $K_{\mathrm{receiver}}$ & Strictly sequential tasks degrade under handoffs & PlanCraft: $-39.1\%$ to $-70.1\%$ vs.\ SAS \\
Multi-agent + parallel & Approximate epistemic independence & Large gains on decomposable tasks & Finance-Agent Centralized: $+80.8\%$ vs.\ SAS \\
Multi-agent + high $|T|$ & Knowledge fragmentation & Coordination tax grows with $t$ and $n$ & Workbench $T=16$; $\hat{\beta}_{E_c \times T} = -0.267$ \\
\bottomrule
\end{tabular}
\caption{Epistemic predictions vs.\ empirical observations from Kim et al.~\cite{kim2025scaling}. The table compares topology-level qualitative predictions to the paper's architecture-level metrics. Reported percentages and error-amplification factors are empirical aggregates, not literal plug-in values of the simplified theorem parameters.}
\label{tab:epistemic-predictions}
\end{table}

\begin{center}
\fbox{%
\begin{minipage}{0.94\linewidth}
\textbf{Design Implications for Agent Architects.}
\begin{enumerate}[leftmargin=*]
\item Use a reviewer or hub when multiple workers can independently introduce high-cost errors. The gain comes from visibility and suppression, not from agent count alone.
\item Keep strictly sequential reasoning in one agent unless a handoff adds a genuinely new capability, observation source, or trust level.
\item Use specialist swarms for decomposable tasks only when coordinator overhead is small relative to subtask cost and the subtasks are close to conditionally independent.
\item Avoid fragmenting large toolsets across many agents unless tool routing is a first-class design problem. Otherwise, remote-tool discovery and second-order planning will dominate.
\item Treat topology as a runtime policy, not a fixed ideology. When observed task structure shifts from sequential to parallel or from low-risk to high-risk, the coordination pattern should shift with it.
\end{enumerate}
\end{minipage}}
\end{center}

\subsubsection{Epistemic Dynamics and Adaptive Topology}

The preceding theorems treat topology as fixed. In practice, the Operon framework supports \textbf{dynamic topology switching}---morphogen gradients (Eq.~\eqref{eq:morphogen-diffusion}) can trigger reorganization at runtime. We connect this to the epistemic formalization.

The Epiplexity monitor ($\hat{\mathcal{E}}_t$, Eq.~\eqref{eq:epiplexity-approx}) can be reinterpreted as a heuristic proxy for \emph{finite-horizon} epistemic stagnation. Define
\begin{equation}
\mathrm{Stagnant}_i^{(h)}(\varphi) := \neg K_i(\varphi) \wedge \neg \Diamond_{\le h} K_i(\varphi)
\label{eq:epistemic-starvation}
\end{equation}
where $\Diamond_{\le h}$ means ``reachable within $h$ coordination rounds under the current topology.'' Low epiplexity does not \emph{prove} this modal condition, but it provides an operational signal that the current wiring is failing to generate new task-relevant observations. This is precisely the regime in which topology switching is warranted: the current wiring diagram's epistemic capacity is insufficient for the task.

Morphogen-driven adaptation then becomes \textbf{epistemic optimization}: the system senses when its topology's knowledge properties are mismatched to the task and restructures accordingly. An independent topology ($\otimes$) failing on a sequential task triggers convergence to centralized coordination ($\circ$); a centralized topology bottlenecking on a parallelizable task triggers distribution to independent execution. This is the adaptive capability that purely empirical approaches \cite{kim2025scaling} identify as necessary but cannot yet provide---biological systems have evolved it as homeostatic regulation; the Operon framework operationalizes it through the morphogen-epiplexity coupling.

Recent work on unifying epistemic and temporal logic for distributed system verification \cite{davis2026reasoning} suggests that these dynamic epistemic properties may be mechanically verifiable, opening a path toward formally certified adaptive agent topologies.

\subsection{Bioenergetic Intelligence: Beyond the Battery Metaphor}

Recent work in mitochondrial psychobiology \cite{allen2022energy, picard2022signaling} challenges the view of
mitochondria as passive energy sources. They function as ``social signaling organelles'' that actively participate
in cellular decision-making. This refines our Isomorphism:
\begin{itemize}[leftmargin=*]
\item \textbf{Mitochondrial Sociality $\to$ Context Fusion:} Just as mitochondria fuse to share resources under
stress, resource-constrained agents should implement \textbf{Context Fusion}---merging sparse Epigenetic States
into a shared summary to survive ``Token Ischemia.''
\item \textbf{Energy as Attention:} The Agentic Runtime does not merely limit the chain-of-thought, but actively
\textit{directs} it. High-energy states permit ``Exploratory'' reasoning (Divergent), while low-energy states
force ``Consolidatory'' reasoning (Convergent). The Metabolic Coalgebra is a \textbf{Cognitive Control Policy}.
\end{itemize}

\subsubsection{The Vermeij Trend: Why Agents Must Evolve}

Finally, we situate this architecture within the broader history of complexity. Geerat Vermeij \cite{vermeij2023power}
argues that evolution is driven by the maximization of \textbf{Power}---the rate at which a system acquires and
applies energy. Life has consistently trended from low-power states (anaerobic bacteria) to high-power states
(endothermic mammals) by internalizing energy production (endosymbiosis).

We observe an identical trend in AI. The shift from ``Generative AI'' (Zero-Shot) to ``Agentic AI'' (Chain-of-Thought)
is a shift from low-metabolism to high-metabolism architectures. However, Vermeij notes that high power requires
high structural integrity; a system that amplifies energy without proper constraints self-destructs.

\textbf{The Competitive Dynamics.} Vermeij's argument is about \textit{escalation}: competitive pressure
between predators and prey drives both toward higher power. What is the analogue in agentic AI?

We identify three sources of selective pressure:
\begin{enumerate}[leftmargin=*]
\item \textbf{Adversarial Robustness (Predator-Prey):} Prompt injection attacks, jailbreaks, and adversarial
inputs act as ``predators'' that exploit agent vulnerabilities. Agents that survive deployment develop
``immune systems'' (the Adaptive Immunity motif). This is a direct Red Queen dynamic: attackers evolve new
injection techniques; defenders evolve new detection mechanisms. The CFFL and Trust-Gated Lens are
``armor'' adaptations.

\item \textbf{Task Complexity (Environmental Pressure):} Users demand agents that can handle increasingly
complex, multi-step tasks. Simple prompt-response systems (``anaerobic'') cannot compete with agentic
systems that chain reasoning, use tools, and maintain state (``aerobic''). This is analogous to the
oxygen revolution: organisms that could exploit the new energy source (aerobic respiration) outcompeted
those that could not.

\item \textbf{Resource Efficiency (Metabolic Selection):} Token costs and latency create selection pressure
for efficient architectures. Agents that accomplish tasks with fewer tokens (higher metabolic efficiency)
are deployed more widely. The Metabolic Coalgebra provides the formal framework for this optimization:
systems evolve toward the Pareto frontier of capability vs. resource consumption.
\end{enumerate}

\textbf{The Cambrian Parallel.} The progression from prompt engineering to agentic engineering mirrors the
Cambrian explosion: a sudden increase in metabolic capability (LLM reasoning power) that enables new
``body plans'' (agent architectures). The Cambrian saw the emergence of eyes, shells, and predation---all
requiring sophisticated metabolic support. Similarly, agentic AI sees the emergence of tool use, planning,
and adversarial robustness---all requiring the structural integrity that the Operon framework provides.

The prediction is clear: agent architectures that lack proper metabolic regulation, immune defense, and
homeostatic mechanisms will be outcompeted by those that possess them. The Operon framework is not merely
a safety feature; it is the necessary evolutionary adaptation---the ``vascularization'' of software---that
enables high-power cognition to function without collapsing into incoherent noise (thermodynamic death).

\subsubsection{Immune Evasion and Adversarial Limits}

No static defense is perfect against adaptive attackers. Biology faces this reality: pathogens evolve
to evade immune detection (antigenic drift, molecular mimicry, immunosuppression). The same dynamics
apply to agentic security.

\textbf{Evasion Vectors.} An adversary who understands the defense layers can craft inputs that:
\begin{itemize}[leftmargin=*]
\item Pass innate filters by avoiding known PAMP signatures (novel injection syntax)
\item Evade provenance checks by exploiting trusted channels (tool poisoning)
\item Fool T-cell detection by mimicking normal behavioral distributions (low-and-slow attacks)
\end{itemize}

\textbf{Mitigation Strategies.} Biology's answer is continuous adaptation:
\begin{itemize}[leftmargin=*]
\item \textbf{Signature Updates:} Innate PAMP databases must be continuously updated as new attack
patterns are discovered (analogous to antiviral signature updates).
\item \textbf{Thymic Retraining:} Baseline behavioral profiles should be periodically refreshed,
especially after system updates that legitimately change agent behavior.
\item \textbf{Immune Memory Sharing:} Threat signatures discovered by one deployment should propagate
to others (analogous to herd immunity via shared threat intelligence).
\item \textbf{Diversity:} Heterogeneous defenses (different filter implementations, multiple verifier
models) reduce the probability of universal evasion.
\end{itemize}

The honest conclusion is that security is a process, not a product. The Operon framework provides the
\textit{architecture} for defense-in-depth, but the \textit{content} of that defense (specific patterns,
behavioral baselines, trust policies) must evolve with the threat landscape.
