PaperlayerView exact revision on arXiv

Source-linked AI summary

AI Agent Systems: Architectures, Applications, and Evaluation

Bin Xu

arXiv:2601.01743v1cs.AI

TL;DR

AI agents address the mismatch between single-turn language interfaces and long-horizon tasks requiring state, tools, and verified actions. This survey unifies agent architectures and evaluates them as budgeted systems, concluding that dependable deployment requires full-stack verification, secure memory, trace observability, and realistic multidimensional benchmarks.

  • Problem

    Most real tasks require information gathering, persistent state, tool selection, and multi-step execution under constraints, which single-turn question answering does not provide.

  • Method

    The survey organizes agent architectures around a transformer policy embedded with memory, typed tools, verifiers, environment interaction, and execution traces.

  • Results

    The survey finds that deployable agents require multidimensional evaluation covering task success, efficiency, tool-use correctness, trajectory quality, robustness, and safety or compliance.

  • Takeaways & Limitations

    Dependable autonomy requires treating reliability and governance as properties of the full model-orchestration-tools stack rather than the base model alone.

  • Takeaways & Limitations

    Formal verifier interfaces, actionable invariants, and residual-risk quantification remain challenging, while composing verifiers across multi-step trajectories remains an open question.

Abstract

from arXiv · show

AI agents -- systems that combine foundation models with reasoning, planning, memory, and tool use -- are rapidly becoming a practical interface between natural-language intent and real-world computation. This survey synthesizes the emerging landscape of AI agent architectures across: (i) deliberation and reasoning (e.g., chain-of-thought-style decomposition, self-reflection and verification, and constraint-aware decision making), (ii) planning and control (from reactive policies to hierarchical and multi-step planners), and (iii) tool calling and environment interaction (retrieval, code execution, APIs, and multimodal perception). We organize prior work into a unified taxonomy spanning agent components (policy/LLM core, memory, world models, planners, tool routers, and critics), orchestration patterns (single-agent vs.\ multi-agent; centralized vs.\ decentralized coordination), and deployment settings (offline analysis vs.\ online interactive assistance; safety-critical vs.\ open-ended tasks). We discuss key design trade-offs -- latency vs.\ accuracy, autonomy vs.\ controllability, and capability vs.\ reliability -- and highlight how evaluation is complicated by non-determinism, long-horizon credit assignment, tool and environment variability, and hidden costs such as retries and context growth. Finally, we summarize measurement and benchmarking practices (task suites, human preference and utility metrics, success under constraints, robustness and security) and identify open challenges including verification and guardrails for tool actions, scalable memory and context management, interpretability of agent decisions, and reproducible evaluation under realistic workloads.

1 Introduction

AI agents address the gap between natural-language interfaces and real-world tasks by combining foundation models with execution loops for planning, tool use, memory, and verification. This survey organizes emerging architectures and emphasizes trade-offs and reproducible evaluation under realistic variability.

  • Motivation: AI agents couple foundation models with execution loops that observe environments, plan, call tools, update memory, and verify outcomes.They translate user intent into procedures executed across software repositories, browsers, enterprise systems, and robots.
  • Motivation: Real-world tasks require multi-source information gathering, persistent state, tool selection, and multi-step actions under latency, permission, safety, and cost constraints.
  • Current gaps: Agent deployments increasingly span workflow automation, interactive long-horizon settings, and nondeterministic environments that motivate verification loops and trace-based evaluation.
  • Current gaps: Agent systems remain limited by compounding errors, nondeterministic tool behavior, governance risks, and unresolved trade-offs between autonomy, controllability, latency, reliability, capability, and safety.
  • Survey scope: The survey synthesizes agent architectures for reasoning, planning, tool use, and deployment while organizing the landscape by learning strategies, optimization, applications, and evaluation regimes.

2 Autonomous Agent Paradigm

The autonomous-agent paradigm treats transformer models as policy cores embedded in structured, budgeted control loops with memory, tools, verifiers, and environment interfaces. The survey connects this abstraction to practical construction choices including typed tools, risk-sensitive deliberation, trace-based refinement, and system-level evaluation.

  • LLMs and VLMs: LLMs map instructions, retrieved documents, tool outputs, and memory to plans, tool calls, or natural-language actions, but require external evidence and executable checks for grounding.
  • LLMs and VLMs: Agent capability increasingly depends on system design: budgeted loops constrain time, tokens, tool calls, and permissible side effects while allocating deliberation to hard or risky tasks.
  • LLMs and VLMs: Test-time search, reranking, backtracking, self-consistency, typed schemas, and policy checks can improve reliability and auditing without retraining, but selective use is needed to limit cost and latency.
  • Agent Transformer Definition: An agent transformer embeds a transformer policy in a control loop with explicit interfaces to observations, memory, typed tools, and verifiers that check proposals before side effects.
  • Agent Transformer Definition: The execution loop observes the environment, retrieves memory, proposes and validates an action, executes it through tools, and updates the environment and memory.
  • Agent Transformer Creation: Practical construction uses constrained tool schemas, canonical action templates, retrieve-plan-act-verify-update loops, stronger controls for high-impact actions, trace logging, and system-level evaluation of success, cost, latency, robustness, and safety.

3 Agent AI Learning

Agent learning spans optimization mechanisms, system infrastructure, and foundation-model capabilities, with choices shaped by long-horizon interaction, tool variability, and safety constraints. The section contrasts reinforcement learning, imitation learning, traditional rule/graph/behavior-tree components, and in-context learning as complementary routes to agent behavior.

  • Learning Stack: Agent learning operates across mechanisms, agent systems, and foundation models, linking policy optimization with system engineering and tool-grounded execution.These layers interact with long-horizon decision making, tool variability, and safety constraints.
  • Reinforcement Learning: Reinforcement learning optimizes long-horizon behavior under interaction, including when to gather information, act, and recover from errors.Its applicability is constrained by sparse rewards, costly rollouts, and safety limits on exploration.
  • Imitation Learning: Imitation learning acquires agent behavior from structured demonstrations containing observations, rationales, tool calls, and outcomes.Behavioral cloning supports schema-validated tool calls, while DAgger addresses compounding errors by collecting corrective demonstrations on induced states.
  • Imitation Learning: Imitation learning avoids unsafe exploration and reduces cost in tool-rich environments, but inherits demonstration biases, coverage gaps, and weak handling of adversarial inputs.Verification, repair loops, critics, and constrained execution help address out-of-distribution cases.
  • Traditional RGB: Traditional rule-based policies, graph planners, and behavior trees remain predictable, inspectable, and governable safety interfaces.Their explicit constraints support deterministic auditing, formal checks, real-time reactivity, and reproducible evaluation.
  • Traditional RGB: Modern systems hybridize LLMs with traditional components: language models interpret ambiguity and propose actions, while rules and planners enforce safety, timing, and domain constraints.Learning often targets routing and parameterization of existing rules, graph branches, or behavior-tree subtrees rather than replacing them.
  • In-context Learning: In-context learning adapts agents through prompts, exemplars, tool schemas, and interaction protocols without parameter updates.Stable, well-specified tool interfaces can provide rapid capability gains with relatively predictable governance and rollback.

4 Agent AI Taxonomy

The taxonomy organizes agent systems by interaction locus, generative target, and reasoning substrate, connecting architectural choices to observability, safety, latency, verification, and evaluation. It distinguishes generalist, embodied, interactive, simulated, generative, mixed-reality, knowledge, and logic-oriented systems by their operating constraints and capabilities.

  • Taxonomy Framework: The taxonomy classifies agents by interaction locus, generative target, and reasoning substrate to connect architectures with deployment requirements.The organizing constraints include observability, safety, latency, verification, and evaluation.
  • Generalist Agents: Generalist agents use a shared policy core with modular tools and memory across coding, browsing, analytics, and enterprise workflows.Their dominant challenge is long-horizon compounding error under tool and environment variability, requiring end-to-end workflow evaluation.
  • Embodied and Action Agents: Embodied and action agents operate under partial observability, sensor noise, continuous control, and real-world safety costs.High-risk actions require conservative alignment and policy gates that enforce constraints beyond the final response.
  • Interactive Embodied Agents: Interactive embodied agents use clarification, instruction following, and shared autonomy so users can steer behavior, correct mistakes, and approve high-impact actions.They must track evolving context and sensory state while surfacing uncertainty instead of hallucinating intent.
  • Simulation and Environment Agents: Simulation agents enable cheaper, scalable interaction, fast iteration, controlled ablations, and reproducible benchmarking, but remain vulnerable to environment drift and reward mis-specification.Sim-to-real transfer remains difficult when moving from controlled environments to production systems.
  • Generative Agents: Generative agents create stories, scenes, characters, or evolving social simulations, requiring long-horizon consistency of world state, persona, and narrative.Iterative generation, constraint validation, revision, and structured tool calls support auditable outputs.
  • AR/VR and Mixed Reality: AR/VR and mixed-reality agents fuse real-time multimodal perception with low-latency action and spatial grounding.Their designs decompose perception into tools such as tracking, OCR, and detection, coordinated by an LLM/VLM orchestrator.
  • Knowledge and Logic Agents: Knowledge and logic agents prioritize grounded evidence, explicit constraints, multi-step inference, and auditable decision traces.They must manage retrieval quality, provenance, schema drift, prompt injection, tool semantics, and validation.

5 Agent AI Application Tasks

AI agents are increasingly organized as workflow executors that translate user intent into multi-step actions across tools, data sources, and environments. Application designs address domain-specific challenges through explicit planning, verification, policy controls, and multimodal grounding.

  • Applications are organized around domains that stress interaction, perception, planning, tool use, and long-horizon control.
  • Autonomous coding and software maintenance agents: Coding agents must handle long-horizon, tool-rich work involving repository search, coherent multi-file edits, testing, flaky environments, and dependency drift.Evaluation requires end-to-end correctness, minimal regressions, and evidence that changes match the intended specification under realistic constraints.
  • Autonomous coding and software maintenance agents: Coding-agent reliability is supported by retrieving context, planning executable changes, making small diffs, running tests and linters, and iteratively repairing failures.Structured edit boundaries, patch previews, test-selection policies, captured diagnostics, and review steps reduce risk around side-effecting operations.
  • Enterprise workflow agents: Enterprise agents must reconcile distributed systems while enforcing access control, auditability, policy compliance, and recovery from partial tool-call failures.Orchestrated designs route tasks to specialized tools, enforce permissions through schemas or allowlists, and verify side-effecting actions before execution.
  • Browser and GUI operation agents: Web and GUI agents operate under dynamic layouts, adversarial inputs, partial observability, and benign variability such as localization, pop-ups, and slow networks.State assertions, retries, backtracking, alternative affordances, and screen re-parsing support recovery from action drift.
  • Real-time multimodal assistants: Real-time multimodal agents combine perception tools, memory, and low-latency orchestration while producing inspectable intermediate outputs for verification or correction.Decomposing perception into OCR, detection, and retrieval tools helps manage noisy inputs, evolving visual state, and context growth.

5.2 Agents for Gaming

Gaming agents must satisfy tight timing, state, safety, and design constraints while maintaining coherent interaction and producing verifiable analytics. Practical systems separate high-level reasoning from specialized control and bind analytical claims to executed evidence.

  • Gaming agents: Gaming agents must remain responsive and consistent while respecting cooldowns, visibility, information disclosure, economy balance, and adversarial player inputs.Evaluation spans win rate and task completion as well as believability, variety, pacing, fairness, and adherence to lore and design constraints.
  • Gaming agents: High-level LLM cognition paired with smaller policies and controllers supports real-time action selection under game-state constraints.In competitive, fully observed settings with massive simulation, reinforcement learning has achieved superhuman performance and robust execution.
  • Gaming agents: Dialogue agents use retrieval, explicit memory, and game-state tools to ground responses in lore, quest logic, relationships, preferences, and commitments.Auditable and reversible memory updates support long-horizon coherence beyond raw context windows.
  • Gaming analytics: Gaming analytics is constrained by noisy telemetry, schema drift, inconsistent metric definitions, causal-attribution difficulty, brittle tools, and prompt injection through untrusted text.Evaluation must emphasize reproducibility and evidence-backed analysis rather than narrative fit alone.
  • Gaming analytics: Analytics agents combine LLM summarization and hypothesis generation with classical models and tool execution for churn, segmentation, anomaly detection, queries, visualizations, and statistical tests.ReAct-style execution makes intermediate artifacts inspectable and enables human verification.
  • Gaming analytics: Retrieval over schemas, metric definitions, experiment plans, and postmortems improves consistency, while verifier loops test alternative filters, counterfactuals, and sanity checks.Modular routing also supports evolving analytics toolchains.
  • Agent-based gaming content creation: Scene-synthesis agents generate candidates, validate style, performance, and physics constraints, then iterate through critique-and-revise loops.Commercial deployment additionally requires auditable traces of prompts, tools, and source assets.

5.3 Robotics

Robotics agents combine multimodal grounding and language-level planning with specialized controllers that preserve timing and safety under partial observability, stochasticity, and hard physical constraints.

  • Embodied environments introduce perception errors, actuator noise, strict timing, collision constraints, force limits, and workspace boundaries that make naive LLM-in-the-loop control risky.Safety requirements can also prohibit open-ended exploration.
  • Robotics systems pair VLM perception and LLM instruction following with classical or reinforcement-learning controllers for continuous control.Hierarchical orchestration maps language goals to skill plans while specialized controllers execute constrained primitives.
  • Mapping, grasp and motion planning, and simulation tools let agents validate feasibility, estimate risk, and select safer actions before execution.Verifier and replanning loops update beliefs from sensor observations and reissue skill-level commands when outcomes deviate from plans.

5.4 Healthcare

Healthcare agents operate in safety- and privacy-critical environments where access, provenance, bias, omissions, and distribution shift constrain deployment. Their workflows combine speech, language, retrieval, and structured extraction to support documentation and clinical drafting.

  • Healthcare agents face access-control, data-residency, audit, bias, distribution-shift, omission, and prompt-injection risks across fragmented clinical information.Evaluation must measure clinical correctness, omission sensitivity, calibration, and downstream workflow impact rather than writing quality alone.
  • Healthcare assistants combine ASR, LLM summarization and drafting, retrieval over guidelines and institutional policies, and structured extraction of medications, problems, and labs.Agent-like workflows can also generate domain-specific prompts for rare-event medical imaging under limited labeled data.

5.5 Multimodal Agents

Image-language agents combine visual perception and grounding with planning, tool orchestration, and verification over visual evidence. Their main challenges include hallucinations, brittle extraction, perturbation sensitivity, and faithful support for claims.

  • Architecture: Image-language agents separate perception tools from planning and verification to support reasoning over visual evidence.The pipeline uses VLMs for perception and grounding and LLMs for planning and tool orchestration.
  • Challenges: Visual hallucinations, brittle OCR and layout extraction, and sensitivity to perturbations remain common for documents and UI screenshots.Small perception errors can change the meaning of visual content.
  • Challenges: Faithful agents must ensure that claims are supported by visible evidence while handling privacy constraints that can prevent centralized image logging.Evaluation must therefore consider faithfulness to visual evidence as well as answer quality.
  • Challenges: Images and documents can contain prompt injections, motivating safety layers, sandboxed tool execution, and strict tool allowlists.Intermediate correctness and safety must be evaluated alongside final answers.
  • Architecture: Tool-calling pipelines decompose visual tasks into OCR and layout parsing, detection, retrieval, and editing.Generative models are used as tools for generation or editing rather than as the primary reasoning engine.

5.6 Video-language Experiments

Video-language agents face costly long-context and temporal-reasoning challenges, while heterogeneous toolchains and privacy constraints make results difficult to compare and reproduce. Evaluation protocols should expose retrieval, context, system, and orchestration choices.

  • Reproducibility: Long-video agent results are sensitive to ASR quality, embedding models, indexing parameters, preprocessing, and retrieval nondeterminism.Dataset leakage and restricted sharing of raw videos and traces further complicate interpretation and replication.
  • Protocol: Evaluation should fix segmentation and retrieval policies and report ablations over context budgets and planner depth.These controls help distinguish underlying capability from system tuning.
  • Protocol: Protocols should report model-level metrics alongside index build time, query latency, and memory footprint.Retrieval and orchestration can dominate end-to-end behavior.
  • Protocol: Clear protocols isolate how indexing, planning depth, and tool usage affect quality, latency, and cost.The goal is improved reproducibility across long-video agent systems.

5.7 Agent for NLP

NLP agents augment instruction-tuned language models with retrieval, tool use, planning, memory, and orchestration. Their central limitations are compounded long-horizon errors, cost and latency, brittle tool interaction, and tension between safety and usability.

  • Challenges: Tool selection can fail through wrong tools, arguments, or assumptions about tool semantics, especially when outputs are incomplete or misleading.The resulting gaps can prompt plausible but incorrect text.
  • Architecture: LLM agents combine instruction-tuned models with retrieval, tool traces or prompting, feedback, and tools such as search, code execution, and database queries.Planning variants and self-consistency reruns can improve performance and stability on harder tasks.
  • Challenges: Long trajectories compound errors, while multiple model calls create central cost and latency trade-offs and complicate failure attribution.Operational concerns include concurrency, caching, and fallbacks.
  • Architecture: General agents often use frontier-scale models for breadth and smaller models for routing, moderation, summarization, caching, and retrieval.This division targets cost and latency management.
  • Orchestration: Orchestrated systems route subtasks to specialized tools, maintain persistent memory, and use planner–executor–reviewer patterns for decomposition and cross-checking.Search-based planning explores alternative action sequences when a single trajectory is insufficient.
  • Safety: Conservative policies reduce risk but harm usability, whereas permissive policies increase security and safety exposure across multi-step trajectories.Policy compliance must persist across retrieved content and tool outputs.
  • Safety: Constrained schemas, structured outputs, explicit planning, and permission gates shift control toward enforceable interfaces.Deployments still require allowlists and related safeguards.

6 Evaluation

Agent evaluation should measure end-to-end task completion together with efficiency, tool correctness, trajectory quality, robustness, and safety. Because agent behavior depends on architecture and environment, complementary system- and trajectory-level metrics are needed to expose hidden costs and failure modes.

  • Core outcomes: Evaluation should prioritize correct task completion in the environment while reporting score, time-to-completion, and trajectory length.WebArena emphasizes realistic end-to-end UI success, while GAIA supports controlled correctness checks with short verifiable answers.
  • Efficiency and cost: Efficiency reporting should include latency, token usage, cost per successful completion, tool-call count, retries, and backtracking.Agents can solve tasks while remaining impractically slow or expensive.
  • Efficiency and cost: Latency percentiles and runtime context are necessary because architectures trade deliberation for cost and latency and platforms can differ substantially.Relevant context includes hardware, accelerator type, and serving stack.
  • Tool-use correctness: Tool-use evaluation should separately measure tool selection, argument correctness, execution success, and recovery after failure.ToolBench emphasizes end-to-end tool competence because reliability and error handling often dominate failures.
  • Trajectory and planning quality: Trajectory metrics should report invalid actions, loops, and plan adherence or coherence alongside final success.These metrics help explain failures and compare planning and orchestration choices.
  • Robustness and reliability: Robustness evaluation should test perturbations, seed variance, and graceful degradation under token or tool budgets.Reliability benchmarks should report distributions and failure clusters rather than averages alone.
  • Safety and compliance: Safety evaluation should cover policy violations and human interventions across the full execution trajectory, with deployment assumptions and threat models reported.Trace artifacts support auditing for prompt injection, untrusted outputs, and permission escalation.
  • Benchmarks: AgentBench, WebArena, ToolBench, SWE-bench, and GAIA cover interactive environments, web tasks, tool use, software issue resolution, and verifiable assistant tasks.Their differing scopes reinforce the need for complementary evaluation dimensions.

7 Directions for Future Research

Future research should treat agentic systems as budgeted, auditable systems operating under unreliable environments, while developing stronger verification, memory, planning, evaluation, coordination, and conceptual frameworks.

  • Research agenda: Agent systems need principled guarantees for allocating compute, interacting with unreliable environments, and producing auditable plans, traces, and tool calls.This frames agents as budgeted, tool-augmented systems rather than purely linguistic models.
  • Verification and trustworthy tool execution: Verifying tool actions remains difficult because formal verifier interfaces, actionable invariants, residual-risk measurement, and compositional safety are not yet established.Proposed directions include tool contracts, layered defenses, sandboxing, permission gates, and trace-first monitoring.
  • Memory and context management: Long-horizon agents require memory systems that store, retrieve, and update state without contradictions, stale information, prompt-injected artifacts, or uncontrolled cost and latency.Open directions include memory write policies, provenance, verification, systematic ablations, and reporting of recovery costs.
  • Planning and test-time compute allocation: Planning and deliberation improve reliability when single-shot rollouts fail, but they create cost, latency, reward-hacking, and brittle-scoring trade-offs.Research should allocate test-time compute according to risk and uncertainty while integrating tool-grounded feedback into planning and termination decisions.
  • Robust evaluation and reproducibility: Reliable evaluation must report tool-call correctness, side-effect containment, retries, failure distributions, complete traces, environment versions, multiple seeds, and deployment constraints.This responds to sensitivity to prompts, sampling, tool versions, and environment drift.
  • Multi-agent coordination and governance: Multi-agent systems can improve coverage through decomposition and cross-checking, but require bounded roles, reliable disagreement resolution, observability, audit logs, and governance under delegation.Evidence-based critiques and structured verification may reduce correlated failures, although coordination, incentives, consistency, and cost remain open issues.
  • Unified conceptual frameworks: The field needs unified taxonomies that distinguish agents from agentic workflows, separate policy models from orchestration, and connect systems, learning, and evaluation in a scientific design loop.Such frameworks are intended to support architecture comparison, failure-mode identification, design decisions, evaluation, and governance.

8 Conclusion

The survey frames AI agents as budgeted, trace-first systems whose reliability and governance depend on the full stack, not the base model alone. It emphasizes multidimensional evaluation and dependable autonomy through verifiable execution, secure memory, bounded computation, and observability.

  • The unified taxonomy treats agents as budgeted systems with structured tool interfaces and trace-first operation.Reliability and governance are properties of the model, orchestration, and tools together.
  • Learning and optimization span reinforcement or imitation learning, in-context learning, and test-time reflection, self-consistency, and search.These mechanisms complement modular system components such as memory, tool routers, planners, critics, schemas, sandboxing, and audit logs.
  • Deployable agents require multidimensional evaluation covering task success, efficiency and cost, tool-use correctness, trajectory quality, robustness, and safety or compliance.AgentBench, ToolBench, WebArena, SWE-bench, and GAIA provide complementary stress tests for these dimensions.
  • Dependable autonomy at scale requires verifiable policy-compliant tool execution, secure consistent long-term memory, budgeted test-time compute, and trace-first observability.These capabilities support auditing, reproducibility, and governance while narrowing the gap between demonstrations and robust deployment.
Loading 2601.01743v1…