AGENT+P: Pattern for Controlled Agent Systems

• AGENT+P is an architectural pattern that pairs an operative agent with an explicit planning, policy, or control layer to enhance long-horizon task performance.
• It separates global planning from local execution by employing structures such as UI transition graphs, Q-tables, and pseudocode plans to guide decision-making.
• Empirical evidence shows AGENT+P improves success rates and efficiency across diverse domains, including UI automation, workflow optimization, and reinforcement learning governance.

AGENT+P denotes an architectural pattern in which an operative agent or multi-agent substrate is coupled to an explicit planning, policy, or control layer that shapes trajectories, constrains action choices, or governs interaction. In one direct usage, it names a plug-and-play UI automation framework that uses symbolic planning over a UI Transition Graph; across related work, the same pattern appears as Q-table-guided workflow construction, pseudocode-style planning, per-agent context scoping, tool-mediated decoding, contract design, and governance or evaluation layers (Ma et al., 7 Oct 2025, Lin et al., 18 Sep 2025, Cao et al., 2 Jun 2025, Patel, 9 Apr 2026, Rahman et al., 1 Jun 2026, Ivanov et al., 2024, Aiersilan et al., 19 Mar 2026, Jia et al., 9 Oct 2025).

1. Conceptual scope

The most explicit formalization appears in "Agent+P: Guiding UI Agents via Symbolic Planning" (Ma et al., 7 Oct 2025). There, the central claim is that LLM-based UI agents perform local perception and action execution effectively but hallucinate on long-horizon tasks because they lack understanding of the global UI transition structure. AGENT+P addresses this by separating global navigation from local grounding: the agent remains the executor, while a symbolic planner computes a high-level route over an explicit graph.

Other works use nearly the same decomposition in different domains. PriorDynaFlow describes AGENT+P as a set of specialized agents governed by an adaptive planning or policy module that decides who acts next, when to stop, and how to shape the workflow for each task (Lin et al., 18 Sep 2025). PGPO treats the pattern as an LLM agent equipped with a program-like planning language and a planning-aware preference optimization objective (Cao et al., 2 Jun 2025). DACS implements per-agent steering by giving the orchestrator the full context of exactly one agent while compressing all others to registry summaries (Patel, 9 Apr 2026). AgentPLM frames protein design as a sequential decision process with tool use, where the PLM is elevated from a passive generator to a policy in a POMDP (Rahman et al., 1 Jun 2026).

This suggests that AGENT+P is best understood not as a single algorithm, but as a family of neuro-symbolic or policy-augmented systems in which the “AGENT” component executes, observes, or interacts, while the “+P” component introduces explicit structure that is not left to implicit next-token reasoning alone.

2. Canonical architectural pattern

Across the literature, AGENT+P systems repeatedly instantiate three roles: an execution substrate, an explicit coordination object, and a mechanism that binds them at runtime. The execution substrate may be a single model, a role-specialized agent pool, or a distributed agent society. The coordination object may be a graph, plan, contract, registry, memory bank, or probabilistic governance score. The runtime mechanism then selects actions, routes control, filters context, or assigns incentives.

System	Agent substrate	“+P” layer
Agent+P (Ma et al., 7 Oct 2025)	Existing LLM-based UI agent	UTG + PDDL symbolic planner
PriorDynaFlow (Lin et al., 18 Sep 2025)	Role-defined multi-LLM workflow	Q-table policy + a priori next-agent decisions
PGPO (Cao et al., 2 Jun 2025)	ReAct-style LLM agent	P-code Plans + preference optimization
DACS (Patel, 9 Apr 2026)	Orchestrator with concurrent agents	Focus$(a_i)$ context scoping
AgentPLM (Rahman et al., 1 Jun 2026)	ESM-2 650M PLM	RAD + CAPO over tool calls
VeriAgent (Wang et al., 18 Mar 2026)	Programmer/Correctness/PPA agents	Tool feedback + Evolved Memory Mechanism

The same architectural logic extends beyond those six systems. Agent GPA adds a specialized evaluation layer over the Goal–Plan–Action loop (Jia et al., 9 Oct 2025). SWARM adds a governance engine with continuous-valued risk metrics and configurable levers such as transaction taxes, circuit breakers, reputation decay, and random audits (Aiersilan et al., 19 Mar 2026). Principal-agent reinforcement learning treats the principal as a policy over contracts rather than environment actions (Ivanov et al., 2024). ANP pushes the same separation down to infrastructure, defining identity, negotiation, and application protocols for an Agentic Web (Chang et al., 18 Jul 2025).

3. Planning and policy mechanisms

A defining feature of AGENT+P is that planning is made explicit in a formal object. In the UI-automation formulation, the app is modeled as a UI Transition Graph $G = (\mathcal{U}, \mathcal{T}, \epsilon)$, where nodes are UI states, directed edges are transitions, and edge labels are actions $a = (w,e)$. Targeted UI automation is then written as a shortest-path problem over this graph,

$\pi^* = \arg\min_{\pi} \sum_{i=1}^{N} \kappa(a_i),$

with unit costs in the reported experiments, and the resulting plan is generated by Fast Downward with A* over a fixed PDDL domain (Ma et al., 7 Oct 2025).

PriorDynaFlow replaces symbolic shortest-path planning with a learned policy over workflow graphs. A workflow is a directed graph $W=(N,E)$ whose nodes are role-specialized agents and whose edges carry learned reward or penalty. The planning core is tabular Q-learning with update

$$Q_{\text{new}(s_t, a_t)} = (1 - \alpha) Q(s_t, a_t) + \alpha \big[ R_{s_t} + \gamma \max_{a} Q(s_{t+1}, a) \big],$$

and the Q-table is used to constrain a decision space rather than to select the next node directly. The current agent then makes an a priori choice from the top-$k$ candidates based on the current task state, executed nodes, and available roles (Lin et al., 18 Sep 2025).

PGPO makes planning explicit in language form rather than in graph search or value iteration. Its planning unit is a pseudocode-style step

$$P_s = (id, name, [parameter], [return\;value], [control\;flow]),$$

and a full P-code Plan is $(P_s, E)$, where $E$ is the set of task-specific planning entities. The plan is generated before the ReAct trajectory and is then optimized by a DPO-style objective that combines plan-level preferences and plan-following preferences (Cao et al., 2 Jun 2025).

DACS makes the control layer a deterministic context-construction rule. Registry mode keeps only lightweight status summaries; when agent $G = (\mathcal{U}, \mathcal{T}, \epsilon)$0 emits a SteeringRequest, the orchestrator enters Focus$G = (\mathcal{U}, \mathcal{T}, \epsilon)$1 mode with

$G = (\mathcal{U}, \mathcal{T}, \epsilon)$2

and $G = (\mathcal{U}, \mathcal{T}, \epsilon)$3 is never truncated. The objective is not search optimality but isolation of the steering interaction from cross-agent contamination (Patel, 9 Apr 2026).

A more structural formulation appears in "Structured Cooperative Multi-Agent Reinforcement Learning: a Bayesian Network Perspective" (Syed et al., 11 Oct 2025). There, the multi-agent process is encoded as a Bayesian network, and each agent’s exact local action value function is shown to depend only on a value dependency set $G = (\mathcal{U}, \mathcal{T}, \epsilon)$4. This yields a partially decentralized training–decentralized execution paradigm and a multi-agent policy gradient theorem whose critic and gradient depend only on structurally relevant agents, not the full system.

4. Tool, memory, and protocol substrates

In several AGENT+P systems, the planning layer is inseparable from tool use. AgentPLM expands the action space from amino acids to

$G = (\mathcal{U}, \mathcal{T}, \epsilon)$5

where $G = (\mathcal{U}, \mathcal{T}, \epsilon)$6 contains CALL tokens for ESMFold, FoldX, and AutoDock Vina, together with EOS. Reasoning-Augmented Decoding interleaves residue generation and tool calls, and when a CALL token is emitted the model does not advance position; it re-scores the same step after tool feedback. Tool outputs are embedded through a Tool Context Encoder, stored in a fixed-size Trajectory Memory Buffer with $G = (\mathcal{U}, \mathcal{T}, \epsilon)$7, and optimized end-to-end by Contrastive Agent Policy Optimisation (Rahman et al., 1 Jun 2026).

VeriAgent uses a comparable closed-loop structure for RTL generation, but with a different substrate. It combines a Programmer Agent, Correctness Agent, PPA Agent, and Memory Manager, and integrates simulation, Yosys, OpenROAD, and the NanGate45 library. The physical objective is collapsed into

$G = (\mathcal{U}, \mathcal{T}, \epsilon)$8

with Relative PPA Score normalized by the original benchmark implementation. Its Evolved Memory Mechanism stores Rule Memory, Structure Memory, and EDA Signal Memory as trigger–guidance–metadata nodes that are inserted, refined, or discarded after each execution trajectory (Wang et al., 18 Mar 2026).

ANP generalizes the same architectural separation to internet-scale interoperability. Its three-layer stack consists of an identity and encrypted communication layer based on DID and end-to-end encrypted communication, a meta-protocol negotiation layer for dynamic capability negotiation, and an application protocol layer centered on Agent Description Protocol and Agent Discovery Protocol. Here the “+P” element is infrastructural rather than task-local: it defines the protocol substrate through which agents authenticate, discover one another, and negotiate how to talk (Chang et al., 18 Jul 2025).

These systems show that AGENT+P does not require the planning layer to be purely symbolic. It may instead be embodied in tool-call tokens, memory evolution, or protocol negotiation, provided that execution is constrained by explicit intermediate structure.

5. Incentive, governance, and evaluation layers

One branch of the literature moves from planning to incentives. "Principal-Agent Reinforcement Learning: Orchestrating AI Agents with Contracts" formalizes a hidden-action principal–agent MDP

$G = (\mathcal{U}, \mathcal{T}, \epsilon)$9

where the principal does not act in the environment and instead chooses contracts $a = (w,e)$0. The agent’s reward is $a = (w,e)$1, the principal’s reward is $a = (w,e)$2, and the solution concept is subgame-perfect equilibrium obtained by alternating agent best response and principal contract optimisation (Ivanov et al., 2024).

SWARM extends the same logic from one principal and one or more agents to a system-wide governance layer over agent societies. Each interaction receives a soft label

$a = (w,e)$3

interpreted as $a = (w,e)$4, and governance acts through transaction taxes, circuit breakers, reputation decay, random audits, externality internalization, staking, and collusion detection. The system-level safety metrics are explicitly distributional, including expected toxicity

$a = (w,e)$5

and quality gap

$a = (w,e)$6

Here the “+P” layer is governance over interaction distributions rather than planning over task trajectories (Aiersilan et al., 19 Mar 2026).

A third extension is ex post diagnosis. Agent GPA evaluates the operational loop of Goal, Plan, and Action through Goal Fulfillment, Plan Quality, Plan Adherence, Logical Consistency, and Execution Efficiency, with Tool Selection and Tool Calling as additional tool-level metrics. The judges output scores on $a = (w,e)$7 together with rationales and span IDs, thereby turning the planning layer into an explicit object of evaluation rather than only control (Jia et al., 9 Oct 2025).

This suggests that AGENT+P can be read along three axes: online control of trajectories, incentive shaping of behavior, and structured diagnosis of failures.

6. Empirical evidence across domains

The empirical record is heterogeneous but consistently favors explicit planning or policy layers over unstructured agent execution. On AndroidWorld, Agent+P improves the success rates of state-of-the-art UI agents by up to 14% and reduces the action steps by 37.7%; on the “Go to the privacy policy page” task, average actions drop from 6.1 to 3.8 and average time from 19.9s to 16.9s (Ma et al., 7 Oct 2025). PriorDynaFlow reports an average improvement of 4.05% over state-of-the-art baselines while reducing workflow construction and inference costs to only 30.68%–48.31% of existing methods (Lin et al., 18 Sep 2025). PGPO reports, for Llama-2-7B averaged over ALFWorld seen/unseen, WebShop, and TextCraft, 67.1 versus 62.6 for IPR, 60.9 for ETO, and 53.9 for SFT, and its analyses show lower invalid action rates and fewer omissions (Cao et al., 2 Jun 2025).

In orchestration, DACS reports 90.0–98.4% steering accuracy versus 21.0–60.0% for a flat-context baseline across eight synthetic scenarios, with wrong-agent contamination reduced from 28–57% to 0–14% and context efficiency ratios up to 3.53x. In Phase 4 with autonomous LLM agents, DACS exceeds the flat-context baseline by +17.2pp at $a = (w,e)$8 and +20.4pp at $a = (w,e)$9, with the advantage growing with $\pi^* = \arg\min_{\pi} \sum_{i=1}^{N} \kappa(a_i),$0 (Patel, 9 Apr 2026). In structured cooperative MARL, MAStAC improves convergence and final performance in both sparse and dense interaction regimes; in the 40-warehouse task, MAStAC approximated reaches $\pi^* = \arg\min_{\pi} \sum_{i=1}^{N} \kappa(a_i),$1 versus $\pi^* = \arg\min_{\pi} \sum_{i=1}^{N} \kappa(a_i),$2 for MADDPG and $\pi^* = \arg\min_{\pi} \sum_{i=1}^{N} \kappa(a_i),$3 for MATD3 (Syed et al., 11 Oct 2025).

In biology and hardware, the same architectural principle remains effective. AgentPLM reports state-of-the-art results across ThermoStab-75, AntibodyOpt-VH, EnzymeDesign-EC3, PPI-Interface, and ZeroShot-Fitness, with ThermoStab $\pi^* = \arg\min_{\pi} \sum_{i=1}^{N} \kappa(a_i),$4, antibody top-10% hit rate $\pi^* = \arg\min_{\pi} \sum_{i=1}^{N} \kappa(a_i),$5, enzyme design $\pi^* = \arg\min_{\pi} \sum_{i=1}^{N} \kappa(a_i),$6, PPI $\pi^* = \arg\min_{\pi} \sum_{i=1}^{N} \kappa(a_i),$7, and zero-shot $\pi^* = \arg\min_{\pi} \sum_{i=1}^{N} \kappa(a_i),$8. The antibody result is 1.91× ProtAgent and 4.23× ESM-2 (Rahman et al., 1 Jun 2026). VeriAgent reaches Relative PPA Score $\pi^* = \arg\min_{\pi} \sum_{i=1}^{N} \kappa(a_i),$9 with Gemini, compared with $W=(N,E)$0 for the original designs and $W=(N,E)$1 for ChipSeek-R1, while also reporting VerilogEval-Machine pass@1 $W=(N,E)$2, VerilogEval-Human pass@1 $W=(N,E)$3, and RTLLM v1.1 Func@5 $W=(N,E)$4 (Wang et al., 18 Mar 2026).

Evaluation and governance layers also show quantitative leverage. Agent GPA reports that its judges detect $W=(N,E)$5 TRAIL/GAIA test errors, or $W=(N,E)$6, and localize $W=(N,E)$7, or $W=(N,E)$8, with 86% agreement for targeted error localization (Jia et al., 9 Oct 2025). Principal-agent reinforcement learning achieves approximately optimal subgame-perfect behavior on randomly generated binary game trees and, in the Coin Game, attains near-optimal social welfare with about 30% of social welfare paid as subsidies while new black-box agents follow recommendations 80–90% of the time (Ivanov et al., 2024). SWARM finds that strict governance reduces welfare by over 40% without improving safety, and that aggressively internalizing system externalities collapses total welfare from $W=(N,E)$9 to $$Q_{\text{new}(s_t, a_t)} = (1 - \alpha) Q(s_t, a_t) + \alpha \big[ R_{s_t} + \gamma \max_{a} Q(s_{t+1}, a) \big],$$0 while toxicity remains invariant (Aiersilan et al., 19 Mar 2026).

7. Limitations and open problems

The literature also delineates the boundaries of the AGENT+P pattern. In symbolic UI planning, performance depends on UTG quality, correct target-node selection, and the determinism assumption of classical planning; static analysis may add infeasible edges, dynamic exploration may miss edges, and real GUIs may require contingent replanning (Ma et al., 7 Oct 2025). In Q-table-guided workflow construction, state abstraction can be too coarse or too fine, reward shaping is sensitive, and non-stationarity arises when roles, prompts, or base models change (Lin et al., 18 Sep 2025). PGPO improves generalization, but plan-following reward estimation requires Monte Carlo rollouts and initial P-code plans were generated by GPT-4o and then human-verified (Cao et al., 2 Jun 2025).

Tool-augmented systems introduce their own costs. AgentPLM is oracle-bound, tools such as Vina and ESMFold are expensive even with caching, and the method performs local correction without explicit backtracking (Rahman et al., 1 Jun 2026). VeriAgent limits correctness and PPA loops to at most two rounds, depends on NanGate45, Yosys, and OpenROAD, and has not been extended to full-chip or complex SoC-level designs (Wang et al., 18 Mar 2026). DACS, despite strong gains, was evaluated with scripted agents in Phases 1–3, only two model families, and a noisy contamination proxy in real-agent settings (Patel, 9 Apr 2026). ANP leaves meta-protocol economics, large-scale DID operations, vocabulary standardization, and higher-level collaboration protocols unresolved (Chang et al., 18 Jul 2025).

Governance and incentive layers expose a different class of difficulty. SWARM shows that naive levers can destroy welfare without improving toxicity, that binary metrics are vulnerable to proxy gaming, and that externality pricing only works when agents or acceptance mechanisms can adapt (Aiersilan et al., 19 Mar 2026). Principal-agent RL assumes finite horizon in its core convergence theorem, faces LP scaling issues, and must contend with discontinuities in the principal’s Q-function under function approximation (Ivanov et al., 2024). Agent GPA, although strong diagnostically, inherits the variability and cost of LLM judges, with Plan Quality the noisiest of the reported metrics (Jia et al., 9 Oct 2025). Structured cooperative MARL achieves exact locality only when the structural graphs are known; when the value dependency set becomes dense, truncation is needed and introduces approximation error (Syed et al., 11 Oct 2025).

Taken together, the surveyed work suggests that AGENT+P is most powerful when the added planning or policy layer captures real structure that the base agent would otherwise have to infer implicitly: a transition graph, a workflow graph, a tool interface, a dependency graph, a contract space, or a governance signal. The central research question is therefore not whether to add “P,” but how to choose the formal object through which planning, control, or governance is made explicit.