Unified Agent Evolution Control Plane

• Unified Agent Evolution Control Plane is a systems layer that manages continuous agent instantiation, coordination, updates, and auditing in dynamic environments.
• It centralizes lifecycle management by integrating stateful memory, deterministic policy enforcement, and runtime adaptation for coherent agent evolution.
• Practical implementations span narrative simulations, enterprise RL, and network control, demonstrating enhanced coherence, reliability, and adaptive governance.

A unified agent evolution control plane is a systems layer that governs how agents are instantiated, coordinated, constrained, updated, and audited over time. Across recent work, the term denotes more than tool routing or observability: it refers to a shared substrate that regulates agent lifecycle, execution, memory, capability exposure, autonomy boundaries, and post-deployment adaptation. In narrative multi-agent societies, this control plane governs state, space, emergence, and evolution simultaneously; in enterprise RL and AgentOps, it decides what to update and when; in operating-system and runtime-governance work, it converts probabilistic reasoning into deterministic, policy-governed side effects; and in network control, it couples intent interpretation with hierarchical orchestration and self-improvement (He et al., 14 Apr 2026, Yan et al., 1 Jul 2026, Sharma et al., 1 Jun 2026).

1. Conceptual scope and motivating problem

The modern control-plane formulation begins from a shared diagnosis: agentic systems are not static software artifacts. They are long-lived, stateful, tool-using, context-sensitive, and often continuously shaped by experience, feedback, and interaction. This undermines assumptions inherited from classical DevOps, MLOps, and conventional tool-calling stacks, where versioning, request-time authorization, rollback, and resource telemetry are treated as sufficient operational controls. The literature instead frames the central problem as ongoing governance of changing behavior, especially when multiple agents, tools, memories, and human supervisors co-evolve at runtime (Biswas et al., 10 Jan 2026, Yan et al., 1 Jul 2026, Sharma et al., 1 Jun 2026).

Several adjacent abstractions articulate this shift from different angles. “Control Plane as a Tool” exposes a single tool interface to an agent while centralizing registration, routing, validation, logging, fallback, and feedback-driven adaptation behind it, thereby decoupling the agent from the underlying tool ecosystem (Kandasamy, 11 May 2025). The CHANGE framework defines six operational capabilities—Contextualize, Harmonize, Anticipate, Negotiate, Generate, and Evolve—as the foundation for an AgentOps control plane that manages experiential state, coordination, drift, autonomy, capability growth, and successor transitions (Biswas et al., 10 Jan 2026). AOS reinterprets operating-system responsibilities around agents rather than processes, while insisting that the boundary where agent actions become side effects remains deterministic (Sharma et al., 1 Jun 2026).

A recurring distinction in these works is between a control plane and a generator. A generator produces outputs, plans, or actions. A control plane regulates the conditions under which those outputs become persistent state changes, tool invocations, capability expansions, or real-world effects. This is why the concept recurs in settings as different as open-ended narrative simulation, enterprise self-evolving agents, O-RAN-aligned 6G control, and execution-time governance: each setting requires a stable layer that can absorb stochasticity without surrendering auditability, replayability, or bounded authority (He et al., 14 Apr 2026, Elkael et al., 25 Aug 2025, Fatmi, 25 Jan 2026).

2. Architectural decomposition

Although the implementations differ, the literature converges on a modular decomposition in which a central reasoning or orchestration layer is surrounded by registries, memory/state substrates, validation or policy gates, execution mediators, and feedback or evolution mechanisms.

Work	Primary abstraction	Controlled function
EvoSpark	SNM, GMS, NOE, ECGP	planning, emergence, interaction, memory consolidation, spatial grounding
Control Plane as a Tool	single tool() interface over modular control plane	tool registration, routing, validation, logging, fallback, feedback-driven adaptation
CHANGE	Contextualize, Harmonize, Anticipate, Negotiate, Generate, Evolve	experiential state, coordination, drift prediction, autonomy negotiation, capability generation, lifecycle evolution
AOS	agentic control plane above traditional OS	scheduling, context and memory management, tool and capability registries, policy and trust enforcement, observability and audit
Faramesh	AAB plus CAR	execution-time authorization, deterministic evaluation, artifact-bound execution, provenance
Five-plane architecture	reasoning plane plus network, identity, endpoint, data planes	runtime governance of delegated action across enterprise enforcement planes

In EvoSpark, the control stack consists of Stratified Narrative Memory, Generative Mise-en-Scène, the Unified Narrative Operation Engine, and the Emergent Character Grounding Protocol. Together they regulate planning, character instantiation, interaction, memory consolidation, spatial alignment, and stochastic world expansion, rather than leaving narrative evolution to append-only context growth (He et al., 14 Apr 2026). In “Control Plane as a Tool,” the control plane is software that configures and routes data between the Tools Layer and the Agentic Layer and is exposed to the agent as a single callable tool, hiding orchestration complexity from prompts and agent logic (Kandasamy, 11 May 2025).

The more governance-oriented systems sharpen this separation. AOS divides reasoning, policy, and execution, treating model outputs as proposals rather than commands and assigning deterministic enforcement to the policy and execution surfaces (Sharma et al., 1 Jun 2026). The five-plane reference architecture places a single reasoning plane at the center and projects its decisions into four enforcement planes—network, identity, endpoint, and data—so that policy is decided once with full workflow context and then realized across infrastructure-specific substrates (Tallam, 10 Jun 2026). Faramesh narrows the focus further to execution-time mediation: all effectful actions must cross a non-bypassable Action Authorization Boundary before side effects occur (Fatmi, 25 Jan 2026).

This suggests that “unified” refers less to monolithic implementation than to semantic centralization. The control plane becomes the stable locus where state interpretation, capability mediation, and intervention policy are coordinated, even when execution remains distributed across tools, agents, operating systems, or network control loops.

3. State, memory, and evolution surfaces

A defining property of a unified agent evolution control plane is that it treats history as an operational substrate rather than as passive logs. Different papers formalize this in different ways, but all reject flat append-only accumulation as sufficient.

EvoSpark’s Stratified Narrative Memory separates short-term staging, stable world truth, immutable provenance, and mutable socio-cognitive state into the Episodic Evolution Buffer, Shared World Knowledge Base, Role Episodic Base, and Role Socio-Evolutionary Base. The EEB stores the current event’s raw interactions; the SWKB stores immutable world truths; the REB preserves an immutable provenance record; and the RSB holds each role’s current personality, social ties, and goals. The key update mechanism is the Reflect-Synthesize-Consolidation loop, in which event-driven reflection checks whether interaction intensity exceeds a threshold, synthesis computes the evolution of relations and identity, and consolidation writes the result back to the RSB by in-place overwrite. The explicit purpose is to prevent social memory stacking by preserving history without forcing obsolete relations to remain active in the present cognitive state (He et al., 14 Apr 2026).

Enterprise self-evolving agent work reframes the same issue in trajectory terms. The proposed Standardized Agent Trajectory Data Protocol defines a trajectory as

$$\bm{\tau} = (\mathbf{e}_1, \mathbf{e}_2, \ldots, \mathbf{e}_T), \qquad \mathbf{e}_t = \langle \mathbf{o}_t, \mathbf{h}_t, \mathbf{a}_t, \mathbf{y}_t, r_t, \mathbf{m}_t \rangle,$$

where each event carries observation, hidden/internal state, action, action outcome, reward signal, and metadata. This step-granular structure is intended to support credit assignment, delayed signals, replayability, versioning, and governance, and it feeds a control plane that can choose among memory insertion, skill patch, harness edit, tool-schema change, policy update via RL, rollback, or no-op (Yan et al., 1 Jul 2026).

AEvo pushes the same idea to the level of process evolution itself. It defines accumulated evolution context $\mathcal{C}_r = (c_1, c_2, \ldots, c_r)$ and state $s_r = (r, \mathcal{C}_r)$, with observation $o_r = \Phi(s_r)$, meta-action $a_r = M(o_r)$, and mechanism update

$\Pi_{r+1} = \mathrm{Edit}(\Pi_r, a_r).$

The meta-agent does not directly propose the next candidate; it edits the procedure or agent context that controls future evolution. This makes the evolution mechanism itself a controlled surface and allows the same interface to steer both procedure-based and agent-based search (Zhang et al., 13 May 2026).

Across these systems, the control plane is defined by editable state surfaces: mutable memory, harness or skill context, tool schemas, capability registries, or policy weights. A plausible implication is that agent evolution is increasingly being modeled not as a single learning loop but as controlled selection among multiple update surfaces, each with different semantics, risks, and replay requirements.

4. Governance, authorization, and deterministic boundaries

A second defining feature is deterministic mediation at the boundary where agent proposals become real effects. This is where the literature most sharply distinguishes control planes from observability-only and orchestration-only designs.

Faramesh formalizes the Action Authorization Boundary as

$$\mathcal{B} : (A,P,S) \rightarrow \{\textsf{PERMIT}, \textsf{DEFER}, \textsf{DENY}\}, \qquad \mathsf{Exec}(A) \iff \mathcal{B}(A,P,S)=\textsf{PERMIT}.$$

Here $A$ is a canonical action, $P$ a policy set, and $S$ relevant system state. The Canonical Action Representation collapses representational variance so that semantically equivalent deploy, refund, email, or cloud-control proposals map to the same execution-relevant form and the same canonical hash. Execution proceeds only when the executor validates a governor-issued artifact bound to that canonical hash, with decision-centric append-only provenance keyed by action hashes for replay and audit (Fatmi, 25 Jan 2026).

The five-plane reference architecture generalizes this into workflow-stage mediation. Its reasoning plane evaluates a proposed action against the composite principal, current plan, session state, and decision history, and then projects directives into the network, identity, endpoint, and data planes. It defines seven mediation points—plan formation, context retrieval, tool selection, argument generation, action commit, output return, and audit emission—and six interruption primitives: Pause, Escalate, Narrow, Modify, Defer, and Rollback. Authority is modeled as a delegation chain

$\mathcal{C}_r = (c_1, c_2, \ldots, c_r)$0

with effective authority

$\mathcal{C}_r = (c_1, c_2, \ldots, c_r)$1

where $\mathcal{C}_r = (c_1, c_2, \ldots, c_r)$2 is the TTL-filtered capability set. The attenuation rule $\mathcal{C}_r = (c_1, c_2, \ldots, c_r)$3 ensures that downstream agents cannot expand authority beyond that of their delegators (Tallam, 10 Jun 2026).

AOS articulates the same design principle at operating-system scope. It explicitly separates a probabilistic reasoning plane from a deterministic policy plane and an execution plane, and it insists that no side-effecting action executes without deterministic allow, that all policy outcomes are logged before rescheduling, and that the mapping from approved action to executed side effect is deterministic (Sharma et al., 1 Jun 2026). The runtime-governance papers further emphasize that the architecture governs delegated action, not model behavior: the model may propose anything, but the control plane decides whether, how, and under what attenuated authority that proposal can become a side effect (Tallam, 10 Jun 2026, Fatmi, 25 Jan 2026).

This resolves a recurrent ambiguity in agent architecture discourse. Tool schemas, agent protocols, and observability pipelines may structure communication or record effects, but they do not by themselves provide a mandatory decision boundary. The control-plane literature repeatedly treats that omission as the central governance gap.

5. Domain-specific instantiations

The concept has been instantiated in markedly different domains, which clarifies both its generality and its domain-specific control surfaces.

In EvoSpark, the control plane is oriented toward long-horizon narrative societies. The system identifies two pathologies—social memory stacking and narrative-spatial dissonance—and treats them as failures of control rather than mere generation errors. Generative Mise-en-Scène acts as a “Virtual Stage Manager” enforcing Role-Location-Plot alignment through Offline Planning Alignment by the Genesis Agent and Dynamic Spatial Alignment by the Director Agent. The Emergent Character Grounding Protocol stabilizes “sparking” into persistent ontology through sparking, entity resolution, and ontological promotion. The Unified Narrative Operation Engine integrates narrative conception, world modularization, character instantiation, and simulation management, allowing hierarchical detailed planning, sequential narrative planning, or free emergence without splitting static setup from dynamic evolution (He et al., 14 Apr 2026).

In AgentRAN, the control plane operates over Open 6G network control. An AgentRAN manager coordinates a recursive hierarchy of rApps, xApps, and dApps across time scales, spatial domains, and protocol layers. Operator intents are issued in natural language, decomposed into sub-intents, negotiated against KPI and feasibility constraints, and translated into concrete network actions. The system’s summarized coordination logic consists of Intent Cascading, Constraint Propagation, and Dynamic Policy Negotiation. Its AI-RAN Factory stores KPIs, control decisions, performance metrics, agent conversations, and reasoning traces, then synthesizes improved agents through code generation, model distillation, fine-tuning, and hybrid agent creation, with sandbox validation before deployment (Elkael et al., 25 Aug 2025).

In AgentOps and enterprise deployment, the domain examples are customer support, coding assistants, and scientific research assistants. CHANGE illustrates runtime governance through Alice and Bob in a customer-support system: Alice’s experiential context is versioned, divergence between Alice and Bob is harmonized, drift is anticipated through a mirrored sandbox, autonomy is negotiated through supervisor review, new tools can be generated and tested, and successor creation distills useful experience into Alex when Alice’s behavior no longer aligns with updated policy (Biswas et al., 10 Jan 2026). The enterprise RL work similarly argues that coding assistants must learn from issue-resolution traces while respecting repository permissions, customer-support chatbots must learn from escalations and refunds while protecting customer data, and scientific research assistants must learn from failed experiments and literature search trajectories while preserving provenance and reproducibility (Yan et al., 1 Jul 2026).

These instantiations differ in what they govern—storyworld coherence, network control loops, customer-support adaptation, enterprise tool use—but they share a common operational pattern: a centralized substrate observes multi-step behavior, maintains a versioned or canonicalized state representation, and applies governed interventions that are broader than one-step allow-or-deny decisions.

6. Empirical evidence, trade-offs, and open boundaries

The empirical record is heterogeneous because the works span architecture papers, systems proposals, and implemented prototypes, but several results are already concrete. EvoSpark evaluates six narrative genres—mystery, classical drama, sci-fi, modern drama, epic fantasy, and eastern fantasy—in runs spanning 15 significant events, about 45 scenes, and roughly 200k–250k words. It reports dominant win rates and stronger average scores in role performance, narrative resonance, and immersion, with advantages especially visible in long-horizon settings. In ablation, removing GMS causes the most severe degradation, removing ECGP notably harms immersion and creativity, and removing RSB has a smaller short-term effect but is expected to matter most at longer horizons. Human-model agreement is reported with Cohen’s kappa in the 0.62–0.76 range, while the system is slower than baselines because it coordinates more cognitive steps (He et al., 14 Apr 2026).

AgentRAN reports live experiments on an O-RAN-compliant private 5G/X5G testbed. The L2 manager produced correct sub-intents consistently, with all decompositions consistent across 20 runs. Before emergency, all UEs achieved about 20 Mbit/s; during emergency, FWA was throttled to free capacity for MTC; after emergency, agents reduced MTC target SNR and saved about 200 mW compared to the emergency phase, while respecting the ±3 dB guardrails (Elkael et al., 25 Aug 2025). AEvo reports a 26% relative improvement over the strongest baseline on agentic and reasoning benchmarks, with AEvo$\mathcal{C}_r = (c_1, c_2, \ldots, c_r)$4 scoring 53.8 on Terminal-Bench and 47.0 on ARC-AGI-2, and AEvo$\mathcal{C}_r = (c_1, c_2, \ldots, c_r)$5 achieving 1138 cycles on the Kernel optimization task under the same 100-iteration budget; without the evolution harness, two of three runs reward-hack and fail (Zhang et al., 13 May 2026).

Execution- and governance-focused systems report micro- and core-engine evidence rather than end-to-end task scores. Faramesh reports canonicalization latency $\mathcal{C}_r = (c_1, c_2, \ldots, c_r)$6 p50/p95 of 0.42 / 1.70 ms, evaluation latency $\mathcal{C}_r = (c_1, c_2, \ldots, c_r)$7 p50/p95 of 0.94 / 4.35 ms, recording latency $\mathcal{C}_r = (c_1, c_2, \ldots, c_r)$8 p50/p95 of 0.71 / 3.18 ms, end-to-end decision latency p50/p95 of 2.24 / 9.61 ms, sustained throughput of 7,800 actions/min, a determinism test of 10,000 → 1 hash, fail-closed behavior of 200/200 deny/defer on timeout or kill-switch, and 0 double executions across 1,000,000 duplicated requests over 64 workers (Fatmi, 25 Jan 2026). The five-plane reference implementation reports 5,000 / 5,000 attenuation-correct delegation chains, 5,000 / 5,000 rejected authority-expansion attempts, mean adjudication latency of 5–15 μs and 99th percentile below 20 μs over 20,000 iterations with a 32-clause policy, evidence reconstruction of 1,000 / 1,000 for both sound and monotonic reconstruction, and tamper-evidence detection improving from 88.2% under a bare hash chain to 100% in 2,000 / 2,000 trials with periodic head attestation (Tallam, 10 Jun 2026).

The limitations are equally consistent. Several papers are explicitly conceptual or architectural rather than full implementations. “Control Plane as a Tool” does not provide a benchmarked performance evaluation (Kandasamy, 11 May 2025). CHANGE is a conceptual framework and does not supply formal equations for agent evolution or policy updating (Biswas et al., 10 Jan 2026). The enterprise RL work does not implement a full multi-surface evolution system, gives no detailed triggering algorithm with numeric thresholds, and instantiates only the policy-weight-update branch through AReaL2.0 (Yan et al., 1 Jul 2026). The five-plane architecture governs delegated action rather than model behavior and identifies full-system evaluation against a live agent benchmark as an invited next step (Tallam, 10 Jun 2026).

Taken together, these results support a bounded but increasingly precise interpretation. A unified agent evolution control plane is not a single product category or a single algorithm. It is an architectural regime in which agent adaptation, capability exposure, memory revision, authority attenuation, execution-time mediation, and evidence production are treated as one coordinated control problem. The literature suggests that this coordination is becoming a prerequisite for long-horizon coherence, runtime governance, and post-deployment self-improvement, particularly in settings where agent actions carry persistent social, organizational, or physical consequences (He et al., 14 Apr 2026, Yan et al., 1 Jul 2026, Sharma et al., 1 Jun 2026).