AgenticRei: AI Governance & Multi-Agent Architecture

• AgenticRei is an AI framework that treats agents as structured entities with memory, tool use, and external deontic governance.
• It integrates explicit communication protocols and multi-agent orchestration to enable coordinated, autonomous multi-turn workflows.
• The framework emphasizes accountability and dynamic decision-making through formal agent specifications and runtime policy enforcement.

AgenticRei denotes a line of agentic AI design in which LLM agents are treated not as isolated prompt-response systems but as structured, memory-bearing, tool-using, and governable actors. In the literature, the name appears in two closely related senses: as a prospective architecture label for agentic recommender and multi-agent systems, and as an explicit runtime governance framework based on deontic policy reasoning outside the LLM. Across these uses, AgenticRei is associated with formal agent specifications, multi-agent orchestration, explicit communication protocols, hierarchical memory, and externally enforced governance over tool calls and agent-to-agent messaging (Maragheh et al., 2 Jul 2025, Joshi et al., 17 Jun 2026).

1. Conceptual scope

AgenticRei is situated within the broader shift from reactive generative systems to agentic AI systems that can autonomously pursue goals, make decisions, and execute complex, multi-turn workflows over extended periods (Mukherjee et al., 1 Feb 2025). In this setting, autonomy is not limited to text generation. It includes sustained action, tool invocation, adaptation to environmental change, and coordination with other agents or humans. The same literature emphasizes that this transition changes where responsibility, liability, and control reside, because the system itself books, negotiates, purchases, or otherwise acts, rather than merely advising a human (Mukherjee et al., 1 Feb 2025).

A second conceptual strand argues that current LLM-centered agentic AI remains insufficiently “agentified” unless it is complemented by explicit models of cognition, cooperation, and governance. In that formulation, AgenticRei is treated as a plausible design target for a BDI-inspired core agent layer, a social reasoning layer, a communication layer, and a learning/tool layer, with LLMs used as tools for perception, language, and suggestion rather than as the whole architecture (Dignum et al., 21 Nov 2025). This positions AgenticRei at the intersection of LLM-agent engineering and the Autonomous Agents and Multi-Agent Systems tradition.

A third strand is narrower and more concrete. “Deontic Policies for Runtime Governance of Agentic AI Systems” introduces AgenticRei as a runtime governance architecture for agentic AI systems. There, the name refers to a policy engine that enforces permissions, prohibitions, obligations, dispensations, and explicit rule priorities, grounded in OWL ontologies and executed entirely outside the LLM at the action boundary (Joshi et al., 17 Jun 2026). Taken together, these papers depict AgenticRei as both an architectural blueprint for agentic systems and a governance substrate for controlling them.

2. Formal agent, memory, and multi-agent structure

In the recommender-systems perspective, an LLM-based agent is defined as

$$A_{\mathrm{LLM}} = \bigl(\mathcal{M}, \mathcal{I}, \mathcal{O}, \mathcal{F}, \Omega\bigr),$$

where $\mathcal{M}$ is the language-model core, $\mathcal{I}$ the input space, $\mathcal{O}$ the output space, $\mathcal{F}$ the set of tools or functions, and $\Omega$ the memory or state. At each step,

$o_t = f_{\mathcal{M},\mathcal{F}}(i_t,\omega),$

with current input $i_t$, retrieved memory $\omega \subseteq \Omega$, and action $o_t$ taking the form of a reply, tool call, or message to another agent. This formulation is presented as the minimal contract for a system like AgenticRei: one must specify the model or models, observable inputs, allowable actions, tool set, and memory structure (Maragheh et al., 2 Jul 2025).

The corresponding multi-agent system is

$\mathcal{M}$0

with $\mathcal{M}$1 a finite set of agents, $\mathcal{M}$2 a shared environment, and $\mathcal{M}$3 an interaction protocol. Here $\mathcal{M}$4 is a communication matrix specifying which directed messages are allowed, and $\mathcal{M}$5 is a set of message schemas such as query, candidate_list, compliance_report, tool_call, or ranked_list (Maragheh et al., 2 Jul 2025). This makes communication explicit rather than implicit in prompt text.

Memory is first-class in this formalism. Update and retrieval are written as

$\mathcal{M}$6

with memory items

$\mathcal{M}$7

where $\mathcal{M}$8 is a key, $\mathcal{M}$9 a value, and $\mathcal{I}$0 metadata containing timestamp, label, and update count. The labels distinguish episodic, semantic, and procedural memory. Retrieval is formalized through a relevance score $\mathcal{I}$1 and a $\mathcal{I}$2 operator; retention is controlled by a decay policy of the form $\mathcal{I}$3, with eviction below threshold (Maragheh et al., 2 Jul 2025). The practical implication is a memory subsystem combining vector retrieval, summarization, retention, and typed memory roles rather than an undifferentiated context buffer.

Within this framework, several recurring roles are proposed for AgenticRei-like systems: user-facing chat agents, episodic retrieval agents, validation or NLI agents, specialized-agent callers, domain agents, collection-consistency agents, ranking agents, and evaluator or compliance agents (Maragheh et al., 2 Jul 2025). The resulting architecture is explicitly compositional: planning, retrieval, checking, ranking, explanation, and compliance are distributed across roles rather than collapsed into one monolithic prompt.

3. Cognitive organization, protocols, and institutional embedding

AAMAS-oriented work adds a second layer of formalization to the AgenticRei idea by insisting on explicit cognitive and social models. In that account, BDI architectures provide beliefs, desires, and intentions as explicit state rather than leaving “intentionality” implicit in prompts. Standard modal operators are used:

$\mathcal{I}$4

with rules such as

$\mathcal{I}$5

and intention dropping when $\mathcal{I}$6 is achieved or known impossible (Dignum et al., 21 Nov 2025). The significance is that goal adoption, persistence, and abandonment become checkable design objects.

The same perspective emphasizes formal communication acts and protocols. KQML and FIPA-ACL are cited as message frameworks in which acts such as inform, request, and query-ref carry semantics in terms of mental states rather than remaining unstructured natural-language utterances. A request can be interpreted as an attempt to induce an intention; an inform act is correct only if the sender believes the proposition and intends the receiver to believe it (Dignum et al., 21 Nov 2025). For AgenticRei, this means protocol semantics can be made explicit, auditable, and institutionally constrained.

Mechanism design and normative systems extend this architecture into the social domain. Utility functions $\mathcal{I}$7, social choice functions $\mathcal{I}$8, and equilibrium reasoning are proposed as the means for structuring coordination in settings such as logistics or scheduling, while deontic operators

$\mathcal{I}$9

represent obligation, permission, and prohibition within institutional settings (Dignum et al., 21 Nov 2025). In this formulation, AgenticRei is not merely a tool-using LLM agent. It is a participant in organizations, roles, protocols, and sanction structures.

This broader “agentifying” move matters because it reframes transparency and accountability. Instead of explaining behavior only through post hoc textual rationales, one can explain it by reference to beliefs, intentions, active norms, protocol state, and institutional commitments (Dignum et al., 21 Nov 2025). A plausible implication is that the tuple-based formalism of the recommender literature and the deontic governance framework of the policy literature are complementary rather than competing: the former specifies what an agent is and how agents coordinate, while the latter constrains what those agents may do.

4. Runtime governance through deontic policy

In its most concrete form, AgenticRei is a runtime governance framework for agentic AI systems. It uses a deontic policy language built on the Rei framework, expressed as OWL and evaluated at runtime by a high-performance logic engine entirely outside the LLM. The same pipeline governs both tool invocations by the agent and agent-to-agent messages (Joshi et al., 17 Jun 2026). This externalization is central: enforcement is deterministic at the action boundary and does not rely on the LLM’s own policy interpretation.

The policy model includes five core constructs. deontic:Permission and deontic:Prohibition specify allow and deny conditions. deontic:Obligation specifies duties that arise when permissions are exercised, such as notifying a CISO after software installation. deontic:Dispensation waives obligations under stated constraints. metapolicy:RulePriority resolves conflicts between rules by explicitly specifying which rule overrides which (Joshi et al., 17 Jun 2026). Policies are aggregated by policy:Policy, often under metapolicy:ExplicitPermImplicitProh, which implements default deny.

The runtime path follows an extract-evaluate-apply pattern. A TripleExtractor intercepts outbound actions, constructs a triple of the form $\mathcal{O}$0, and filters credentials so that only issuers explicitly trusted by policy are passed to the engine. A PolicyEngine consults a triple store loaded with Rei policies and domain ontologies, returning permit, prohibit, or default-deny, plus any obligations attached through deontic:provision. Middleware then either executes the action and registers obligations with an ObligationManager, or blocks the action and returns a structured policy-violation result (Joshi et al., 17 Jun 2026).

The obligation lifecycle is operational rather than purely declarative. Obligations are created when a permission fires, tracked until discharge, waivable through a higher-priority dispensation, and escalated when deadlines are missed (Joshi et al., 17 Jun 2026). Ontological reasoning gives policies semantic reach across class hierarchies. A prohibition over phi:PHI, for example, automatically applies to phi:PatientTreatmentPlan when OWL reasoning infers subclass membership (Joshi et al., 17 Jun 2026). This makes policy coverage robust to ontology evolution.

The framework is explicitly positioned against XACML, Rego, and Cedar. Those systems address permit/prohibit constraints, but the paper argues that they do not provide obligation lifecycle management, dispensations, meta-policy conflict resolution, and ontological reasoning over domain class hierarchies in the same manner (Joshi et al., 17 Jun 2026). Prototype performance is reported as end-to-end latency below 10 ms per request, with RDFox query execution below 1 ms and the remaining time dominated by HTTP overhead (Joshi et al., 17 Jun 2026). This is presented as sufficient for synchronous interception of tool calls and agent-to-agent messages.

5. Learning, personalization, and verifier-guided optimization

Around the core AgenticRei concept, several papers describe learning mechanisms for “AgenticRei-style” systems. Personalized Agentic RL models the environment as a user-conditioned MDP

$\mathcal{O}$1

with policy

$\mathcal{O}$2

and decomposed reward

$\mathcal{O}$3

Its central optimization method, PARPO, decouples generic and personalized reward streams and uses per-user anchors to stabilize personalized advantages, while PSGM organizes users, skills, tools, and scenarios in a heterogeneous graph for preference-aligned retrieval (zhang et al., 22 May 2026). On ETAPP-Original, the framework reports Judge 0.7708 versus 0.7411 for SkillRL; on ETAPP-Hard, 0.7275 versus 0.7010 (zhang et al., 22 May 2026).

A second line of work focuses on credit assignment in agentic RL. TRIAGE introduces role-typed credit assignment over environment-facing action segments, classifying them as decisive progress, useful exploration, no-progress infrastructure, or regression, and then correcting trajectory-level GRPO credit with bounded role-conditioned process rewards. The segment-level correction is

$\mathcal{O}$4

with $\mathcal{O}$5 (Xu et al., 30 Jun 2026). On ALFWorld and WebShop, TRIAGE improves success rates over GRPO and reduces environment-facing turns by an additional $\mathcal{O}$6 and $\mathcal{O}$7 on completed rollouts relative to GRPO (Xu et al., 30 Jun 2026). This suggests a route for AgenticRei-like systems to differentiate exploration from regression instead of broadcasting one final verifier score to every action.

Skill accumulation is treated in ReSkill, which reconciles skill creation with policy optimization inside the RL loop. It uses assertion-driven diagnosis of failures, within-group rollout sampling to compare old and new skill banks during GRPO training, and Thompson Sampling with adaptive discounting to balance exploration and exploitation as the policy evolves (He et al., 1 Jun 2026). On ALFWorld with Qwen3-4B, ReSkill reaches 89.8% overall versus 83.9% for SkillRL; on Qwen3-8B it reaches 92.7% overall and 95.3% on unseen tasks (He et al., 1 Jun 2026). This is relevant to AgenticRei because it operationalizes procedural memory as an evolving skill library rather than static prompt text.

Verifier-guided optimization is extended to multimodal settings by Argos, an agentic verifier that selects teacher-derived and rule-based scoring functions to evaluate final-response accuracy, spatiotemporal localization, and reasoning quality, then combines them with a gated multi-objective reward:

$\mathcal{O}$8

The paper argues that SFT on curated reasoning traces is insufficient because RL with outcome-only rewards leads models to collapse to ungrounded solutions, whereas online verification with Argos maintains grounding and improves state-of-the-art results across spatial reasoning, hallucination, embodied AI, and robotics benchmarks (Tan et al., 3 Dec 2025). For AgenticRei, this provides a template for turning verifiers into explicit reward agents rather than treating reward modeling as a single scalar head.

6. Canonical use cases, challenge families, and broader implications

The recommender-systems literature presents four end-to-end templates that function as canonical AgenticRei use cases. The first is interactive party planning, formalized as an interactive recommendation function

$\mathcal{O}$9

under thematic, dietary, and budget constraints. The second is user simulation and offline evaluation, with recommender $\mathcal{F}$0, user simulator $\mathcal{F}$1, and long-horizon evaluation functional

$\mathcal{F}$2

The third is contextual and multi-modal furniture recommendation, combining text, image, and profile inputs under compatibility constraints. The fourth is brand-aligned recommendation explanation, where explanation generation is constrained by factual consistency and brand-policy compliance (Maragheh et al., 2 Jul 2025). These cases jointly emphasize decomposition, memory specialization, multi-modal perception, and evaluator agents.

The same paper identifies five cross-cutting challenge families: protocol complexity, scalability, hallucination and error propagation, emergent misalignment including covert collusion, and brand consistency and control (Maragheh et al., 2 Jul 2025). Hallucination is formalized through per-agent validity indicators and propagating invalid messages; emergent misalignment includes private protocols, filter bubbles, and covert collusion; brand control is formalized by a policy-compliance predicate over messages. These are not presented as peripheral concerns but as the risk map for agentic recommender design.

Broader work on agentic AI reinforces that these concerns are institutional as well as technical. “Agentic AI: Autonomy, Accountability, and the Algorithmic Society” frames autonomous execution as creating a “moral crumple zone,” in which responsibility is diffused across developers, deployers, users, platforms, and data providers (Mukherjee et al., 1 Feb 2025). “The Agentic Economy” distinguishes unscripted interactions from unrestricted interactions and argues that the architecture of agent-to-agent communication will determine whether markets evolve toward walled gardens or an open web of agents (Rothschild et al., 21 May 2025). A plausible implication is that AgenticRei’s protocol and governance choices are not merely implementation details; they shape who may communicate, who controls discovery, and how accountability is allocated.

Industrial evidence from software product development points in the same direction. A systematic review over 92 primary studies reports that output verifiability is the primary enabler of agentic adoption, that Planner-Executor-Reviewer is the dominant architectural pattern, and that industrial mitigation strategies converge on confining agent actions to verifiable, bounded spaces (Apostolou et al., 14 May 2026). This aligns closely with both the tuple-and-protocol formalism of AgenticRei-like recommenders and the deontic runtime governance model of the policy framework.

In this combined view, AgenticRei is best understood not as a single algorithm but as an architectural doctrine: explicit agents, explicit protocols, explicit memory, explicit governance, and explicit verification. The literature presents it as a response to the limits of monolithic prompt-driven autonomy and as a foundation for agentic systems that are memory-augmented, tool-using, multi-agent, and externally governable (Maragheh et al., 2 Jul 2025, Joshi et al., 17 Jun 2026).