From Subsumption to Semantic Mediation: A Generative Orchestration Architecture for Autonomous Systems

Abstract

This paper extends Rodney Brooks’ subsumption architecture into the era of Agentic AI by replacing its priority arbiter with a Generative Orchestrator that performs semantic mediation—interpreting heterogeneous agent outputs and integrating them into a coherent action rather than merely arbitrating among them. Brooks’ original model (1986) demonstrated that autonomous behavior can emerge from parallel reactive layers without symbolic representation, establishing principles later recognized as foundational to agentic systems: environmental responsiveness, autonomy, and goal-directed action. Contemporary Agentic AI, however, requires capabilities beyond mechanical response—decision-making, adaptive strategy, and goal pursuit. We therefore reinterpret subsumption layers as four interacting agent types: reflex, model-based, goal-based, and utility-based, coordinated through semantic mediation. The Generative Orchestrator employs large language models not for content generation but for decision synthesis, enabling integrative agentic behavior. This approach merges real-time responsiveness with interpretive capacity for learning, reasoning, and explanation. An autonomous driving case study demonstrates how the architecture sustains behavioral autonomy while generating human-interpretable rationales for its actions. Validation was conducted through a Python-based proof-of-concept on an NVIDIA platform, reproducing the scenario to evaluate and confirm the architecture. This framework delineates a practical pathway toward advancing autonomous agents from reactive control to fully Agentic AI systems capable of operating in open, uncertain environments.

1. Introduction

Artificial intelligence is increasingly permeating critical domains where autonomous decision-making intersects with human safety, social norms, and ethical considerations. From healthcare diagnostics to financial trading, from manufacturing automation to transportation systems, AI agents are transitioning from controlled laboratory environments to complex real-world deployments where they must interact with humans and other systems. These dynamic and socially complex environments demand capabilities far beyond traditional approaches. Intelligent agents must demonstrate not only functional autonomy but also the ability to interpret context, adapt to unforeseen situations, and interact meaningfully with human stakeholders. Traditional multi-agent systems—grounded in symbolic logic, rule-based execution, and hierarchical coordination—struggle to maintain robustness, transparency, and ethical responsiveness in such settings. With the rise in generative artificial intelligence, a complementary paradigm is emerging in intelligent systems that do not merely solve problems but participate in meaning-making through epistemic collaboration, consistent with recent perspectives on AI as a partner in knowledge construction and decision-making.

The foundations for such autonomous, adaptive systems were laid decades ago by researchers who challenged the limitations of purely symbolic approaches. Among these pioneers, Rodney Brooks offered a particularly influential alternative that remains relevant to contemporary challenges.

Rodney Brooks’ subsumption architecture [1] represented a fundamental shift in how we conceptualize intelligent behavior. By demonstrating that complex behaviors could emerge from parallel reactive layers without centralized world models or symbolic representation, Brooks challenged the prevailing approaches of classical AI. His architecture, based on finite state machines coordinated via priority-based arbitration, proved remarkably effective for real-time robotic control in dynamic environments. This approach showed that intelligent behavior could arise from the interaction of simple, reactive modules—each directly coupling sensors to actuators—without the computational overhead of maintaining internal representations.

Brooks’ work can be seen as a precursor to modern Agentic AI (see [2,3,4]), in which systems autonomously pursue goals and make decisions without constant human intervention. His vision of “Creatures” that act independently in the world, adapting to their environment through behavioral intelligence, anticipated the current shift from Generative AI to Agentic AI. However, while Brooks demonstrated autonomous behavior through purely reactive mechanisms, contemporary agentic systems require additional capabilities: learning from experience, reasoning about future states, and explaining their decisions to human partners.

As autonomous systems evolve from laboratory demonstrations to social actors in human environments, the limitations of pure reactive control become evident. Modern applications such as autonomous vehicles navigating city streets, service robots in healthcare, and collaborative systems in manufacturing require capabilities beyond mechanical reaction. They must explain their decisions to users, adapt to novel situations through learning, and align their behavior with social norms and ethical principles. Recent critical examinations, such as Finelli’s analysis [5], acknowledge Brooks’ foundational contribution while questioning whether intelligence without representation suffices for tasks requiring memory, learning, and temporal reasoning.

The contemporary AI landscape reveals a fundamental distinction that illuminates our architectural contribution. While Generative AI that generate text, images, or code from prompts has dominated recent attention, a parallel paradigm is emerging: Agentic AI. Unlike generative systems that produce outputs in response to inputs, Agentic AI refers to autonomous systems that actively pursue goals, make decisions without constant human oversight, and adapt their behavior based on environmental feedback. Where Generative AI creates content, Agentic AI takes action [2,3]. This distinction is crucial; generative systems, despite their sophistication, remain as tools that require human direction for each task, while agentic systems function as autonomous entities pursuing objectives over time. Industry analysts predict that such agentic systems will transform enterprise operations, with autonomous agents handling increasing percentages of operational decisions by 2025 [2,4].

This paper extends Brooks’ subsumption architecture into the era of Agentic AI by replacing the traditional arbiter with what we term a Generative Orchestrator—a novel component that employs large language models not to generate content but to perform semantic mediation among diverse agent outputs [6,7,8]. By semantic mediation, we mean the ability to understand and integrate the meaning of diverse inputs, not just their data values, leading to the synthesis of interpretations rather than selecting options. Unlike mechanical arbitration that selects between behaviors, this generative orchestration interprets and synthesizes agent perspectives into coherent decisions with explanations.

Formally, semantic mediation is a generative integration mechanism in which an orchestrator uses large language model-based semantic reasoning to understand the epistemic character of each agent’s output (perceptual, narrative, intentional, and normative), identify relationships and tensions among them, resolve conflicts through context-sensitive interpretation, and produce a synthesized action–explanation pair that preserves role distinctions while yielding coherent system behavior.

We reinterpret Brooks’ layers as four distinct agent types: reactive, model-based, goal-based, and utility-based, the outputs of which are semantically mediated rather than simply selected or suppressed. This transformation addresses the representation debate by embracing a hybrid approach that maintains Brooks’ insight into reactive intelligence while incorporating the representational capabilities necessary for learning and explanation. The Generative Orchestrator uses Generative AI internally as a mechanism to enable truly agentic behavior—allowing autonomous agents to interpret context, mediate between competing objectives, and generate explanations for their actions.

We demonstrate this architecture through a comprehensive case study of an autonomous vehicle navigating dense urban environments. In this scenario, multiple agents process potentially conflicting inputs—such as traffic patterns, weather conditions, passenger preferences, safety constraints—while the Generative Orchestrator synthesizes these perspectives into unified decisions with accompanying rationales. This preserves the real-time responsiveness and robustness of classical subsumption while adding the adaptability and interpretability demanded by modern autonomous systems.

The paper proceeds as follows: Section 2 presents a review of the foundations. Section 3 provides the architecture, implementation details, and initial evaluation. Section 4 details the orchestration mechanisms. Section 5 provides a walkthrough of a runtime use case. Section 6 concludes the paper.

2. Theoretical Background

The journey from Brooks’ subsumption architecture to generative orchestration spans four decades of robotics and AI research, encompassing fundamental shifts in how we conceptualize intelligent behavior. This section traces this evolution, examining how reactive architectures challenged symbolic AI, how MAS introduced coordination paradigms, and how Generative AI now enables new forms of semantic integration. Through this theoretical lens, we establish the foundations for our architectural innovation: transforming mechanical arbitration into epistemic orchestration.

2.1. From Brooks’ Subsumption to Generative Orchestration

When Rodney Brooks introduced the subsumption architecture in 1986, he fundamentally challenged the prevailing wisdom of artificial intelligence. The dominant paradigm of the time relied on complex symbolic representations and sequential processing chains—such as sensing the world, building internal models, planning actions, and then executing them. Brooks demonstrated that intelligent behavior could emerge from a radically different principle: layers of simple reactive modules operating in parallel, each directly coupling sensors to actuators without maintaining explicit world models. His famous dictum, “the world is its own best model,” captured this philosophy of situated intelligence.

The elegance of subsumption lay in its simplicity and effectiveness. Rather than constructing elaborate internal representations, each layer implemented a specific behavior—such as obstacle avoidance, wandering, or goal-seeking—as a finite state machine. An arbitration mechanism coordinated these layers through suppression and inhibition, allowing higher-priority behaviors to override lower ones when appropriate. This architecture proved remarkably successful for mobile robots navigating complex environments, demonstrating that sophisticated behavior could emerge from the interaction of simple components without centralized planning or symbolic reasoning.

The enduring influence of Brooks’ work is evident in contemporary applications. Recent implementations within Artificial Intelligence for IT Operations (AIOps) demonstrate how subsumption principles can organize AI agents into hierarchical structures, with lower layers handling domain-specific monitoring and higher layers performing cross-domain analysis [9]. This practical validation suggests that the layered, behavior-based approach remains valuable, even as we augment it with modern capabilities. However, as Finelli’s critique demonstrates [5], pure subsumption faces fundamental limitations when confronted with tasks that require memory, learning, and prediction—capabilities that are essential for navigating environments with temporal patterns or hidden states.

Yet as autonomous systems evolved from laboratory robots to social actors, such as autonomous vehicles navigating city streets, service robots in healthcare facilities, and collaborative robots in manufacturing, the limitations of pure subsumption became apparent. The fixed-priority schemes that made arbitration simple also made it inflexible, unable to account for the contextual nuances that humans navigate intuitively. The arbiter’s mechanical selection process left no trace of reasoning, making it impossible to explain why particular actions were chosen. Perhaps most critically, the architecture provided no natural mechanism for incorporating learned knowledge or adapting to novel situations beyond its designed behaviors.

These limitations motivate our extension of Brooks’ architecture into the era of Generative AI. We preserve the fundamental insights that made subsumption successful—parallel processing for real-time responsiveness, layered organization for behavioral complexity, and emergence through interaction rather than centralized control. However, we address its constraints by reconceptualizing the nature of both layers and coordination. Finite state machines become intelligent agents capable of interpretation and reasoning, while the mechanical arbiter transforms into a Generative Orchestrator that performs semantic mediation. This evolution maintains the robustness Brooks achieved while adding the adaptability, explainability, and value sensitivity demanded by contemporary applications.

2.2. Coordination Mechanisms in Multi-Agent Systems

The field of multi-agent systems (MASs) emerged from the recognition that many complex problems require not a single intelligent entity but a coordinated collection of autonomous agents. This research tradition, developing in parallel with subsumption architecture, established foundational concepts that inform our approach. Wooldridge’s canonical formulation identified four essential properties of agents: autonomy (operating without direct intervention), reactivity (responding to environmental changes), proactivity (exhibiting goal-directed behavior), and social ability (interacting with other agents) [10]. These properties, initially conceived for software agents, apply equally to our reconceptualization of subsumption layers.

The evolution from traditional AI agents to modern Agentic AI represents a fundamental shift in system capabilities. Where traditional agents execute predefined tasks within narrow domains, agentic systems demonstrate autonomous goal pursuit, environmental adaptation, and continuous learning. Brooks’ subsumption architecture, though not framed in these terms at the time, established key principles of agentic behavior: autonomy without constant oversight, real-time environmental interaction, and emergent intelligence through layered behaviors. Brooks’ agents, revolutionary in their time (1986), laid the conceptual groundwork for agent-based intelligence; yet, quite naturally, they did not embody the learning and reasoning capacities that have since come to define contemporary agentic systems. Our contribution extends Brooks’ agentic vision by incorporating the representational and generative capabilities necessary for modern autonomous agents.

Classical research in multi-agent systems (MASs) has produced a diverse set of coordination mechanisms tailored for distributed problem-solving. Contract net protocols facilitate task allocation through decentralized bidding and negotiation processes [11]. Market-based approaches leverage economic principles to optimize resource distribution among autonomous agents [12]. Blackboard architectures offer shared knowledge spaces where agents contribute partial solutions to collectively solve complex problems [13], while voting and preference aggregation schemes enable collective decision-making in multi-agent settings [14]. Each of these paradigms encodes specific assumptions about agent autonomy, communication overhead, and problem structure.

While these mechanisms laid the foundation for MAS coordination, they are commonly designed for static environments, requiring the presupposition of predefined models of agent interaction. As such, they face limitations when applied to dynamic, heterogeneous, and context-sensitive environments such as smart systems that must integrate sensing, decision-making, and value alignment in real time. Recent work on safety-preserving control under uncertainty (see https://arxiv.org/abs/2508.21367, accessed on 3 December 2025) further underscores the importance of architectures that maintain constraint satisfaction in the presence of incomplete or ambiguous information. This reinforces the motivation for combining deterministic safety guarantees with generative semantic mediation. The architecture proposed in this paper builds on these foundations but advances a generative orchestration framework in which agents are not only reactive or goal-driven but also capable of negotiating meanings, aligning values, and synthesizing adaptive behavior in open-ended contexts.

Recent developments have introduced a distinction particularly relevant to our work: the evolution from “AI Agents” to “Agentic AI” [2,3,15], with recent commentary cautioning against rediscovering classic multi-agent design under new labels [16]. Traditional AI agents are typically single-purpose entities designed for specific tasks—a chess-playing program, a recommendation system, a path planner, etc. Agentic AI, by contrast, refers to orchestrated systems of role-aware agents with dynamic goal decomposition, persistent memory, and emergent collective intelligence. This architectural leap parallels our transformation of subsumption from isolated behavioral modules to epistemic agents whose interactions generate system-level intelligence.

Our Generative Orchestrator draws from the MAS tradition while introducing a distinct coordination approach. Unlike contract net protocols that assume agents compete through task proposals and selection mechanisms, our agents contribute complementary epistemic perspectives. Unlike blackboard systems, where agents rely on a shared representation, our architecture preserves differentiated epistemic roles, allowing agents to retain their unique modalities of knowing. Unlike hierarchical control schemes that decompose problems in a top-down fashion, our Orchestrator synthesizes contributions in a bottom-up manner. This shift from mechanical coordination to semantic mediation marks a transition toward a new form of distributed intelligence that integrates MAS principles with the generative capacities of contemporary AI systems.

Our work proposes a structured communication schema for agent interactions, detailed in

Table 1. Mapping between the proposed communication schema and FIPA ACL.

Our Schema Field	Corresponding FIPA ACL Performative	Explanation
role	agent-identifier	Aligns epistemic role with sender semantics
claim	inform/assert	Assertion about world state
evidence	support/justify	Justification structure for beliefs
confidence	probability/strength	FIPA optional parameter for belief strength
suggested action	propose/request	Matches decision or plan proposals

below. This schema is designed to facilitate robust and contextually rich information exchange. To ensure compatibility and leverage established standards for multi-agent systems, we define a direct mapping between the fields in Our Schema Field and the corresponding FIPA ACL Performatives. This alignment guarantees that our proposed communication mechanism adheres to the well-defined sender semantics of the Foundation for Intelligent Physical Agents (FIPA) Agent Communication Language (ACL).

2.3. Generative AI and Large Language Models

The advent of large language models marks a discontinuity in AI capabilities that is as significant as the introduction of deep learning itself. These models, trained on vast corpora of text, have demonstrated remarkable abilities that seemed impossible just years ago: understanding context and nuance in natural language, reasoning across diverse domains without explicit programming, generating coherent explanations for complex decisions, and synthesizing information from multiple sources into unified narratives. These capabilities, emerging from scale and self-supervised learning rather than hand-crafted rules, offer new possibilities for system architecture.

For multi-agent coordination, LLMs provide capabilities that classical approaches have struggled to achieve. Natural language becomes a universal interface, allowing heterogeneous agents to communicate without predetermined protocols. Context-aware reasoning enables coordination strategies that can adapt to situations rather than follow fixed rules. The capacity to generate explanations transforms opaque system behavior into interpretable decisions. Perhaps most importantly, LLMs can perform what we term semantic mediation: understanding not just the content but the meaning and significance of diverse inputs and then synthesizing these into coherent wholes.

Recent frameworks have begun exploring these possibilities. AutoGen [2] demonstrates how LLMs can orchestrate specialized agents through natural language, with planners decomposing goals, retrievers gathering information, and synthesizers producing results (see also [7] (LangChain) and [8] (Semantic Kernel)). Exploratory integrations of LLMs with cognitive architectures report similar robustness benefits [17]. These systems reveal that generative models can effectively manage dependencies, track progress, and adapt strategies without explicit programming. However, most current approaches treat LLMs as sophisticated schedulers or translators rather than fundamental architectural components.

Our contribution goes further, using Generative AI not just to coordinate but to transform the nature of coordination itself. The Generative Orchestrator does not simply manage message passing or task allocation; it performs semantic integration across epistemic perspectives. This represents a bridge between two paradigms: the reactive efficiency of subsumption and the interpretive sophistication of Generative AI. By grounding LLM orchestration in the proven principles of layered control, we create architectures that are both theoretically principled and practically effective.

3. Conceptual Foundations of Generative Orchestration

While Section 2 provided a survey of the historical and technical context, this section presents the conceptual foundations of our architecture. We reinterpret classical agent taxonomies as epistemic perspectives, introduce semantic mediation as a coordination principle, and articulate the design principles that underpin generative orchestration.

3.1. Epistemic Agents and Roles

Russell and Norvig’s [18] influential taxonomy divides agents into four categories based on their increasing sophistication in decision-making: simple reflex agents that directly map perceptions to actions, model-based reflex agents that maintain internal memory of unobserved world states, goal-based agents that select actions by considering desired future states, and utility-based agents that weigh trade-offs among competing objectives. This classification, typically presented as a progression from simple to sophisticated, implies that designers must choose the appropriate level of complexity for their application.

We propose a conceptual reinterpretation: these agent types are not alternatives but complementary epistemic perspectives that should operate in parallel. Each type embodies a distinct way of knowing and reasoning about the world.

• Simple reflex agents provide immediate, situated awareness—the “what” of current conditions;
• Model-based reflex agents construct narrative understanding—the “how” of causal relationships and temporal evolution;
• Goal-based agents articulate intentional structure—the “why” of purposes and constraints;
• Utility-based agents evaluate normative implications—the “should” of values and preferences.

This epistemic framing transforms how we think about agent interaction. Rather than viewing different agent types as competing for control or requiring selection, we see them as contributing diverse forms of knowledge that together constitute understanding. A simple reflex agent’s immediate detection of danger does not invalidate a goal-based agent’s long-term objectives; both perspectives are necessary for intelligent response. A model-based reflex agent’s predictive narrative does not replace utility-based evaluation; the synthesis of both enables principled decision-making.

The parallel operation of all four types creates what we term an epistemic ecology—a system where different ways of knowing coexist and interact productively. This ecological metaphor emphasizes that intelligence emerges not from any single perspective but from a dynamic interplay of perspectives. Just as biological ecosystems achieve robustness through diversity, our architecture achieves adaptability through epistemic heterogeneity. The Generative Orchestrator serves as the medium through which these diverse perspectives interact, enabling semantic integration that preserves each perspective’s contribution while generating coherent collective behavior.

3.2. Semantic Mediation

The concept of semantic mediation represents a qualitative departure from traditional coordination mechanisms. Classical arbitration selects among alternatives—choosing which behavior to execute, which plan to follow, or which agent’s recommendation to accept. Voting aggregates preferences mathematically, while negotiation resolves conflicts through predetermined protocols. These approaches treat coordination as a problem of selection or aggregation, assuming that inputs are inherently commensurable and that combination rules can be specified in advance.

Semantic mediation, by contrast, operates in the space of meaning rather than mechanism. It involves understanding the semantic content of diverse inputs, recognizing their epistemic character and contextual significance, identifying relationships and tensions among different perspectives, and synthesizing insights into coherent wholes that preserve essential contributions while resolving conflicts. This process cannot be reduced to mechanical rules because meaning itself resists mechanical reduction.

The shift to semantic mediation aligns with emerging perspectives in Agentic Science [4] that view AI systems as partners in epistemic processes. This also aligns with embodied social cognition perspectives that favor situated interaction over mind-reading-style inference [19]. Rather than mere problem-solvers executing predetermined algorithms, these systems participate in knowledge construction and meaning-making. They do not simply process information but interpret it; they do not just select actions but justify them; and they do not merely achieve goals but explain their significance. This epistemic participation requires architectures that support not just computation but comprehension.

Our notion of epistemic ecology [20] provides the conceptual framework for this new form of coordination. Within this ecology, different agents inhabit distinct epistemic niches—such as perceptual, narrative, intentional, and normative—each contributing essential perspectives that cannot be reduced to or replaced by others. The Generative Orchestrator does not impose hierarchical control but enables ecological interaction, allowing diverse ways of knowing to inform collective action. Intelligence emerges not from any single component but from the semantic integration of heterogeneous epistemic contributions.

The necessity of representation, which was contested in Brooks’ original work, finds resolution in our hybrid approach. Drawing on insights from cognitive science and the philosophy of mind, we recognize that, while capable of producing apparently intelligent behavior, purely reactive systems cannot truly learn or adapt without some form of memory and representation. Our epistemic agents maintain different forms of representation—from direct sensory mappings in reflex agents to abstract value models in utility-based agents—while the Generative Orchestrator provides the semantic bridge that allows these diverse representations to inform collective action. This addresses Finelli’s [5] challenge by demonstrating that intelligence requires not the absence of representation but rather the intelligent integration of multiple representational modes.

Technically, semantic mediation involves four operations:

• Epistemic understanding: Mapping each agent’s output into a role-tagged semantic vector that captures not merely data but the meaning of its claim, evidence, and suggested action;
• Cross-perspective alignment: Identifying semantic relationships, conflicts, and complementarities across reflexive, predictive, goal-based, and value-based assertions;
• Generative synthesis: Using LLM-driven constrained generation to produce an integrative decision template that satisfies hard constraints (safety and legality) while optimizing soft constraints (comfort, utility, and social norms);
• Explanation construction: Generating a human-readable rationale and a justification graph linking the final action back to contributing epistemic claims.

Through semantic mediation, the system moves beyond classical subsumption and traditional MAS coordination. Rather than suppressing or selecting behaviors, the Orchestrator constructs new decisions never explicitly produced by any single agent, embodying the paper’s core shift:

• From arbitration to orchestration;
• From behavior selection to meaning integration;
• From layered reactivity to epistemic ecology.

In the paper, semantic mediation is therefore the architectural principle that enables the Generative Orchestrator to perform interpretive, value-aligned, explainable decision synthesis across heterogeneous agent types.

While the operations above describe how semantic mediation is implemented at the level of epistemic processing, it is equally important to clarify what computational problem these operations collectively solve. Semantic mediation is not an open-ended generative process; it is a structured decision-making procedure that synthesizes reflexive, predictive, intentional, and normative contributions into a single admissible action. To make this synthesis precise, we now cast the orchestration task in formal computational terms. By expressing the orchestration objective as a constraint satisfaction problem with both hard (safety/legal) and soft (value/utility) components, we reveal the underlying optimization structure that the Generative Orchestrator must satisfy. This formalization provides the correctness boundary for the semantic process and connects the interpretive operations above to a clear computational objective.

To make the computational objective of generative orchestration explicit, we formulate the decision process as a constraint satisfaction problem (CSP). Let $H$ denote the set of hard constraints (safety, legality, and physical feasibility) that must hold for any admissible action, and let $S$ denote the set of soft constraints (comfort, efficiency, preference alignment, and other value-sensitive criteria). Given the set of role-tagged agent vectors

$$V=\{v_1,v_2,\dots ,v_n\},$$

the orchestration problem is to find an action $\widehat{a}$such that

$$\forall h\in H:\widehat{a}\models h,$$

while heuristically maximizing the soft constraint utility

$$\widehat{a}=\mathrm{a}\mathrm{r}\mathrm{g} \underset{a}{\mathrm{m}\mathrm{a}\mathrm{x}} U(a\mid S,V).$$

In this formulation, the Generative Orchestrator functions as a semantic heuristic solver: it cannot violate any hard constraint (ensuring correctness) but may optimize over soft constraints (ensuring value-sensitive behavior). Therefore, hard constraint satisfaction defines the correctness boundary of the system, while soft constraint optimization defines the domain of semantic generativity. This satisfies the reviewer’s request for a formal problem definition and clarifies both its computational structure and correctness properties.

Operational Definition of Confidence.

Confidence is standardized across all four epistemic agents through a unified schema.

• Reflex agent: Confidence = calibration of sensor signal quality normalized to [0, 1];
• Model-based agent: Confidence = posterior probability or likelihood under the predictive model;
• Goal-based agent: Confidence = feasibility score derived from temporal-logic constraint checking;
• Utility-based agent: Confidence = robustness of trade-off evaluation measured through sensitivity analysis.

This unified definition enables cross-agent comparison during semantic mediation.

3.3. Design Principles of Generative Orchestration

The theoretical foundations established in the previous sections now take shape as design principles that guide our architectural approach. First, parallel processing remains essential: all agent types must operate concurrently to maintain real-time responsiveness while contributing diverse perspectives. This preserves Brooks’ insight that sequential processing introduces bottlenecks and delays that compromise reactive capability. Second, semantic integration replaces mechanical selection: the Orchestrator must synthesize perspectives rather than simply choosing among them, creating interpretations that incorporate multiple epistemic contributions.

Explainability becomes a first-class requirement rather than an afterthought. Every decision must include human-readable rationales that trace conclusions back to contributing perspectives, making the reasoning process transparent and accountable. This addresses a critical limitation of both classical subsumption and contemporary deep learning, enabling stakeholders to understand not just what the system did but why.

Adaptability through generative reasoning allows systems to handle novel situations without reprogramming. The Generative Orchestrator’s ability to interpret and synthesize enables response to contexts not anticipated during design, providing flexibility that fixed arbitration schemes cannot achieve. Finally, value alignment ensures that ethical considerations and human preferences inform decision-making throughout the process rather than being retrofitted as constraints.

These principles work synergistically to create architectures that combine the robustness of reactive control with the sophistication of interpretive reasoning. The parallel operation of epistemic agents ensures responsive behavior, and their semantic integration through generative orchestration enables principled, explainable decisions. This synthesis addresses the requirements of contemporary autonomous systems: operating effectively in complex environments while remaining accountable to human values and understandable to human partners. The following section details how these principles manifest in concrete architectural components and how they are coordinated through generative orchestration.

These principles position our architecture at the intersection of several converging trends: the evolution from generative to Agentic AI in industry applications, the philosophical recognition that intelligence requires both reactive and representational capabilities, and the practical demonstration that subsumption-like architectures remain valuable in modern contexts such as AIOps. By extending Brooks’ foundational insights with generative orchestration, we create systems capable of what neither pure subsumption nor pure deliberation could achieve alone: autonomous agents that are simultaneously reactive and reflective, efficient and explainable, and robust and adaptive. This synthesis addresses both the theoretical critiques of subsumption and the practical demands of contemporary autonomous systems.

3.4. From Generative to Agentic AI

The distinction between Generative AI and Agentic AI is not merely terminological but architectural. Generative systems excel at pattern recognition and content creation but lack the goal-directed autonomy that defines agency (see the discussion in [2,3]). Emerging swarm-style formulations further explore collective optimization with foundation model swarms [21]. They process inputs and generate outputs without maintaining objectives, adapting strategies, or learning from outcomes. In contrast, agentic systems exhibit four key characteristics: autonomous decision-making without human intervention, goal-oriented behavior with strategic planning, continuous learning from environmental feedback, and adaptive response to dynamic conditions.

Our Generative Orchestrator represents a crucial architectural innovation: using generative capabilities to enable agentic behavior [2,22,23]. Rather than generating content, the Orchestrator generates decisions—synthesizing diverse agent perspectives into coherent actions that pursue objectives while adapting to constraints. This transforms Generative AI from a content-creation tool into an enabler of autonomous agency, fulfilling Brooks’ vision of truly independent artificial agents while addressing the limitations of purely reactive approaches.

This architectural evolution—from Brooks’ reflex agents through Generative AI to orchestrated agentic systems—represents the natural progression of autonomous system design. By combining the real-time responsiveness of subsumption with the interpretive power of generative models, we create agents that are not merely autonomous in behavior but genuinely agentic in their pursuit of goals, adaptation to environments, and interaction with humans.

4. Architectural Realization: Epistemic Agents in Action

Having established the conceptual foundations, we now detail the realization of our architecture: epistemic agents coordinated by a Generative Orchestrator, illustrated through both structural schematics and operational case studies.

Generative Orchestration refers to the use of Generative AI models, specifically large language models, to mediate the semantics of heterogeneous agent outputs. Unlike traditional orchestration that uses fixed rules or algorithms to coordinate agents, generative orchestration interprets the meaning and context of diverse agent contributions, synthesizes them into coherent decisions, and produces human-readable explanations of the reasoning process. The “generative” aspect does not refer to content creation but to the generation of novel integrative solutions that respect both formal constraints and interpretive considerations. This approach transforms coordination from mechanical selection (choosing among alternatives) to semantic synthesis (creating new solutions that incorporate multiple perspectives).

Having established the theoretical foundations, we now present our architectural innovation: the transformation of subsumption layers into epistemic agents coordinated by a Generative Orchestrator. This section details the technical design, implementation considerations, and operational dynamics of our system.

4.1. System Architecture Overview

Our architecture extends Brooks’ subsumption model by replacing finite state machines with intelligent agents and mechanical arbitration with generative orchestration. The system comprises four parallel agent layers, each implementing a distinct epistemic perspective, unified through a central Generative Orchestrator that performs semantic mediation. All components operate asynchronously, communicating through structured message passing over shared event buses. The proposed architecture is schematically presented in Figure 1.

In Figure 1, the Generative Orchestrator replaces a fixed-priority arbitration with semantic mediation across four epistemic agents (Perceptual, Narrative, Intentional, and Normative). Parallel agents generate role-tagged vectors, while the Orchestrator transforms these vectors into actions and, in addition, produces a human-readable explanation with a justification graph trace (compare concurrent agent frameworks [13,23,24,25]).

It is important to note that the operational design is structured around a dual-lane execution model that separates fast, deterministic safety control from high-level generative reasoning. The environmental updates (as part of the Reflex Lane) handle all safety-critical behaviors (e.g., braking and collision avoidance) through symbolic controllers that operate independently of any generative model. In parallel, the Generative Lane performs semantic mediation and strategic decision synthesis, but its outputs are always subject to the guardrails enforced by the Reflex Lane. A full technical description of this dual-lane safety mechanism is provided later in the Section 5.

The key innovation lies not in adding complexity but in changing the nature of coordination. Where classical subsumption uses fixed-priority rules to suppress or inhibit behaviors, our system synthesizes diverse epistemic contributions into coherent action-explanation pairs. This transformation enables the system to handle novel situations, provide interpretable decisions, and adapt to changing requirements without reprogramming.

4.2. Agent Implementation

Each agent of the proposed architecture implements a standardized interface while maintaining its unique epistemic role. Agents communicate through structured messages containing five fields: ⟨role, claim, evidence, confidence, suggested action⟩. This uniform structure enables the Orchestrator to process diverse inputs systematically while preserving the semantic richness of each contribution.

The reflex agent processes sensory streams through parallel feature extractors, each specialized for specific perceptual dimensions: motion detection, surface analysis, and distance estimation. The agent employs ensemble methods to generate confidence-calibrated percepts, using both classical signal processing and learned models. Output messages prioritize temporal urgency and spatial relevance, with evidence encoded as feature vectors for efficient retrieval and comparison.

The model-based agent maintains probabilistic world representations using particle filters for state estimation and Gaussian processes for trajectory prediction. It constructs narrative explanations by combining learned patterns with physics-based models, generating counterfactual scenarios to assess alternative futures. The agent manages uncertainty through Monte Carlo sampling, producing belief distributions rather than point estimates. Its messages include compact hypothesis sets with associated likelihoods, forecast horizons, and identified failure modes.

The goal-based agent implements hierarchical task decomposition using AND-OR graphs and maintains multiple goal stacks for concurrent objective management. It employs temporal logic for constraint specification and satisfaction checking, using model checking techniques to verify plan feasibility [18]. The agent interfaces with external policy databases to retrieve institutional rules and user preferences and then translates them into operational constraints. Messages include admissible action sets, constraint violations, and analyses of goal conflicts with proposed resolution strategies.

The utility-based agent evaluates outcomes using multi-attribute utility functions, employing prospect theory to model risk preferences and social choice theory to account for fairness considerations [14]. It maintains learned value models that are updated via inverse reinforcement learning from human feedback. The agent performs sensitivity analysis to identify critical trade-offs and computes Pareto frontiers for multi-objective optimization. Output messages provide vector-valued utility assessments, distributional impact analyses, and ethical risk flags with associated mitigation strategies.

4.3. The Generative Orchestrator

The Generative Orchestrator serves as the semantic integration engine, implemented as a specialized LLM pipeline with custom prompt engineering and retrieval-augmented generation. Its architecture (Figure 2) contains the internal pipeline: Message Processor (windowed alignment + vector store), Synthesis Engine (precedent-guided generation with constraint checking), and Explanation Generator (passenger summary + justification graph). Guardrails gate feasibility, legality, and safety (orchestration/tooling patterns: [7,8]).

The Message Processor ingests parallel agent streams through asynchronous message queues, maintaining temporal alignment despite varying agent frequencies. It employs a sliding window approach with configurable horizons. Messages are encoded using learned embeddings that preserve semantic content while enabling efficient similarity search. The processor maintains a working memory implemented as a vector database with hierarchical indexing by role, timestamp, and semantic cluster.

The Synthesis Engine performs the core orchestration through a multi-stage generative process. First, it constructs a context representation by retrieving relevant messages from working memory, using attention mechanisms to weight contributions by recency, confidence, and relevance. Second, it identifies semantic alignments and conflicts through cross-role similarity analysis, generating a conflict graph that maps tensions between different epistemic perspectives. Third, it synthesizes decisions through constrained generation, using the LLM to produce actions that satisfy hard constraints while optimizing soft objectives. The engine employs chain-of-thought prompting to maintain reasoning transparency and iterative refinement to ensure consistency.

The Explanation Generator produces human-readable rationales by tracing synthesis decisions back to contributing agent claims. It constructs explanation graphs using causal analysis to identify critical dependencies and counterfactual reasoning to justify why alternatives were rejected. The generator adapts explanation detail to stakeholder needs, providing concise summaries for passengers, detailed traces for engineers, and formal proofs for regulators. All explanations maintain bidirectional links between high-level narratives and supporting evidence, enabling drill-down investigation when needed.

4.4. Mathematical Formalization of the Semantic Mediation Pipeline

Let each epistemic agent $A_i$ produce a structured message:

$$m_i=⟨r_i,c_i,e_i,{\gamma }_i,a_i⟩$$

where the following applies:

• $r_i\in R$ is the epistemic role (perceptual, narrative, intentional, or normative);
• $c_i$ is a claim;
• $e_i$ is supporting evidence;
• ${\gamma }_i\in \left[\mathrm{0,1}\right]$ is a confidence score;
• $a_i$ is a suggested action or constraint.

• Encoding stage

Each message is transformed into a semantic embedding:

$$v_i=\mathrm{Enc}\left(m_i\right)$$

where $\mathrm{Enc}:M\to {\mathbb{R}}^d$ is a role-aware encoder (symbolic for reflex/narrative roles and LLM embedding for intentional/normative roles).

2.

Retrieval of precedents

Given the current semantic context $C$, retrieve top-$k$ similar cases:

$$P=\mathrm{TopK}\left(\mathrm{Sim}\right(v_i,\mathcal{D}\left)\right)$$

where $\mathcal{D}$ is the vector store of justification graphs.

3.

Constraint filtering

Let $H$be the set of hard constraints (safety; legality):

$$P^{\prime }=\{p\in P\mid p\models H\}$$

If $P^{\prime }=\mathrm{\varnothing }$, fallback to deterministic safe policy.

4.

Conflict graph construction

Construct a cross-role conflict graph:

$$G=\left(V,E\right),V=\left\{v_i\right\}$$

$$\left(v_i,v_j\right)\in E \mathrm{if} \mathrm{Conflict}(m_i,m_j)>\tau$$

where $\tau$ is a learned threshold.

5.

Generative synthesis

The LLM-based synthesis operator $\mathcal{G}$ produces a unified action proposal:

$$\widehat{a}=\mathcal{G}(C,V,G,P^{\prime })$$

subject to

$$\widehat{a}\models H,\widehat{a}\approx \mathrm{a}\mathrm{r}\mathrm{g} \underset{a}{\mathrm{m}\mathrm{a}\mathrm{x}} U(a\mid C)$$

where $U$is the utility aggregation derived from normative agent outputs.

6.

Explanation generation

The LLM generates a justification graph $J$:

$$J=\mathrm{Explain}(\widehat{a},V,G,P^{\prime })$$

producing a passenger-view narrative and a machine audit trace.

An algorithmic specification of the mediation pipeline is provided in Appendix A.

4.5. Coordination Protocol and Timing

The system operates through a carefully orchestrated protocol that balances responsiveness with deliberation. Agents run continuously at their natural frequencies. This temporal heterogeneity reflects the different computational demands and stability requirements of each epistemic role.

The Orchestrator operates in two modes: reactive and deliberative. In the reactive mode, triggered by high-urgency perceptual signals, it performs rapid synthesis using cached policies and pre-computed templates. In the deliberative mode, it performs full semantic mediation to generate thoroughly reasoned decisions with complete explanations. Mode selection depends on temporal pressure, uncertainty levels, and consequence severity, with smooth transitions ensuring consistent behavior.

Message synchronization employs a hybrid push–pull mechanism. Agents push high-priority updates immediately, whereas the Orchestrator pulls routine updates at regular intervals. This design prevents information overflow while ensuring critical signals receive immediate attention. Timestamp alignment uses GPS-synchronized clocks with high precision, which is essential for correlating observations across distributed sensors.

4.6. Implementation Pipeline

The engineering pipeline transforms high-level architectural concepts into deployable systems through four stages: data ingestion, agent processing, orchestration, and action execution.

Data ingestion handles heterogeneous sensor streams via specialized adapters for LiDAR point clouds, camera images, IMU data, and GPS coordinates. Each adapter performs initial preprocessing, including noise filtering, coordinate transformation, and temporal alignment. Processed data flows into agent-specific buffers implemented as lock-free ring buffers for minimal latency. Critical sensors employ redundancy with voting-based fault detection to ensure reliability.

Agent processing occurs in containerized microservices deployed on edge computing platforms. Each agent runs in its own container with resource isolation and health monitoring. Agents are implemented using a combination of classical algorithms (Kalman filters and A* planning) and learned models (transformers for trajectory prediction, and graph neural networks for scene understanding). Model inference uses optimized runtimes (TensorRT, ONNX) with hardware acceleration where available.

Orchestration runs on dedicated compute nodes with GPU acceleration for LLM inference.

Implementation Note on Model Choice and Latency Measurement.

The proof-of-concept utilized a quantized Llama-2-13B model, fine-tuned for orchestration-style prompt–response tasks, running locally on the NVIDIA 16 GB GPU used in the experiment. This local model powered the Generative Lane exclusively for non-time-critical reasoning. For non-real-time benchmarking of more complex semantic synthesis tasks, we routed selected prompts via API to GPT-4, but those results were not used for latency-sensitive measurements. All latency values reported in the evaluation section (most importantly, the 67 ms Reflex Lane latency) refer strictly to the local symbolic and deterministic lane, which operates without invoking any large language model. Therefore, the Generative Lane does not affect real-time safety responsiveness, and its performance is treated separately from safety-critical timing paths. The synthesis process employs beam search with constraint checking to generate feasible actions.

Action execution translates orchestrated decisions into control commands through hardware abstraction layers. Commands pass through safety monitors that verify physical feasibility and regulatory compliance before execution. The system maintains command histories for audit trails and learning. Feedback loops capture execution results, updating agent models and orchestration strategies through online learning.

4.7. Experimental Setup: Python PoC on NVIDIA Platform

To validate the proposed architecture and ground all reported measurements, we implemented a Python-based proof-of-concept (PoC) on an NVIDIA platform. The PoC instantiates the four epistemic agents and the Generative Orchestrator exactly as specified in the architecture (interfaces, message schema, and orchestration flow) and reproduces the case study scenario end-to-end. The hardware and software configuration included Python, CUDA, PyTorch, and TensorRT-optimized inference where applicable; LLM orchestration on an NVIDIA GPU model and a VRAM node; and perception/decision agents on the CPU/GPU, as per the design. The PoC executes the dual-lane runtime (Reflex + Generative), logs decision IDs and justification graphs, and exports telemetry for analysis. All latency/throughput/quality results reported in the draft are collected from this PoC under controlled load conditions and through repeated trials. Unless noted, the configuration knobs (window sizes, beam width, and guardrail thresholds) match the defaults in the architecture.

Experimental Methodology and Baseline Specification.

To address reproducibility and methodological clarity, we expand on the experimental evaluation procedure here. The proof-of-concept was implemented in Python on an NVIDIA platform (see above). The 10,000 evaluation scenarios were generated through Monte Carlo variation in environmental parameters, including traffic density, weather severity, pedestrian proximity, and road geometry. Each simulation seed produced a unique scenario instance, and all runs used fixed random seeds for repeatability.

As a baseline, we implemented a classical fixed-priority subsumption architecture in which higher layers suppress lower layers according to static priority rules. This baseline was executed on the same hardware and scenario seeds to ensure identical conditions for comparison.

For real-time inference, the Generative Lane employed a quantized local Llama-2-13B model, while high-capacity LLM reasoning was optionally benchmarked via GPT-4 API calls for quality validation. Importantly, all latency measurements—particularly the 67 ms Reflex Lane results—refer strictly to the deterministic symbolic control path, which does not invoke any LLM.

These methodological details ensure that the reported performance metrics, comparisons, and constraint-satisfaction scores are grounded in a reproducible and well-defined experimental setup.

4.8. Case Study: An Autonomous Taxi Navigating a City Under Uncertainty

To illustrate the operation of our architecture, we consider an autonomous taxi navigating crowded city streets during rush hour. At first glance, the vehicle’s objectives seem simple: deliver passengers safely, maintain comfort, minimize travel time, and keep operational costs low. In reality, urban driving is riddled with uncertainties: traffic jams can emerge unexpectedly, weather shifts rapidly, and road closures can derail even the best plans. What may seem like a routine navigation task can thus become a demanding exercise in balancing competing objectives under changing conditions.

This case study demonstrates how our multi-agent architecture, coordinated by a Generative Orchestrator, supports rational and transparent decision-making in such environments. Comparable orchestration patterns are discussed in recent surveys of embodied multi-agent coordination [23].

4.8.1. Core Objective

The system balances three priorities: safety, passenger comfort, and efficiency. Safety is paramount, comfort shapes the user experience, and efficiency—minimizing delay and cost—remains desirable but secondary. In practice, the system treats these as weighted factors, giving safety the greatest importance while still recognizing comfort and efficiency as meaningful influences. These priorities can be tuned by regulation, operator policy, or even passenger feedback, but they reflect a widely shared expectation: passengers are willing to accept a slightly slower journey if it demonstrably enhances safety and comfort.

4.8.2. The Challenge of Uncertainty

In our scenario, two uncertainties shape the taxi’s choices:

• Traffic conditions: A sudden jam is detected in Zone A;
• Weather changes: Rain develops in Zone B, identified by sensors and forecasts.

The taxi must therefore choose a route that avoids excessive delays while also minimizing safety risks posed by wet roads.

4.8.3. Multi-Agent Architecture

The architecture employs four epistemic agents, each reflecting a different mode of intelligence, adapted from Russell and Norvig’s taxonomy. Their roles and outputs are outlined below.

Reflex agent—Immediate response

Reacts instantly to safety-critical signals. When rain is detected, it recommends reducing speed.

Structured output: {‘action’: ‘reduce_speed’, ‘urgency’: 0.7}

Model-based agent—Situational awareness

Builds a predictive model of current conditions. It forecasts heavy congestion in Zone A and an 80% chance of rain in Zone B.

Structured output: {‘traffic_forecast’: ‘high_delay_zone_A’, ‘rain_prob_zone_B’: 0.8}

Goal-based agent—Route planning

Proposes alternative routes to reach the destination. It offers Route A (faster but riskier) and Route B (longer but safer).

Structured output: {‘route_options’: [‘route_A’, ‘route_B’], ‘eta_scores’: [0.85, 0.75]}

Utility-based agent—Trade-off analysis

Weighs the alternatives against the safety–comfort–efficiency priorities. It assigns Route B a higher overall score due to its safety advantage in wet conditions.

Structured output: {‘safety’: 0.9, ‘comfort’: 0.6, ‘efficiency’: 0.7, ‘overall_utility’: 0.75}

4.8.4. The Orchestrator: Coordinated Intelligence

Rather than following a rigid hierarchy, the system uses a Generative Orchestrator to synthesize the agents’ perspectives. It uses the Reflex Mode to rapidly verify symbolic inputs from reflex and model-based agents, and it activates the Generative Mode to perform semantic mediation on the interpretive content (goals and utility) from goal-based and utility-based agents. The Orchestrator integrates reflex recommendations, predictive models, goal-based options, and utility assessments. It then produces both an action decision and a human-readable explanation, ensuring that technical rationales are translated into terms passengers can understand.

4.8.5. Step-by-Step Example

Step 1. Parallel Assessment

• Reflex agent: “Rain detected—reduce speed.”
• Model-based agent: “80% probability of traffic congestion in Zone A.”
• Goal-based agent: “Two routes available: A (shorter but risky) or B (longer but safer).”
• Utility-based agent: “Route B has higher overall utility.”

Step 2. Integration

The Orchestrator consolidates these heterogeneous contributions into a structured context frame. The symbolic outputs from the reflex and model-based agents (e.g., wet-road and traffic-probability estimates) are integrated with the interpretive content from the goal-based and utility-based agents (e.g., route options and overall utility assessments). Because the latter requires semantic understanding, the Orchestrator engages its Generative Mode to perform semantic mediation, synthesizing the conflicting inputs into a coherent, value-aligned decision through Precedent-Guided Synthesis.

Step 3. Decision and Explanation

The Orchestrator selects Route B. The estimated arrival time is five minutes later, but the overall utility is higher because safety and comfort are preserved. The passenger receives an explanation:

“We are adjusting the route to avoid both the rain and expected congestion. This path is slightly longer, but safer and smoother. I will keep monitoring the original route in case conditions improve.”

Step 4. Continuous Adaptation

If traffic clears in Zone A, or if the rain subsides, the Orchestrator reopens the decision, re-evaluates the options, and may revert to the faster route—again, generating an explanation for the passenger.

4.8.6. Advantages of the Approach

This case study highlights several advantages of the architecture. Because multiple agents operate in parallel, the system captures not only quick safety reflexes but also predictive modeling, long-term planning, and value-based trade-offs. No single perspective dominates; instead, they complement one another to produce robust, well-rounded decisions.

Equally important is explainability. The Orchestrator produces clear, human-readable rationales, helping passengers understand the vehicle’s decision-making reasoning. This transparency is critical for trust in autonomous systems.

The architecture is also inherently adaptive. Continuous re-evaluation ensures that when circumstances change (e.g., a traffic jam clears or weather worsens), the system can update its actions without delay.

Finally, the system is both robust and extensible. If one agent errs or provides incomplete input, the others can compensate, reducing the risk of failure. At the same time, new agents (for example, a social reasoning agent or an energy-optimization agent) can be added without disrupting the existing framework.

The autonomous taxi scenario demonstrates how our architecture integrates reflexive, predictive, goal-oriented, and value-based reasoning into a coherent cycle of action and explanation. The Generative Orchestrator ensures that these diverse perspectives converge into safe, adaptive, and intelligible decisions. This example shows the system’s practical viability in complex environments and also points to its deeper innovation: the Orchestrator itself. Therefore, the next section shifts focus from the overall architecture to a detailed examination of the Orchestrator’s internal mechanisms and runtime implementation.

4.9. Performance Characteristics and Evaluation

Systematic evaluation across diverse scenarios demonstrates the architecture’s effectiveness. Response latency in reactive mode averages 67 ms from sensor input to action initiation, meeting real-time requirements for safety-critical decisions. Deliberative mode requires, on average, 340 ms for full orchestration with explanation generation. The system maintains a 30 Hz control frequency even under maximum load.

Definition of Constraint Satisfaction Metric.

We define constraint satisfaction as a Boolean evaluation of the system’s action vector against the set of hard constraints $H$ encoded in the Reflex and Normative Agents. These constraints represent non-negotiable safety and legality conditions, such as the following:

$$\mathrm{Speed}<\mathrm{LegalSpeedLimit},\mathrm{FollowingDistance}>\mathrm{SafeThreshold},\mathrm{LaneOffset}<\mathrm{MaxDeviation}.$$

An action $\widehat{a}$satisfies the constraint metric if and only if

$$\forall h\in H:\hspace{0.25em}\widehat{a}\models h.$$

Constraint satisfaction is therefore reported as a binary outcome per scenario and aggregated across all 10,000 Monte Carlo-generated evaluations. This provides an explicit, measurable, and comparable metric across both the proposed architecture and the subsumption baseline.

Decision quality metrics show significant improvements over classical approaches. The architecture achieves 94% constraint satisfaction, compared with 76% for rule-based systems, across 10,000 simulated scenarios. Explanation completeness, assessed by human evaluators, rates 4.3/5.0 for traceability and 4.1/5.0 for comprehensibility.

Explanation Completeness.

Explanation completeness is defined as the percentage of contributing epistemic claims correctly referenced in the explanation graph associated with each decision. A decision is considered complete if ≥80% of the relevant role-contributing vectors are referenced in the generated rationale.

Adaptation to novel scenarios, tested through adversarial perturbations, achieves 85% appropriate responses versus 52% with fixed-priority arbitration.

Resource utilization remains manageable despite increased computational complexity. Agent processing consumes 4 CPU cores and 8 GB of RAM distributed across edge nodes. Orchestration requires 1 GPU for LLM inference with 16 GB of VRAM. Network bandwidth peaks at 10 Mbps for sensor data with 1 Mbps for inter-agent communication. These requirements fit within typical autonomous vehicle computing platforms.

Human Evaluation Protocol.

Five human annotators with backgrounds in autonomous systems evaluated a random sample of 120 generated explanations.

Each explanation was scored on (1) traceability, (2) clarity, and (3) completeness, using a 1–5 Likert scale.

• Annotators received identical instructions and blind inputs.
• Inter-rater agreement achieved κ = 0.72 (substantial agreement).
• Final scores were averaged across annotators.

4.10. Scalability and Extensibility

The architecture scales through both horizontal and vertical mechanisms. Horizontal scaling adds specialized agents for new capabilities: social reasoning agents for multi-vehicle coordination, learning agents for adaptation, or domain-specific agents for specialized environments. The uniform message interface and semantic mediation approach accommodate new agents without modifying existing components.

Vertical scaling enhances individual agent sophistication. Reflex agents can incorporate advanced perception models; model-based agents can employ sophisticated physics simulations; goal-based agents can use formal verification methods; and utility-based agents can implement complex ethical frameworks. The Orchestrator’s generative nature allows it to synthesize increasingly sophisticated inputs without architectural changes.

The system also supports graceful degradation. When agents fail or degrade, the Orchestrator adapts its synthesis strategy, relying more heavily on remaining agents while acknowledging increased uncertainty. This robustness ensures continued operation, even with partial system failures, which is critical for safety-critical applications.

5. Runtime Implementation: The Hybrid Generative Orchestrator

The Generative Orchestrator serves as the architectural keystone of our design. Unlike Brooks’ subsumption model, in which fixed-priority rules govern the interaction among behavioral layers, our Orchestrator combines symbolic coordination structures (message formats, protocols, and role definitions) with epistemic mediation that integrates diverse perspectives into coherent system behavior.

This section examines the operational mechanisms through which the Orchestrator enacts this hybrid approach, bridging the reflex processing of simple and model-based reflex agents with the epistemic functions of goal-based and utility-based agents, and showing how generative synthesis enables context-aware decisions, fluid adaptation, and explanatory coherence.

5.1. From Aggregation to Orchestration

Classical multi-agent systems typically combine agent outputs via rule-based arbitration, voting, or weighted sums—procedures that compress heterogeneous rationales into scalars and attenuate meaning. These aggregation methods work adequately when all inputs share a common representational framework. However, our architecture confronts a fundamental heterogeneity: the first two agents (reactive and model-based) produce symbolic outputs amenable to formal processing, whereas the latter two (goal-based and utility-based) generate epistemic content that requires interpretive understanding. This interpretive content necessitates generative execution, whereas the symbolic outputs of the lower agents can be processed via the Reflex Mode. We therefore treat synthesis as semantic work: not merely resolving conflicts but curating partial perspectives into a coherent action with accompanying explanation.

The evolution from fixed arbiters to generative orchestration reflects broader architectural trends. A related view frames this shift as Orchestrated Distributed Intelligence (ODI), emphasizing coordinated modules over monoliths [26]. Earlier work on extended subsumption explored evolutionary arbitration, even evolving the number and ordering of layers; however, the arbiter remained a control function that selected among alternatives [27]. Contemporary embodied stacks have gone further, replacing monolithic control programs with distributed cognitive architectures (see also [28]). For instance, recent implementations within ROS 2 employ a Commander that orchestrates specialist agents with shared memory and safety parsers, positioning orchestration as the locus of control rather than a fixed arbiter [24,29].

We adopt this shift but with a crucial innovation: centralizing generativity. Our Generative Orchestrator composes both symbolic and sub-symbolic proposals into a single decision plus a traceable rationale. This move is epistemological as much as architectural: agent outputs are interpreted as partial contributions (perceptual, narrative, intentional, or normative) to an unfolding situation, aligning with Agentic AI’s emphasis on role clarity, human oversight, and transparent traces.

Operational loop: The end-to-end message processing, retrieval, synthesis, and guardrail validation flow follows the pipeline defined in Section 3.3; here, we emphasize why we centralize generativity and how Precedent-Guided Synthesis differs from mechanical aggregation [24].

Orchestrator Mechanism: Precedent-Guided Synthesis

The Orchestrator transforms role-tagged vectors into decisions via a four-stage process that acknowledges the dual nature of agent outputs:

Retrieve precedents: Query a vector index of past justification graphs using current role vectors as keys to obtain top-k similar episodes. For symbolic agents (reactive and model-based), similarity metrics use numerical distance measures. For epistemic agents (goal and utility-based), semantic embeddings capture interpretive similarity.

Align constraints and goals: Filter precedents by hard constraints (safety and legal) from symbolic agents and context keys (location and policy version) from epistemic agents. This dual filtering respects that symbolic constraints are binary, while epistemic considerations admit degrees.

Simulate and adapt: Build a structured prompt that includes (a) the current role vectors and (b) the precedent snippets. The LLM proposes action_template (params) (for example: {route = B, speed_cap = 0.8 × v_limit, headway = 2.5 s}) and a passenger-facing explanation. The generative model here bridges symbolic precision with epistemic interpretation, leveraging its powerful semantic capabilities to perform Precedent-Guided Synthesis over localized agent vectors and stored policies.

Validate and finalize: A rule/guardrail checker verifies action_template (params) against the hard constraints. If violations are found or required information is missing, the Orchestrator issues clarification requests to the relevant roles and then re-prompts. The outputs are the action, explanation, and justification graph linking role claims to the decision.

Illustrative prompt skeleton (abridged):

• ⟨context⟩:= {time, location, constraints}
• ⟨perceptual⟩:= [{event, confidence, latency}, …]
• ⟨narrative⟩:= [{hypothesis, likelihood, counterfactuals}, …]
• ⟨intentional⟩:= [{goal, priority, admissible_actions}, …]
• ⟨normative⟩:= [{metric, score, risk, guardrail}, …]
• Task: “Select action; produce passenger-facing explanation citing

contributing roles; flag uncertainties; request clarifications

if thresholds unmet.”

Adaptive feedback: Because perceptual and narrative modules update continuously, changes (e.g., traffic clears; new hazard) trigger vector deltas that the Orchestrator reads on the next cycle, revising both action and explanation. Such asynchronous, event-driven coordination is standard in modern agent stacks (e.g., shared queues/ROS-style messaging) and has been validated in embodied systems [29].

Why centralize generativity? Rather than embedding a generative component inside every agent, we keep sub-agents deterministic and lightweight (rules, simulators, and estimators) and centralize creativity, explanation, and negotiation in the Orchestrator (see Figure 3).

This yields the following: (i) modularity: roles can be swapped/added without refactoring prompts across the system; (ii) explainability: one locus produces a justification graph and role attribution; and (iii) responsiveness: prompts adapt to new vectors in real time. Centralization also supports the trace requirements now advocated for in accountable human–AI workflows.

Generative orchestration reframes synthesis as interpretation: instead of collapsing inputs into a scalar decision, it mediates diverse agent views into coherent, value-sensitive action, providing an explanation for the practical instantiation of an epistemic ecology in motion.

5.2. The Orchestrator as an Epistemic Continuum

The key insight driving our orchestration design is that different agent types require different processing strategies. Reactive and model-based agents produce formally verifiable outputs: sensor readings, state estimates, and trajectory predictions that can be processed through traditional computational methods. Goal-based and utility-based agents generate interpretive content: objectives, values, and ethical considerations that require semantic understanding. This dichotomy in processing requirements is architecturally resolved by the Orchestrator’s dual operational modes: Reflex Mode for symbolic processing and Generative Mode for semantic mediation. The Orchestrator modulates its operation along this epistemic continuum, matching its processing to the nature of incoming information.

Although implemented as a single coordination layer, the Orchestrator operates in two distinct modes:

Reflex Mode (arbitration-like) provides low ambiguity and tight timing. For perceptual and model-based inputs—which are often deterministic and time-critical—the Orchestrator behaves like a classical arbiter: prioritize, gate, or pass through per safety margins/thresholds with minimal interpretive work. This mirrors embodied stacks that separate deterministic low-level control from higher-level cognition [29]. In this mode, symbolic processing dominates; the system rapidly evaluates formal constraints, checks physical feasibility, and executes pre-validated action templates.

Generative Mode (generative-interpretive) provides goals/values under uncertainty. For intentional and normative inputs, such as partial goals, trade-offs, and risk/fairness metrics, the Orchestrator engages its generative capacity, powered by large language models (LLMs) trained on vast data corpora, to perform semantic mediation. This capability is activated specifically to process the epistemic content generated by the goal-based and utility-based agents. This process requires the system to request clarifications, synthesize counterfactuals, and produce explanations that link actions to the value landscape and institutional constraints. This corresponds to the co-discovery view in which agents and humans co-construct justification and keep ethical limits explicit [9]. Here, the system must interpret meaning, not just process data: understanding what “passenger comfort” means in context, how “dignity” translates to behavioral choices, or why certain actions might violate unwritten social norms.

This continuum is not characterized by inconsistency but by adaptation to a heterogeneous system: a single, rigid strategy would either over-engineer routine control or underperform in ethically sensitive contexts. By spanning arbitration through semantic synthesis, the Orchestrator becomes a unifying generalization of the classical arbiter, suited to domains that blend routine control with situational nuance (e.g., autonomous vehicles and smart environments).

The dual-mode operation reflects a deeper architectural principle: acknowledging that intelligence requires both reactive competence (Brooks’ insight) and deliberative reasoning (classical AI’s strength). Our Generative Orchestrator does not choose between these paradigms but dynamically integrates them based on situational demands. When a child suddenly runs into the street, reflex processing ensures immediate braking. When navigating a complex social scenario, such as a construction zone with human workers, generative processing enables appropriate behavioral nuance.

Frameworks that demonstrate concurrent modules and message-bus memory support this design envelope in practice [7,8,23]. The next section details the role interfaces (vector schemas and guardrails), the prompt repertoire for mediation, and the engineering pipeline that links shared memory, retrieval, and LLM-based synthesis to runtime decisions.

5.3. Illustrative Runtime Walkthrough: Rainy Urban Intersection

As defined in Section 4.7, the Rainy Urban Intersection scenario integrates narrative and multi-agent coordination, where perceptual, model-based, goal-based, and utility-based agents interact through semantic mediation under the Generative Orchestrator. Building on that conceptual foundation, this section focuses on the hybrid dual-lane implementation that operationalizes the orchestration principle in runtime execution. The design introduces two complementary lanes: a Reflex Lane for time-critical symbolic processing and a Generative Lane for interpretive, value-aligned synthesis. This dual-lane architecture is required to balance real-time responsiveness with semantic depth, ensuring that safety-critical reflexes and deliberative reasoning coexist within a unified orchestration cycle. By narrating the decision process step by step, this walkthrough clarifies the dynamic coordination between rapid safety-critical responses and value-aligned deliberation, illustrating how the hybrid orchestration maintains both latency performance and interpretive depth under uncertain conditions.

The vehicle approaches a zebra crossing on wet asphalt. A pedestrian edges toward the curb; traffic is dense; the rider’s preference tolerates a slight delay, while safety and legality remain strict constraints. The sensors report reduced friction, and the predictive models extend the stopping distance accordingly.

The Orchestrator initiates its dual-lane process. The Reflex Lane integrates the friction estimate with motion forecasts and commits a safe deceleration template to stabilize the situation. In parallel, the Generative Lane begins assembling context: legal yield rules, comfort envelopes, and timing tolerances, preparing a more articulated plan. Both lanes operate in the same state and share a decision ID, ensuring seamless hand-offs and traceability.

The Orchestrator operates through two synchronized inference lanes: a Reflex Lane, which fuses perceptual and model-based inputs for rapid safety-critical action, and a Generative Lane, which performs value-aligned semantic mediation and explanation. Figure 4 illustrates the dual-lane structure underlying the runtime walkthrough presented in this section.

Safety-Critical Separation of Control Paths

To directly address the safety implications of using a generative model in an autonomous system, we emphasize that the dual-lane architecture strictly separates deterministic safety-critical control from LLM-mediated semantic reasoning.

The Reflex Lane executes all braking, collision avoidance, and near-field control using classical, verifiable, non-LLM controllers. This lane operates at high frequency, is fully deterministic, and has direct access to actuators. In any emergency or low-latency scenario, the Reflex Lane bypasses the Generative Orchestrator entirely.

The Generative (LLM) Lane never issues raw actuation commands. Instead, it performs high-level semantic synthesis—interpreting goals, values, and preferences—and outputs proposed strategic actions, which are then passed through guardrails and filtered by the Reflex Lane before execution.

Thus, the LLM is never in the safety-critical control loop. Instead, it governs contextual interpretation and long-horizon decision-making, while deterministic controllers guarantee safety. Its role is strategic route planning and parameter tuning (e.g., comfort adjustment) within safe bounds verified by the symbolic guardrail layer.

Once the immediate margin is secured, the Generative Lane finalizes the policy-aligned plan, confirming legal constraints, adjusting deceleration for comfort, and accepting a modest arrival delay. A concise passenger-facing explanation is generated (“Slowing early due to wet surface and crossing pedestrian; arrival + 12 s”), while a more detailed rationale is stored for engineering and regulatory traceability.

The Reflex and Generative Lanes are complementary rather than sequential. While the Generative Lane resolves values and goals, the Reflex Lane can still react to fresh evidence (e.g., a cyclist entering the crosswalk) and, if needed, pre-empt with a safer template. Once uncertainty drops, the Generative Lane resumes ownership of the plan without any explicit “mode switch”; the internal scheduler simply responds to the evolving temporal and informational character of the situation.

What Gets Recorded

Every committed decision yields two artifacts tied to the same decision ID: (1) a user one-liner (kept short to minimize cognitive load) and (2) a rationale trace citing the decisive signals, forecasts, constraints, and utility weights that supported the choice. Telemetry (latency and confidence) and safety checks (e.g., right-of-way and speed limits) are associated with that ID, enabling post hoc analysis and ablation without replaying raw sensor data.

Failure and Uncertainty Handling

If sensors degrade or a deadline looms, the Reflex Lane defaults to safe templates and marks the reason in the trace (e.g., “low confidence in friction estimate”). The Generative Lane re-enters once confidence returns. If an actuator rejects a command, the Orchestrator advances with the next admissible safe action; exceptions are logged under the same decision ID for continuity.

Interfaces and Boundaries

The Orchestrator does not replace perception or vehicle dynamics. It coordinates their outputs with the goal/value context into a single committed action plus explanation. Policy and ethics are not encoded inside the Orchestrator; they are consumed from the system’s goal/value context. Precedents (recent similar episodes) can be consulted by the Generative Lane to speed justification, but they remain advisory.

Learning and Carry-Over

After the crossing, the system stores a compact episode card: pivotal signals, committed actions and outcomes, and (when available) the rider’s comfort tolerance. Future retrieval of similar conditions can tighten both the first action and the explanation without changing any safety constraints.

This illustrative episode demonstrates how the hybrid orchestration architecture integrates immediate reflexive control with deliberative semantic mediation, achieving both safety-critical responsiveness and value-aligned explainability within a single, traceable decision cycle.

6. Conclusions

This paper presents a novel extension of Brooks’ subsumption architecture that bridges the foundational principles of reactive control with the requirements of modern Agentic AI. By replacing the traditional priority arbiter with a Generative Orchestrator that performs semantic mediation, we have demonstrated how autonomous systems can achieve both the real-time responsiveness that made subsumption successful and the interpretive sophistication demanded by contemporary applications.

Our architectural contribution addresses three critical challenges in autonomous system design. First, it resolves the long-standing tension between reactive and deliberative approaches by enabling dynamic integration rather than forcing a choice between paradigms. The epistemic continuum enables the system to adapt its processing strategy—from rapid, constraint-based reactions to thoughtful, value-informed deliberation—fluidly in response to situational demands. Second, it provides a principled solution to the representation debate that has persisted since Brooks’ original critique. Our hybrid approach demonstrates that intelligence requires not the absence of representation but rather the intelligent integration of multiple representational modes, from direct sensory mappings to abstract value models. Third, it addresses the explainability gap that limits deployment of both reactive systems and deep learning approaches, generating traceable justifications that link decisions to contributing epistemic perspectives.

The transformation of subsumption layers into epistemic agents, i.e., perceptual, narrative, intentional, and normative, represents more than a technical upgrade. It reconceptualizes autonomous behavior as emerging from an epistemic ecology where diverse forms of knowledge interact productively. This ecological framing acknowledges that real-world intelligence requires multiple, irreducible means of knowing: immediate awareness of present conditions, a narrative understanding of causal relationships, the intentional structure of goals and constraints, and a normative evaluation of values and trade-offs. The Generative Orchestrator serves as the semantic bridge that enables these perspectives to inform collective action while preserving their distinct epistemic contributions.

Our case study of urban autonomous driving validates the practical effectiveness of this approach. The system successfully navigates complex scenarios that require split-second reactions and nuanced social reasoning while maintaining safety constraints and adapting to passenger preferences and environmental conditions. Performance metrics demonstrate significant improvements over classical approaches: 94% constraint satisfaction versus 76% for rule-based systems, with explanation quality rated 4.3/5.0 for traceability. These results confirm that semantic mediation can effectively synthesize heterogeneous agent outputs without sacrificing real-time performance, which is essential for safety-critical applications. All results were obtained on the Python PoC deployed on an NVIDIA platform (see Experimental Setup).

The architectural principles established here—parallel epistemic processing, semantic mediation through Generative AI, integrated explainability, and value-aligned decision-making—have implications beyond autonomous vehicles. The framework applies to any domain where autonomous systems must balance reactive competence with deliberative reasoning, from healthcare robotics to financial trading systems. By demonstrating how Generative AI can enable rather than merely augment agentic behavior, we provide a template for building autonomous systems that are simultaneously efficient and interpretable, as well as robust and adaptive.

Several limitations merit acknowledgment and suggest directions for future work. The current implementation relies on large language models that introduce computational overhead and potential brittleness in edge cases. Future research should explore more efficient architectures for semantic mediation, potentially through specialized models trained specifically for orchestration tasks. The precedent system, while effective for gradual learning, requires careful curation to prevent propagation of suboptimal decisions. Developing principled methods for precedent selection and retirement remains an open challenge. Additionally, while our evaluation demonstrates strong performance in simulated environments, extensive real-world deployment will be necessary to validate the architecture’s robustness across the full spectrum of edge cases and adversarial conditions.

Looking forward, this work contributes to the broader evolution from Generative AI to Agentic AI by showing how generative capabilities can serve as foundational technology for autonomous agency. As the field moves toward systems that not merely respond to prompts but actively pursue goals and adapt to environments, the ability to semantically mediate between different forms of reasoning becomes increasingly critical. Our Generative Orchestrator represents one instantiation of this principle, but the underlying concept of using Generative AI to bridge symbolic and epistemic reasoning has broad applicability.

In conclusion, by extending Brooks’ subsumption architecture through generative orchestration, we have created a framework that honors the foundational insights of reactive robotics while addressing the demands of modern autonomous systems. The architecture demonstrates that the path from reactive control to fully realized Agentic AI need not abandon the principles that made early autonomous systems successful but can build upon them through semantic integration. As autonomous systems increasingly participate in human society, their ability to combine immediate responsiveness with interpretive understanding, maintain behavioral autonomy while providing comprehensible explanations, and pursue goals while respecting values will determine their acceptance and effectiveness. This work provides both theoretical foundations and practical mechanisms for achieving these capabilities, contributing to the development of autonomous systems that are not merely intelligent in isolation but genuinely agentic in their engagement with the world.

Finally, we note that although the architecture incorporates a generative model for semantic mediation, all actuator-level decisions in safety-critical contexts remain under the authority of the deterministic Reflex Lane. The LLM provides contextual synthesis, not low-level control. This architectural separation ensures that the system inherits the interpretive benefits of generative models without exposing safety-critical behavior to the uncertainty introduced by generative models.