Adaptive Reflective Interactive Agent (ARIA)

• Adaptive Reflective Interactive Agent (ARIA) is an LLM-agent framework that integrates adaptive state updates, reflective self-assessment, and human-in-the-loop guidance to address changing rules post-deployment.
• The system performs structured self-dialogue to diagnose uncertainty and knowledge gaps, triggering targeted expert queries and repository updates for continuous improvement.
• Deployed in dynamic domains such as compliance and legal analysis, ARIA has demonstrated enhanced performance metrics—achieving 0.8910 sensitivity and 0.8026 specificity with significantly reduced handling times.

Adaptive Reflective Interactive Agent (ARIA) denotes an LLM-agent framework for test-time learning with human-in-the-loop guidance in domains where rules and domain knowledge change after deployment. In its canonical formulation, ARIA makes an initial prediction on a live case, conducts structured self-dialogue to assess uncertainty and identify knowledge gaps, asks targeted questions to human experts when needed, and then updates a timestamped knowledge repository that can be reused on future cases (He et al., 23 Jul 2025). This suggests a broader conception of ARIA as an agent architecture in which adaptation, reflection, and interaction are treated as coordinated system functions rather than as prompt-engineering variants alone, a view that closely matches the architectural program of reflective AI (Lewis et al., 2023).

1. Definition and conceptual lineage

In the ARIA framework, adaptive means that the agent changes its internal state at test time by updating an evolving repository of rules, explanations, and exemplars; reflective means that it performs structured self-assessment over its own reasoning before deciding whether to seek help; and interactive means that human expertise is part of the live deployment loop rather than an offline annotation stage (He et al., 23 Jul 2025). This is a narrower but operationally concrete form of reflection.

The broader reflective-AI literature draws a sharper distinction between reasoning, planning, deliberation, and reflection. Reflection is described not as another inference step, but as a higher-level process that monitors what the system is doing, contextualizes candidate actions, reasons about consequences through models of self, others, and world, considers ethical, cultural, political, social, and long-term goals, and can intervene to block or redirect behavior (Lewis et al., 2023). On that view, ARIA is best understood as a specific implementation of reflective behavior centered on uncertainty diagnosis, knowledge-gap detection, and knowledge governance, rather than a complete realization of reflective agency in the strongest architectural sense.

Earlier research anticipated parts of this agenda without using the ARIA name. A resource adaptive agent mechanism for interactive theorem proving used a two-layer architecture of agent societies, blackboards, background suggestion, and cost-aware modulation of internal activity, explicitly arguing for systems that work steadily and autonomously while adapting to available resources and user timing (0901.3585). In artificial life, cog-1 agents with “somatic computation” used internal variables such as desire to feed, desire to replicate, and fear to modulate behavior through self-regarding appraisal, illustrating an earlier “reflexive” lineage oriented toward adaptive self-regulation rather than meta-cognitive reflection (Gonçalves, 2014).

2. Canonical ARIA architecture

ARIA processes a sequential stream of instances

$X = (x_1, x_2, \dots, x_N),$

and, for each instance $x_i$, produces an initial prediction using the current repository $KR_i$ and base LLM: $\hat{y}_i = \pi(x_i; KR_i, M_{\text{LLM}}).$ It then invokes Intelligent Guidance Solicitation (IGS) to assess the preliminary decision,

$S_i = IGS\_Assess(\hat{y}_i, r_i, KR_i),$

where the assessment includes a confidence judgment and identified knowledge gaps (He et al., 23 Jul 2025).

The reflective core is a predefined set of reflective questions

$$RQ = \{\text{rq}_1, \text{rq}_2, \dots, \text{rq}_{N_{RQ}}\},$$

answered internally as a self-dialogue: $$\text{ans}_k = M_{\text{LLM}}(\text{rq}_k, x_i, \hat{y}_i, r_i, KR_i),$$

$$D_i^{self} = \{(\text{rq}_1,\text{ans}_1), \dots, (\text{rq}_{N_{RQ}}, \text{ans}_{N_{RQ}})\}.$$

From this trace, ARIA derives a categorical confidence level,

$$\text{conf}_i = AssessConfidence(D_i^{self}), \quad \text{conf}_i \in \{High, Moderate, Low\}.$$

If confidence is Moderate or Low and the query budget permits it, ARIA formulates a targeted expert query

$q_i = IGS\_FormulateQuery(D_i^{self}),$

sends it to a human oracle $x_i$0, receives guidance $x_i$1, and updates the repository through

$x_i$2

This is the system’s learning step at test time (He et al., 23 Jul 2025).

The repository is structured. Each knowledge item has the form

$x_i$3

where $x_i$4 may be a rule, explanation, factual statement, or exemplar; $x_i$5; and metadata can include source, usage frequency, related items, and superseded-by links. New guidance is parsed into knowledge assertions, compared against semantically related prior items, and may mark earlier items as Superseded or PotentiallyOutdated. Future retrieval is validity- and recency-aware: $x_i$6 with

$x_i$7

A central misconception is that ARIA learns by online parameter updating; in the canonical framework, the operative state change is repository update, not weight update (He et al., 23 Jul 2025).

3. Reflection as self-assessment, governance, and revision

ARIA’s self-dialogue is only one point in a larger design space of reflective mechanisms. Reflective AI more generally proposes a two-level architecture combining an ordinary learning agent with a reflective layer comprising Reflective Observation, Reflective Learning, Reflective Models, Reflective Reasoning, and Higher-Level Extrinsic Goals (Lewis et al., 2023). The associated loops include Governing Behaviour,

$x_i$8

Abstract Conceptualization of Experience,

$x_i$9

and more explicitly meta-level loops for goal critique, learning critique, and re-representation. Relative to this blueprint, ARIA instantiates a narrower reflective layer: it monitors evidence, detects missing or stale knowledge, and governs when to escalate to humans, but it does not yet provide full self-modeling, consequence simulation, or reflective revision of learning mechanisms (Lewis et al., 2023).

Other systems operationalize reflective interaction differently. Reflecti-Mate models a user’s reflection as

$KR_i$0

with thought categories $KR_i$1, per-thought depth

$KR_i$2

category breadth

$KR_i$3

fixation score

$KR_i$4

and average category depth

$KR_i$5

It then alternates between exploration and exploitation with an $KR_i$6-greedy policy to broaden or deepen reflection (Tarvirdians et al., 21 May 2026). In a between-subjects study with $KR_i$7, the adaptive agent yielded more balanced reflective language, and 72% of participants in the experimental condition agreed or strongly agreed that it helped integrate head, heart, and gut, versus 44% in the baseline condition (Tarvirdians et al., 21 May 2026).

In interactive text environments, Sweet&Sour shows that reflective systems need not learn only from failure. It stores positive and negative reflections in managed memory, with each short-term memory represented as

$KR_i$8

and uses a dual-buffer structure in which successful subgoal reflections enter short-term memory and later migrate to long-term memory, while failure reflections are written directly to long-term memory (Lippmann et al., 2024). On ScienceWorld, Sweet&Sour achieved 54.6 average score with GPT-4o, compared with 45.3 for Reflexion and 36.0 for ReAct, indicating that reflective consolidation of successful intermediate experience can materially change adaptation dynamics (Lippmann et al., 2024).

4. Memory, adaptive questioning, and interaction structure

A recurring pattern in ARIA-related systems is that interaction becomes adaptive only when the agent maintains structured state and uses it to decide whether to continue probing, revise its beliefs, or switch tactics. R2D2 makes this explicit in web environments through a Remember paradigm and a Reflect paradigm. Its replay buffer is a directed graph

$KR_i$9

with observation nodes and action-labeled edges $\hat{y}_i = \pi(x_i; KR_i, M_{\text{LLM}}).$0, while a separate reflective memory stores corrected or truncated trajectories with reflective insights, keyed by query embeddings (Huang et al., 21 Jan 2025). On WebArena, R2D2 achieved 27.5% overall success rate and the abstract reports a 50% reduction in navigation errors and a threefold increase in task completion rates, showing that memory-enhanced navigation and failure-conditioned reflection are complementary (Huang et al., 21 Jan 2025).

AgentMental offers a more structured dialogic pattern. It decomposes assessment into a question generator agent, evaluation agent, scoring agent, and updating agent, using adaptive questioning of the form

$\hat{y}_i = \pi(x_i; KR_i, M_{\text{LLM}}).$1

and a topic-transition rule

$\hat{y}_i = \pi(x_i; KR_i, M_{\text{LLM}}).$2

In the reported implementation, $\hat{y}_i = \pi(x_i; KR_i, M_{\text{LLM}}).$3 and $\hat{y}_i = \pi(x_i; KR_i, M_{\text{LLM}}).$4, and memory is organized as a tree with a root user node, topic nodes, and statement nodes (Hu et al., 15 Aug 2025). With Qwen2.5-72B, the full system achieved MAE = 2.514, Kappa = 79.8, and Macro F1 = 89.8, while removing either in-depth questioning or memory substantially degraded performance (Hu et al., 15 Aug 2025). This demonstrates a form of local reflection: the system does not merely answer; it decides whether enough has been learned to proceed.

Conversate provides a complementary reflective-learning pattern for interview practice. It separates interaction into Interview Simulation, AI-Assisted Annotation, and Dialogic Feedback, with transcript-linked playback, user-authored self-reflection, and iterative answer revision (Daryanto et al., 2024). In the qualitative study, 19/19 participants found follow-up questions helpful, 13/19 said they made the experience feel more like a real interview, and users valued the ability to contest, clarify, and iteratively refine feedback (Daryanto et al., 2024). This suggests that ARIA-style systems benefit when feedback is not merely delivered, but made discussable and revisable.

5. Execution substrates and multimodal embodiments

The “interactive” part of ARIA often depends on specialized execution modules. In GUI environments, Aria-UI provides a pure-vision grounding backend that maps a screenshot, an instruction, and optionally textual or interleaved history to normalized point coordinates in $\hat{y}_i = \pi(x_i; KR_i, M_{\text{LLM}}).$5, without using HTML, DOM trees, or accessibility trees (Yang et al., 2024). Built on Aria, a multimodal-native MoE with 3.9B activated parameters, it extends resolution support from 980 × 980 to 3920 × 2940 and frames grounding as coordinate generation rather than candidate classification (Yang et al., 2024). On ScreenSpot, Aria-UI achieved 82.4 average element accuracy versus 74.1 for UGround; on AndroidWorld, a history-conditioned variant reached 44.8 task success rate versus 32.8 for GPT-4o with UGround (Yang et al., 2024). The paper is explicit, however, that this is a grounding model rather than a full planner, and that it does not provide self-critique, uncertainty estimation, or recovery policies (Yang et al., 2024).

Embodied and socially situated variants extend ARIA-like ideas beyond browser and GUI control. ARIS combines multimodal reasoning, a graph-based Social World Model, and RAG in a modular social-robot architecture for Pepper. Its graph memory stores Person Nodes, Message Nodes, and relationship edges, while the dialogue pipeline retrieves both semantically similar and recent messages, capping context at 80 messages to maintain bounded latency (Datta et al., 1 May 2026). In a user study with $\hat{y}_i = \pi(x_i; KR_i, M_{\text{LLM}}).$6, ARIS yielded higher perceived intelligence, animacy, anthropomorphism, and likeability than an LLM-only baseline, and its RAG pipeline stayed below about 4,000 ms even at 14,000 messages, whereas the Non-RAG pipeline exceeded 10,000 ms (Datta et al., 1 May 2026). This is not full reflective ARIA, but it is a strong example of adaptive, memory-grounded, multimodal interaction.

Livia shows a related pattern in affective AR companionship. Its modular backend includes an Emotion Analyzer Agent, Frontend Voice Interaction Agent, Memory Compression Agent, and Behavior Orchestration Agent, along with progressive memory compression via Temporal Binary Compression (TBC) and Dynamic Importance Memory Filter (DIMF) (Xi et al., 12 Aug 2025). The system reports 88% emotion-recognition accuracy versus 75% for a text-only baseline, 31% higher engagement than a standard text-only version, and per-user storage reduction from 50 KB to 15 KB with 92% important-event recall (Xi et al., 12 Aug 2025). Here, “reflection” is mainly historical grounding through memory retrieval and trend tracking rather than explicit metacognitive self-assessment.

6. Empirical performance, deployment, and acronym ambiguity

As a deployed framework, ARIA’s clearest evidence comes from dynamic-domain tasks. On TikTok Pay customer due diligence name screening, ARIA with GPT-4o achieved 0.8910 sensitivity and 0.8026 specificity at budget $\hat{y}_i = \pi(x_i; KR_i, M_{\text{LLM}}).$7, compared with 0.8718 / 0.7853 for simple uncertainty sampling and 0.7051 / 0.6539 for static GPT-4o (He et al., 23 Jul 2025). On CUAD, ARIA with GPT-4o reached 0.6358 accuracy at $\hat{y}_i = \pi(x_i; KR_i, M_{\text{LLM}}).$8, compared with 0.5735 for RAG and 0.4872 for static GPT-4o (He et al., 23 Jul 2025). Ablations show that removing self-dialogue, conflict resolution, or richer human guidance all degrades performance, with the most severe drops occurring when ARIA is restricted to labels only or deprived of repository conflict handling (He et al., 23 Jul 2025).

The deployment claims are unusually concrete. The framework is reported as deployed within TikTok Pay, serving over 150 million monthly active users (He et al., 23 Jul 2025). Average handling time is also reported: human experts require 12 min/case, whereas ARIA ranges from 0.13 min at $\hat{y}_i = \pi(x_i; KR_i, M_{\text{LLM}}).$9 to 0.41 min with full oracle access $S_i = IGS\_Assess(\hat{y}_i, r_i, KR_i),$0 (He et al., 23 Jul 2025). These numbers matter because they place ARIA in a category distinct from many reflective-agent proposals that remain purely conceptual or benchmark-bound.

The acronym, however, is overloaded. “ARIA: Training Language Agents with Intention-Driven Reward Aggregation” uses ARIA to denote Aggregates Rewards in Intention space for training language Agents, a reinforcement-learning method that clusters semantically similar actions and assigns shared rewards in open-ended language action environments (Yang et al., 31 May 2025). Likewise, “Aria: An Agent For Retrieval and Iterative Autoformalization via Dependency Graph” uses Aria for a theorem-formalization system that decomposes mathematical statements into dependency graphs and refines Lean code with compiler-in-the-loop reflection (Wang et al., 6 Oct 2025). These systems are architecturally relevant to agent research, but they are not instances of Adaptive Reflective Interactive Agent in the specific sense defined in (He et al., 23 Jul 2025).

7. Limitations, misconceptions, and future directions

The canonical ARIA framework has clear limitations. It depends on expert availability and quality, repository growth can become difficult to manage, and the current validation is concentrated in structured domains such as compliance and legal analysis; the CUAD setting also uses a simulated oracle rather than human experts (He et al., 23 Jul 2025). The paper further notes overhead from self-dialogue, retrieval, and conflict handling, which may matter in high-throughput settings (He et al., 23 Jul 2025). A common misconception is therefore to treat ARIA as a general solution to reflective agency; it is better understood as a strong design for human-guided test-time adaptation under changing rules.

Related systems expose adjacent gaps. Aria-UI is explicit that strong interactive execution does not by itself provide integrated planning, self-correction, uncertainty estimation, or long-term memory (Yang et al., 2024). ARIS provides persistent social memory and modular multimodal action, but not explicit self-critique, contradiction management, or confidence-aware memory writes (Datta et al., 1 May 2026). AgentMental and Conversate show effective procedural reflection through adequacy checks and dialogic revision, yet remain heavily prompt-dependent and do not provide calibrated uncertainty or robust safety layers (Hu et al., 15 Aug 2025, Daryanto et al., 2024). This suggests that a fuller ARIA would need to combine repository-based adaptation with stronger reflective governance, explicit memory provenance, contradiction handling, and revision policies that operate over longer temporal horizons.

The broader research trajectory points toward several converging requirements. Reflective AI argues for explicit higher-level models of self, others, norms, and consequences (Lewis et al., 2023). Memory-centric agent frameworks argue for separate stores for route memory, reflective memory, and possibly generalized skill memory (Huang et al., 21 Jan 2025). Embodied and social systems argue for graph-structured world models, bounded-latency retrieval, and multimodal grounding (Datta et al., 1 May 2026). A plausible implication is that future ARIA systems will be most effective when they treat adaptation, reflection, and interaction as separate but coupled control loops: one for acting, one for diagnosing and revising, and one for maintaining the evolving knowledge and social state on which future action depends.