1 Introduction↩︎

LLM-based agents [1], [2] have been deployed in social simulations [3] and software teams [4], but they often answer the user’s literal question about an environment while missing the implicit information need behind it. Asking “where is Lin Wei?” may be a request for location, but it may also mean “is she free to chat?”. Three downstream problems follow: agents make decisions with incomplete context; user-facing responses invent details instead of grounding in current state; and environment state is rarely translated into the specific context a user needs for the next action.

Prior approaches answer this only partially. ReAct [5] interleaves reasoning and tool calls during answer generation, but tools fire only when the surface query explicitly demands them — the loop has no step that asks “what does the user actually want to know?”. Plan-and-Solve [6] pre-plans tool calls from the literal query, with no mechanism to bridge to an implicit need that the literal query does not name. Generative Agents [3] inject all environment state as passive context but expose no control over which private state to surface for a given query. Each treats the user’s surface query as if its literal form fully specified what the user wants. AURA’s contribution is the missing step: making implicit-need inference an independent control variable for tool use. Rather than appending another LLM call to a ReAct loop, AURA factors out gap estimation as a pre-tool routing decision that determines which private-state probes to issue and how many.

By situated we mean structured environments where private state is partitioned behind tool-mediated access—the agent can observe public context passively but must actively probe for hidden state. This is narrower than the general “situated agent” umbrella, which includes embodied navigation, open-world exploration, and real-time sensor fusion; we do not address those settings. We study this problem as implicit-intent inference over structured environment state. AURA introduces the Environment Agent: a pipeline (Perceive \(\to\) Scene \(\to\) Memory \(\to\) Reason) plus an LLM-generated IntentFrame that estimates the gap between a user’s literal query and plausible implicit need, then uses that estimate to direct per-query probing, tool selection, and optional heads-up alerts.

Contributions. (i) We introduce the IntentFrame as a pre-tool control variable: before any tool fires, the agent infers the user’s implicit need and emits a scalar gap score that determines the probe budget and shortlists candidate tools. (ii) On a 100-query four-scene implicit-intent benchmark, gap-routed probing improves implicit-need coverage over ReAct-style NoIntent (\(\Delta{=}{+}0.07\), \(p{<}10^{-6}\); three of four scenes significant), reproducing on a 25-query pilot, a second backbone, and under disjoint-example ablation. (iii) We characterise the mechanism’s regime boundary: the controller is an access–cost Pareto point on factual grounding, not a universal accuracy win (Section 5.1; Limitations). (iv) We release the AURATown simulator, all 100 implicit-intent queries with subcategory labels (\(\kappa{=}0.61\) inter-annotator agreement), and per-seed run records.

2 Related Work↩︎

2.0.0.1 Agent architectures and tool use.

ReAct, Reflexion, Toolformer, AgentBench, ToolLLM, T-Eval [5], [7]–[11] treat tool use as reactive: tools fire during reasoning. AURA’s Explore runs before reasoning with a bounded budget routed by the inferred literal-vs.-implicit gap. Plan-and-Solve [6] plans tool calls from the surface query without that gap routing.

2.0.0.2 Multi-agent simulation and memory.

Generative Agents [3] inject environmental observations into LLM prompts; AURA adds (i) per-query access control by an LLM-produced IntentFrame, vs.passive top-\(k\) retrieval; (ii) a public/private state split that supplies the substrate for implicit-intent and belief-state evaluations Park’s all-public state cannot. SOTOPIA [12] provides the 7-dimension framework we adopt; broader multi-agent benchmarks [4], [12]–[17] treat the environment as serving agents on request. Memory frameworks [18]–[22] target long-term storage; AURA’s memory is populated by proactive probing, not passive accumulation. Proactive context agents (ContextAgent, ProAgent, PROBE, ProAgentBench [23]–[26]; full comparison in Appendix 13.0.0.4) target when to assist; concurrent industry work [27] argues for treating interactivity as a native multimodal capability with continuous micro-turn perception rather than turn-bounded prompting; AURA is orthogonal to both axes, targeting what private-state context to surface for an already-received query.

2.0.0.3 Pragmatic and conditional QA.

A parallel line of work targets the same motivation in text-only QA: users omit context they assume the model already shares. [28] introduce CondAmbigQA, a 2,000-query benchmark with condition-aware reasoning that improves QA accuracy by \(11.75\%\). AURA addresses the same gap in a different regime: the implicit need lives in another agent’s hidden private state rather than in textual context, and the resolution mechanism is a budgeted probe over a structured environment registry rather than a textual condition rewrite.

2.0.0.4 Belief-state evaluations.

Theory of mind in LLMs is contested: [29] argues spontaneous emergence; [30], [31] show failure on trivially-altered Sally–Anne tasks; [32] build an explicit symbolic tracker. AURA is not a ToM benchmark: of our five implicit-intent subcategories, only second_order probes belief tracking (stale-belief templates adapted from [31]); the other four (availability, mood, appropriateness, latent_goal) target surfacing of non-belief private state through a budgeted controller. We position AURA as evidence about when intent-directed probing helps surface hidden state; belief queries appear in our 5-subcategory taxonomy as one substrate (second_order). Transfer to external belief benchmarks does not hold automatically: Appendix 26 reports a FANToM transfer null.

3 The AURA Framework↩︎

AURA factors a situated agent into two phases (Fig. 1): deterministic context assembly (Sense \(\to\) Scene \(\to\) Memory) followed by LLM-controlled reasoning (IntentInferrer \(\to\) Explore \(\to\) Reason \(\to\) Act \(\to\) Interact). The deterministic phase establishes a passive context preview using the same passive-perception pattern as Generative Agents [3] and is not the contribution. The contribution is the IntentInferrer, which produces an IntentFrame whose scalar gap field controls per-query probe budget and tool selection in Explore (Section 3.3); Reason, Act, and Interact then plan and emit the response, with an optional heads-up alert when the inferrer’s gap value crosses a threshold. The remainder of this section formalises the problem (Section 3.1), describes the bounded-probing loop (Section 3.2), and details the IntentFrame stage (Section 3.3).

3.1 Problem Formulation and Architecture↩︎

We consider a situated multi-agent system where \(N\) agents operate in a shared environment \(\mathcal{E}\) over discrete time steps. A human user \(h\) may interact with any agent via natural-language queries \(q\). We seek to maximise environmental grounding of agent actions and user-facing responses: \[\max_{\pi_E}\mathbb{E}\!\left[\sum_t G(\alpha_i^t, \mathcal{E}^t) + \sum_q R(r_q, \mathcal{E}^t_q)\right],\] where \(G\) measures action-state consistency, \(R\) measures response factual accuracy, and \(\pi_E\) is the Environment Agent’s probing policy.

The Explore stage’s useful range is bounded by the residual uncertainty after passive perception: when Sense/Scene/Memory cover the facts the query needs, extra probes add little; when the query depends on a remote agent’s private state, one targeted probe can change the answer.

3.2 Bounded Proactive Probing↩︎

The Explore stage implements bounded environment probing. Unlike ReAct [5] where tool calls are interleaved during reasoning, our probing occurs before answer generation, so the final response is conditioned on a compact probe trace. The probe loop iterates up to a budget \(B\) steps; at each step an LLM planner \(\phi\) examines the current context and the tool registry \(\mathcal{T}{=}\{t_1,\dots,t_K\}\) and either issues a tool call (whose result is appended to a probe trace and used to update the context) or signals stop; the trace is summarised at the end and consumed by Reason. Pseudocode in Algorithm 3 (Appendix 7).

3.2.0.1 Design.

The loop is goal-directed (LLM-driven tool selection given current context, not exhaustively), bounded (step budget \(B\) caps API cost), composable (each tool result updates context for the next decision, enabling multi-hop gathering), and separable (probing runs independently from reasoning, so results can be cached or skipped). The AURATown instantiation registers eight base environment tools (Table 8) for the factual-grounding benchmark, and a separate five-tool scripted registry of agent-state probes for the implicit-intent benchmark (Section 5.2); both register under a pattern-based allow/deny policy.

3.3 Intent Inference: Modeling the User’s Implicit Need↩︎

Proactive probing decides what to ask the environment; intent inference estimates what useful answer the user may need. AURA factors the second decision out as an explicit LLM-mediated stage that sits between Scene/Memory and the Explore budget selector.

Given the user’s surface query \(q\), the preview scene \(\mathcal{S}\), and recent memories \(M\), the IntentInferrer produces an IntentFrame: \[\begin{align} \texttt{IntentFrame} =\, & (\ell,\; I,\; g \in [0,1],\; P \subseteq \mathcal{T},\\ & \;a \in \{0,1\},\; c \in [0,1],\; r) \end{align}\] where \(\ell\) is the literal-need restatement, \(I\) is the list of plausible implicit needs, \(g\) is the gap between literal and implicit (0 if the literal answer suffices, 1 if the user’s real need is orthogonal), \(P\) is a set of recommended probe tools drawn from the registry \(\mathcal{T}\), \(a\) is an alert flag, \(c\) is the inferrer’s self-reported confidence, and \(r\) a rationale.

The gap \(g\) is the control input: downstream stages use a deterministic map \(B(g) = 0, 1, 2, 3, 5\) for \(g \in [0,0.2),[0.2,0.4),[0.4,0.6),[0.6,0.8),[0.8,1]\) respectively, truncated by the global explore_max_steps budget. Importantly, \(B(g)\) is a ceiling, not a target: the downstream Explore loop receives both the probe budget and the recommended_probes hint, and we observe in Section 8.1 that the LLM typically stops short of the ceiling when one well-targeted probe has already returned actionable information.

3.3.0.1 Worked example.

For the query “where is Lin Wei?” at 14:30 with Lin Wei present in the cafe scene, the inferrer outputs \(\ell{=}\)“locate Lin Wei”, \(I{=}\), \(g{=}0.6\), \(P{=}\), \(a{=}1\), \(c{=}0.7\). The \(g{=}0.6\) maps to a budget ceiling of \(B{=}3\), but Explore stops after two probes when get_agent_private_state(‘‘Lin Wei’’) returns availability=busy, which suffices to answer the implicit need.

3.3.0.2 Two backends and control boundary.

A heuristic backend (deterministic surface-cue matching, for tests and offline execution) and an LLM backend (structured-JSON output, calibrated with a four-tier gap rubric and clean benchmark-disjoint few-shot exemplars; recommended-probes whitelisted against the live tool registry) are both provided. The architectural pipeline up to this point (Sense–Scene–Memory) is deterministic; the IntentFrame is the first stage at which the LLM affects control flow (probe budget, tool priority, alert flag). Section 8.1 quantifies the resulting per-query adaptation, and Appendix 18 shows that the examples act as gap calibration rather than answer templates. The heuristic backend is provided for offline tests and air-gapped deployments; all reported results use the LLM backend.

3.3.0.3 Memory architecture.

AURA’s memory scores each item \(m\) against query \(q\) at time \(t\) by a weighted combination of recency, importance, and lexical similarity (Eq. 1 , Appendix 29, with weights \(0.3{:}0.4{:}0.3\) and decay \(0.01\)). Memory types follow [33] (observation, conversation, reflection, plan), with reflections triggered every \(\theta{=}10\) observations. Keyword-based similarity is a deliberate reproducibility trade-off; embedding retrieval is a natural extension. A three-stage enrichment protocol routes each query through context gathering, single-step probe verification, and enriched generation (Appendix 29).

3.3.0.4 Relationship to long-context approaches.

A natural alternative is to pack the full environment state into the prompt and rely on the LLM’s long-context attention. AURA’s selective probing pays one extra IntentInferrer call but issues 0–3 targeted probes whose count tracks the inferred gap, rather than the world size. We do not run a head-to-head against a stuff-everything baseline (such a baseline would also need to decide which slice of memory to include); the Static-Context baseline (§5.1) (a packed scene snapshot) is the closest in-suite analogue and reaches FA \(0.450\) vs.AURA Full’s \(0.640\). Appendix 13.0.0.3 sketches the token-cost and prompt-content differences.

4 AURATown: A Multi-Agent Social Simulation↩︎

AURATown is a 60\(\times\)​60 grid-based social simulation with 5 named agents and 20 named locations over a 6:00–23:00 day (full setup, map, and a tick-18:00 mechanism snapshot in Appendix 10). Two decisions depart from [3]’s 25-agent Smallville. (i) Scale. 5 agents yields tractable per-query ground truth; we test a per-agent mechanism, not multi-agent emergence. (ii) Public/private state split. location and action are visible in the scene snapshot, but availability, emotional_state, unspoken_goal, and beliefs_about_others are hidden and only retrievable via probe tools. Each agent’s private state updates deterministically each tick via a seven-rule priority table (Appendix 9): e.g., an agent at a loaded workplace becomes busy and tired-focused; one at an empty workplace becomes available and lonely. Beliefs about other agents refresh only on co-location, producing the staleness that second_order queries probe. The released codebase additionally includes a chunk-based procedural world used by the demo deployment (demo/town/chunks.py); experiments here use only the fixed 60\(\times\)​60 / 5-agent / 20-location subset.

5 Experiments↩︎

We evaluate AURA along three axes: environment access as a boundary condition (§5.1), intent-directed probing (§5.2), and adaptive probe allocation. Primary experiments use gpt-4o-mini as both agent backbone and LLM-as-judge (full hyperparameters in Appendix 12; cross-backbone robustness on claude-haiku-4-5, qwen-plus, gemini-2.5-flash in Appendix 19). The same-family judge–policy setup limits independence; we address this with a strict precision rescore in Appendix 15. Baselines, metrics, and additional diagnostic checks (routine grounding, component ablation, SOTOPIA, human eval, budget sweep) are in Appendices 14–23.

5.0.0.1 Regime characterisation.

AURA Intent leads the implicit-need regime (§5.2); on factual grounding (§5.1), gap-routed probing is an access-cost Pareto point rather than an accuracy winner. Cross-domain sanity checks (FANToM, LoCoMo, GAIA) are reported in Appendices 26–28.

5.0.0.2 Routine grounding: metric saturates.

Under 100 simulation steps per condition \(\times\) 3 seeds, all five architectures (Vanilla, Static Context, ReAct, AURA No-Probe, AURA Full) fall within \(0.024\) absolute GA spread, every paired \(t\)-test vs.vanilla gives \(p > 0.5\). The metric is saturated: memory-utilisation \(\approx 1.0\) for every method, most actions are trivially grounded (“sleeping at home at 6 AM”). This is evidence about the metric, not the mechanism (Appendix 22).

5.1 Factual Grounding: Environment Access as a Boundary Condition↩︎

This subsection tests whether gap-routed probing is merely a generic accuracy booster (it is not). We collect 50 user queries about the environment spanning 5 categories (spatial, social, temporal, memory, planning). Responses are scored against ground-truth environment state by a gpt-4o-mini LLM-as-judge (same family as the agent backbone — see Appendix 15 for a strict precision rescore that reduces sensitivity to judge softness). We repeat across three random seeds \(\{42, 123, 456\}\) and report mean \(\pm\) std, together with paired \(t\)-tests against two reference conditions: the vanilla LLM (to measure total architectural effect) and AURA (No Probe) (to isolate the marginal contribution of proactive probing on top of the Perceive/Scene/Memory pipeline).

5.1.0.1 Scope evidence: factual lookup is an accuracy–access tradeoff regime.

The 50 factual queries ask for environment facts — “Where is X?”, “What time is it?” — so saturated access is a strong control. Fixed-Probe invokes all eight environment tools on every query and reaches \(0.766\) FA, statistically above GapRouted (\(0.696\); paired \(\Delta{=}{+}0.070\), \(p{=}0.031\)). Plan-and-Solve is similar in raw FA (\(0.764\); paired vs.GapRouted \(\Delta{=}{+}0.068\), \(p{=}0.056\)). The gap-routed controller therefore is not the raw-accuracy winner on factual lookup. Its contribution is an access Pareto point (Figure 2): \(1.40\) probes/query vs.Fixed-Probe’s \(8.00\) (\(\mathbf{82\%}\) fewer; \(p{=}4.9\times10^{-52}\)), and disclosure \(0.92\) vs.\(5.00\) (\(p{=}6.7\times10^{-38}\)). On a 30-query privacy-sensitive factual slice (Appendix 16), GapRouted ties Plan-and-Solve and ReAct in FA (\(p{=}0.86\) and \(0.65\)) while reducing forbidden-tool violations to \(\mathbf{0\%}\) (Plan-and-Solve \(78.9\%\), ReAct \(25.6\%\), Fixed-Probe \(100\%\)). Per-query wall-clock latency tells a more cautious story: GapRouted pays the IntentInferrer’s extra LLM round trip and is slower at the median than Fixed-Probe (\(4.08\) vs.\(2.37\) s; Appendix 17), so the cost-of-selectivity claim holds on probe count and disclosure rather than on latency. The mechanism’s primary accuracy contribution remains the implicit-need setting in Section 5.2; the factual-grounding regime bounds the cost of selective access.

5.1.0.2 Reflexion failure mode.

Reflexion (Table 1) collapses to \(0.174\) FA because the reflection step withdraws probe-supported claims (Appendix 21); the Full-vs-No-Probe contrast is near-null at gap\({\approx}0\) (\(p{=}0.060\)).

5.1.0.3 Privacy as a design benefit.

Gap routing’s zero forbidden-tool violation rate is not a post-hoc observation: low-gap factual queries receive \(B{=}0\) budget and skip the probe registry entirely, so they structurally cannot invoke a forbidden tool. This makes the access–cost Pareto a privacy Pareto as well.

5.1.0.4 Strict-precision robustness.

A strict-precision rescore (Appendix 15) confirms the access-cost picture: per-category gains concentrate on temporal and memory; the overall architectural margin above ReAct narrows (\(p{=}0.064\)). The IntentFrame’s primary accuracy contribution is the implicit-need regime (§5.2).

5.2 Implicit-Need Surfacing via Intent Inference↩︎

This subsection tests whether intent inference itself surfaces the user’s implicit information need on queries specifically designed to hide that need behind a literal surface form.

5.2.0.1 Query set.

We construct 25 primary implicit-intent queries stratified across five subcategories that vary the relationship between surface form and implicit need: availability (e.g., “where is Lin Wei?” \(\to\) “is she free?”), mood, appropriateness, latent_goal, and second_order (representative queries for the remaining four and the second-order belief-vs-truth judging rule in Appendix 20). The scene exposes only public state (location, action); private-state fields (availability, emotional state, unspoken goal, beliefs about others) are only retrievable via probe tools.

5.2.0.2 Conditions.

Four answer strategies share the same backbone (gpt-4o-mini, temperature 0.1) and a 5-tool agent-state registry (Appendix 11; disjoint from the factual-grounding registry): Literal (scene only, no tools); NoIntent (ReAct-style, up to \(B{=}3\) tool calls); Plan-and-Solve [6] (plan/execute/synthesise, budget 3); Intent (IntentInferrer \(\to\) gap-derived probe ceiling 0–3 \(\to\) directed tool loop, with heads-up prefix on high-gap queries). Each response is scored by a gpt-4o-mini judge on two dimensions in \([0,1]\): literal_score and implicit_score (does it surface the implicit need?). We run 3 seeds (42, 123, 456) over the 25 queries and report query-level paired \(t\)-tests as primary, with seed-level paired tests and query_id cluster bootstraps as secondary checks (Appendix 20).

3pt

5.2.0.3 Overall.

On the 100-query four-scene benchmark (Table 3), AURA-Intent reaches \(\mathbf{0.804}\) implicit-need coverage versus \(0.733\) for NoIntent (ReAct-style) and \(0.223\) for Literal: paired \(\boldsymbol{\Delta{=}{+}0.071}\), \(\boldsymbol{p{=}1.0\times10^{-6}}\). Three of four scenes are individually significant; the post-event night scene D ties because public state already telegraphs availability. A 25-query pilot (Scene A of the four-scene set, Table 2) confirms the direction at higher absolute gain (\(\Delta{=}{+}0.16\), \(p{=}0.006\)) and additionally tests Plan-and-Solve (\(\Delta{=}{+}0.28\), \(p{=}8.3\times10^{-5}\)) and two diagnostic upper bounds (fixed-private \(0.851\), oracle-intent \(0.861\); underpowered to separate from AURA at \(N{=}25\)).

5.2.0.4 Per-subcategory structure.

The 100-query v2 subcategory breakdown reveals where intent inference helps most. Availability shows the largest gain (\(\Delta{=}{+}0.29\), \(p{=}2.7\times10^{-11}\)): surface queries like “where is X?” fully mask the implicit need, so the IntentFrame’s gap score routes a probe that would not otherwise fire. Appropriateness (\(+0.11\), \(p{=}8.2\times10^{-4}\)) and mood (\(+0.07\), \(p{=}1.7\times10^{-3}\)) follow at smaller magnitudes. Second_order ties (\(-0.02\), NS) because “does X think Y…” already cues belief-state probing without gap inference. Latent_goal shows a residual deficit (\(-0.09\), \(p{=}6.2\times10^{-4}\)). The pattern tracks the controller’s design: the gap score adds value precisely when the surface form is maximally decoupled from the implicit need.

5.2.0.5 Ablation: prompt examples.

A three-way prompt ablation (Appendix 18) shows the gain is not example memorisation: disjoint examples reduce Intent by only \(\mathbf{0.037}\) (contrast remains significant). Removing examples entirely collapses the gap calibration and the Intent-vs.-NoIntent contrast becomes non-significant. The pattern is consistent with load-bearing gap calibration, not answer-template memorisation.

5.2.0.6 Cross-backbone.

The Intent-vs.-NoIntent gain reproduces on claude-haiku-4.5 (\(\Delta{=}{+}0.086\) on v2, \(p{=}3.7\times10^{-3}\)) and on qwen-plus (\(\Delta{=}{+}0.25\), CI \([+0.14, +0.37]\)). Per-backbone breakdown and a Gemini JSON-parse failure case in Appendix 19.

5.2.0.7 Backend ablation: gap inference is load-bearing.

Replacing the LLMIntentInferrer with a deterministic HeuristicIntentInferrer (rule-based gap estimation, identical downstream plumbing) drops overall implicit score from \(\mathbf{0.803}\) to \(0.368\) (\(\Delta{=}{-}0.44\); Appendix 24), with the largest drops on lexically-decoupled subcategories. The lift attaches to LLM-mediated gap inference, not the surrounding scaffolding.

5.2.0.8 Human evaluation.

Eight independent raters scored 50 paired (AURA vs.Vanilla) scenarios on four dimensions (Appendix 23.3). AURA receives significantly higher ratings on all four: environmental awareness \(\Delta{=}{+}1.86\) (\(p{=}0.017\), rater-aggregated Wilcoxon), response helpfulness \(+1.58\), agent believability \(+1.59\), factual accuracy \(+1.39\); all four cluster-bootstrap CIs exclude zero. At the cell level, \(74\%\) of (scenario, dimension) cells show \({\geq}6/8\) rater consensus for AURA; \(0\%\) show Vanilla consensus.

5.2.0.9 Adaptive budget: ceiling, not target.

Under fixed explore_max_steps=3, mean probes per query range \(0.80\)–\(2.20\) across subcategories and all four values \(\{0,1,2,3\}\) appear in the 75 runs; the Pearson correlation between gap and realised probe count is only \(\mathbf{r{=}0.19}\), so the gap routes a ceiling rather than determining a target; in practice the agent issues fewer probes than a fixed-budget system on most queries while retaining full budget for high-gap ones (per-subcategory distribution in Appendix 8.1).

6 Conclusion↩︎

AURA inserts a small inference step between scene perception and tool use: an IntentFrame whose gap score routes private-state probes before the agent answers. On a 100-query four-scene benchmark the controller significantly improves implicit-need coverage over ReAct-style probing (\(\Delta{=}{+}0.07\), \(p{<}10^{-6}\)), with three of four scenes individually significant and the gain reproducing across a 25-query pilot, a second backbone, and a prompt ablation. A backend ablation (LLM \(\to\) heuristic gap inference: \(0.803 \to 0.368\)) localises the lift to LLM-mediated gap calibration, suggesting that intent-direction is an LLM-prompted operation at a specific control point rather than an emergent property of the pipeline. The mechanism’s scope is bounded to situated regimes with tool-mediated hidden state (Limitations); whether this control-point view generalises to multi-turn, multi-user, or open-ended planning settings is an open question. Two extensions follow naturally. First, the IntentFrame currently operates on a single user query; in multi-turn dialogue the gap score could be updated incrementally as the conversation reveals more of the user’s intent, potentially reducing probe cost on follow-up queries. Second, the current gap-to-budget map is a hand-tuned step function; learning the mapping from interaction logs could improve calibration beyond what few-shot exemplars provide.

Limitations↩︎

6.0.0.1 Regime scope.

The IntentFrame controller targets situated queries with tool-mediated hidden state. On factual grounding (§5.1) it acts as an access–cost Pareto point rather than an accuracy winner; cross-domain checks on FANToM, LoCoMo, and GAIA show no measurable lift when private state is already in-context or structurally inaccessible (Appendices 26–28).

6.0.0.2 Benchmark and calibration.

The 100-query four-scene benchmark is author-written; inter-annotator agreement on the 5-subcategory partition is substantial (\(\kappa{=}0.61\), two independent annotators; details in Appendix 20). The few-shot calibration examples are load-bearing for gap estimation: removing them reduces the gain to non-significance, though replacing them with benchmark-disjoint examples preserves it (Appendix 18). Human evaluation uses \(N{=}8\) raters (Krippendorff’s \(\alpha{=}0.43\)); directional agreement is strong (\(74\%\) consensus) but magnitude estimates carry substantial uncertainty.

6.0.0.3 Cross-backbone.

Three of four tested backbones reproduce the gain; gemini-2.5-flash fails the IntentFrame JSON parser and silently falls back to a heuristic (Appendix 19).

7 Bounded-Probing Algorithm↩︎

8 Adaptive-Budget Evidence (Supplementary)↩︎

This appendix expands the adaptive-budget claim summarised in Section 5.2: under a fixed global explore_max_steps=3 ceiling, the per-query probe count actually issued by AURA varies across subcategories by \(2.8\times\), and is driven by the IntentFrame’s gap field rather than the configured ceiling. Figure 5 shows the per-subcategory implicit-need scores, Figure 4 the gap-vs-probes scatter, and Table 4 the per-subcategory means with paired latencies.

8.1 Adaptive Budget: LLM-Directed Probe Allocation↩︎

A practical concern for any bounded-probing system is whether the configured probe ceiling simply becomes a fixed per-query cost. We therefore measure the effective number of probes issued after the IntentFrame sets a ceiling and the Explore loop decides whether to stop early. This analysis does not try to define autonomous-agent behavior; it checks the narrower mechanism claim that intent inference changes probe allocation across queries.

Using the same 25-query \(\times\) 3-condition \(\times\) 3-seed run as Section 5.2 (for AURA-full only; \(N=75\)), we measure the probe-count distribution conditional on query subcategory, while holding explore_max_steps=3 constant across all runs. The configured budget is therefore a ceiling, not a target.

3pt

8.1.0.1 Observed allocation patterns.

(i) Effective probe count is not constant. Mean probe count per query ranges from \(0.80\) (availability) to \(2.20\) (appropriateness), despite the same global explore_max_steps=3 setting.

(ii) All four budget values are used. Across the 75 runs, the agent issued \(\{0, 1, 2, 3\}\) tool calls—the full effective range allowed by the run. This is consistent with the intended design: the configured budget is a ceiling, not a target.

(iii) Gap is an input, not the decision itself. The second_order subcategory has the highest observed gap (\(0.80\)) yet uses only \(1.00\) probe on average. The gap-to-budget rule maps \(0.80\) to a ceiling of three probes, but the Explore loop usually stops after one targeted belief-state call because that call already returns the needed value. The Pearson correlation between gap and actual probe count is \(r = 0.19\), so the gap is not a proxy for the final number of tool calls.

Taken together, these traces support the mechanism claim that IntentFrame-conditioned probing changes the cost and evidence gathered for different queries under the same run configuration.

8.1.0.2 Scope of the claim.

The architecture remains a hybrid system: Perceive, Scene, and Memory are code-determined, while intent inference, probe selection, and response generation use LLM calls. The adaptive-budget result should therefore be read as evidence about one control point in the system, not as a broad claim about every stage of the pipeline.

4pt

9 Private-State Evolution Rules↩︎

Private fields on each agent (availability, emotional_state, unspoken_goal, beliefs_about_others) update each simulation tick under a deterministic, transparent rule table (source: demo/town/private_state_evolution.py). The intent is to make AURATown’s private state a live function of agent action and environment context rather than a static lookup. Rules are evaluated in order; the first match wins.

3pt

9.0.0.1 Beliefs-about-others refresh.

Each agent’s beliefs_about_others dictionary entries refresh only when this agent is co-located with the target agent in the same simulation tick. Beliefs about non-co-located agents remain at the most recently observed value, so they go stale when peers move. This is the substrate the second_order subcategory of the implicit-intent benchmark (§5.2) probes: a query like “does Lin Wei think Zhang Hao is at home?” asks for the believer’s stale memory, not the target’s current ground-truth.

The full rule table is unit-tested at tests/test_private_state_evolution.py (14 cases, all rules + co-location/staleness invariants). The evolution itself is pure-function and zero-LLM, so it is reproducible across seeds and is not a confound when ablating other mechanisms.

10 AURATown Agent Profiles and Map↩︎

AURATown is a 60\(\times\)​60-grid simulation of five named agents living in twenty named locations (homes, commerce, civic, parks). The five agents (Table 7) and their starting locations (Figure 6) are fixed across all experiments. Each agent has both public state (location, current action, nearby agents) visible to all queries and private state (availability, emotional_state, unspoken_goal, beliefs_about_others) accessible only via probe tools.

4pt

11 Probe Tool Descriptions↩︎

Factual grounding (§5.1) uses an eight-tool environment registry (Table 8); each tool returns a structured fragment of the simulation state. The implicit-intent setup (§5.2) uses a separate five-tool scripted registry (get_all_agents, get_nearby_agents, get_agent_plan, get_agent_private_state, get_agent_belief_about) over a fixed scene snapshot rather than event-history. The two registries are disjoint by design — the factual-grounding registry probes the world state through scene-aware tools, the implicit-intent registry probes individual agents’ public and private states. The chat/demo deployment additionally exposes both registries, so a deployed agent has access to both base environment tools and private-state/belief probes.

3pt

12 Implementation Details↩︎

This section records the LLM, memory, simulation, and infrastructure parameters that hold throughout the experiments. All numbers report mean\(\pm\)std over the three seeds \(\{42, 123, 456\}\) unless explicitly noted.

12.0.0.1 LLM Configuration.

All LLM calls use gpt-4o-mini via the OpenAI API with:

• Action decision: temperature 0.7, default max tokens

• Probe planning: temperature 0.2, max tokens 200

• Conversation generation: temperature 0.8, max tokens 600

• Reflection: temperature 0.5, default max tokens

• Importance scoring: temperature 0.1, max tokens 50

12.0.0.2 Memory Configuration.

Maximum 200 items per agent, retrieval weights \(w_r = 0.3, w_p = 0.4, w_v = 0.3\), recency decay \(\lambda = 0.01\), reflection threshold \(\theta = 10\).

12.0.0.3 Simulation Parameters.

30-minute ticks, 6:00–23:00 day cycle, conversation cooldown 2 ticks, probe cooldown 2 ticks, movement speed 3 grid units/tick.

12.0.0.4 Infrastructure.

Python backend serving HTTP API on port 7861 with threading for concurrent state/chat/step requests. React frontend with canvas-based pixel-art rendering, viewport camera system, and real-time state updates.

13 Concrete Examples, Comparisons, and Diagrams↩︎

This appendix collects the figures and the proactive-frameworks comparison referenced from the body but moved out for space.

13.0.0.1 Motivating contrast (Figure 7).

A vanilla LLM and AURA on the same query in the same scene state. Vanilla returns the literal location only. AURA infers an implicit availability need, probes the cafe scene for nearby agents and the target’s private state, and returns the location with a heads-up alert that she is currently busy.

13.0.0.2 IntentFrame example (Figure 8).

An example IntentFrame produced by the LLM-backed IntentInferrer on a single AURATown query. Six fields are emitted (literal_need, implicit_need, gap, recommended_probes, should_alert, confidence) and consumed by the Explore and Interact stages (§3.3).

13.0.0.3 Long-context prompt-content sketch (Figure 9).

Figure 9 sketches the token-cost difference between packing the full environment state into the prompt and AURA’s selective probing on the same AURATown scene. Token counts from the AURATown prompt log; latency and FA from Tables 1, 2. This is an illustrative sketch, not a head-to-head experiment: the Static-Context baseline (FA \(0.450\)) is the closest in-suite analogue but does not include private state or memory, so a true full-state long-context baseline is left for future work.

13.0.0.4 Proactive frameworks comparison (Table 9).

Table 9 positions AURA relative to recent proactive and tool-using agent frameworks along three orthogonal axes (decision target, trigger, selection) and reports per-query latency for frameworks we re-implemented under our backbone. “–” marks frameworks that address an orthogonal decision (when to assist from sensor/behaviour patterns) and were not re-run on our factual benchmark.

3pt

14 Experimental Setup (Full)↩︎

14.0.0.1 Baselines.

We compare AURA against six baselines on the factual-grounding benchmark (Table 1) and four on the implicit-intent benchmark (Table 2):

1. Vanilla LLM: direct gpt-4o-mini generation with no environmental context (factual grounding).

2. Static Context: LLM receives a packed scene snapshot (location, time, nearby agents) but no proactive information gathering (factual grounding).

3. ReAct Agent [5]: Thought–Action–Observation interleaved during reasoning. Same eight base environment tools as AURA on factual grounding; same five-tool scripted registry on the implicit-intent benchmark.

4. Reflexion [7]: ReAct + self-reflection, up to 2 retry rounds (factual grounding).

5. Plan-and-Solve [6]: Phase-1 plan-from-surface-query, Phase-2 execute, Phase-3 synthesise (factual grounding + implicit-intent benchmark).

6. AURA (No Probe): AURA architecture with the probe budget forced to \(0\) (factual-grounding ablation).

7. AURA (Full): complete pipeline with IntentFrame-derived budget and tool selection.

We do not re-run Generative Agents [3] or ContextAgent [23] as paired baselines: Generative Agents’ passive observation string is subsumed by our Static Context; ContextAgent targets a different decision (when to assist from sensor streams) and is discussed as related work in Appendix 13.0.0.4 rather than an in-suite comparator.

14.0.0.2 Models and metrics.

Backbone gpt-4o-mini, temperature 0.7; gpt-4o-mini LLM-as-judge at temperature 0.1 [34], combined with a rule-based pre-filter on location and time consistency. Judge and agent share the same model family (gpt-4o-mini), which reduces judge–policy independence; we mitigate by reporting a strict precision rescore (Appendix 15) that uses only the judge’s CORRECT/CONTRADICTED claim-level classifications and drops the soft completeness component. Metrics: Grounding Accuracy (GA, 5 sub-dimensions, inspired by AgentBench [9]), Factual Accuracy (FA, 50 environment-grounded queries in 5 categories), SOTOPIA Social Score (7 dimensions from [12]), Context Utilization (CU), Latency.

15 Strict Precision Rescore for Factual Grounding (Robustness Check)↩︎

The factual accuracy (FA) reported in Section 5.1 uses an LLM-as-judge whose final score combines a hard precision component (correct/(correct+contradicted) over the judge’s claim-level classifications, weight \(0.7\)) with a soft completeness component (a 0/0.5/1 rubric for whether the response addressed the question, weight 0.3). Soft components are sensitive to phrasing and judge mood.

We rescore the same per-query records with strict precision only, drop the completeness term, and additionally report the per-query hallucination rate (fraction of (query, seed) cells with \(\geq 1\) contradicted claim) and perfect-response rate (0 contradicted AND \(\geq 1\) correct). The rescore script and output JSON are listed in Appendix 30.

Three honest takeaways relative to the lenient table in Section 5.1:

• vs. Vanilla: the architectural-effect headline holds and gets larger (\(+0.609\) strict precision, \(p < 10^{-4}\)).

• vs. ReAct (the fair-tools baseline): the strict precision gap is \(+0.090\) (\(p{=}0.064\), query-level paired \(t\)-test, \(n{=}50\)) — not significant. AURA also has a higher hallucination rate than ReAct (\(66.7\%\) vs.\(51.3\%\), \(\Delta{=}+15.3\) pp, \(p{=}0.013\)). Reading these two together, the architectural pipeline’s contribution above a tool-using ReAct baseline is small under strict scoring.

• vs. AURA NoProbe: strict precision rises by \(+0.062\) (\(p{=}0.032\)); the lenient version of this contrast was \(p{=}0.299\). The probing mechanism is more clearly supported under strict scoring than under the soft FA, while the overall architectural margin shrinks.

The per-category strict precision (Table 11) localises the gains: AURA (Full) wins on temporal (\(0.892\)) and memory (\(0.740\)) categories and loses to ReAct on social and spatial. The original “social win for probing” from the lenient analysis does not survive strict scoring; we update Section 5.1’s scope condition accordingly in the discussion.

16 Privacy-Sensitive Distractor Slice↩︎

The factual-grounding primary FA metric rewards factual completeness but does not penalise unnecessary access. We therefore authored a 30-query factual slice whose gold answers require public facts only. Each query carries a forbidden_tools list over high-disclosure tools (memory.recent, world.events_recent, agent.plan) plus query-specific extras; a violation is any fired forbidden tool in the query–seed cell. We run the same three seeds as the factual-grounding benchmark.

Against GapRouted, Fixed-Probe gains \(+0.080\) FA only marginally (\(p{=}0.056\)) while adding \(+100\) pp forbidden-tool violations. Plan-and-Solve and ReAct are tied in FA with GapRouted (\(p{=}0.856\) and \(p{=}0.655\)) but incur \(+78.9\) pp and \(+25.6\) pp violations. This slice makes the factual-grounding tradeoff explicit: saturated access is often accurate, but it violates stated access constraints by construction; gap routing is not FA-dominant, but it operates on the low-violation, low-probe side of the Pareto frontier.

17 Cost and Latency Across Conditions↩︎

The Pareto framing in Section 5.1 ranks conditions on access cost (probes) and disclosure, not wall-clock. Table 13 reports median and mean per-query latency from the same multi-seed runs so the wall-clock side of the tradeoff is auditable. Medians guard against rare upstream-API timeouts that inflate means (most pronounced for the implicit-intent v1 tom row, where one \(604\) s API hiccup on seed \(456\) pulls mean to \(13.85\) s while median stays at \(5.31\) s).

4pt

^\(\dagger\) Median is more representative; mean is inflated by one \(604\) s upstream-API outlier across the \(75\) query–seed cells.

Two observations qualify the Pareto picture. First, AURA GapRouted is not the fastest condition despite firing the fewest probes: the IntentInferrer is a single extra LLM call (\(\approx 2\) s on gpt-4o-mini), so GapRouted’s median latency sits above Fixed-Probe (\(4.08\) vs.\(2.37\) s on factual grounding; \(3.97\) vs.\(1.47\) s on the privacy slice). The probe-count win does not translate into a wall-clock win at small budgets. Second, Reflexion’s median latency (\(16.5\) s) is the regime outlier; its retry loop pays the cost without buying accuracy. We treat latency as a reportable axis rather than a paper claim: the cost-of-selectivity story holds on probe count and disclosure, not on wall-clock.

18 Prompt Ablation for IntentFrame Calibration↩︎

We audit whether the IntentFrame gain comes from benchmark-overlapping few-shot examples or from calibrated gap estimation. Table 14 compares three prompt variants on the same 25 implicit-intent queries and three seeds. The leaked row uses the original benchmark-overlapping examples and is reported only for diagnosis; the clean row is the final system; the no-few-shot row keeps the same rubric but removes all examples.

Clean few-shot is only \(0.037\) below the leaked prompt, so the main effect is not driven by memorising names or locations. In contrast, removing examples reduces Intent to \(0.677\) and makes the Intent-vs.-NoIntent gain non-significant. Mechanistically, the no-few-shot prompt underestimates the gap: mean inferred gap drops from \(0.589\) to \(0.476\), and high-gap cells (\(g{\ge}0.60\)) drop from \(43/75\) to \(22/75\). The few-shot examples are therefore load-bearing calibration for gap-to-budget routing.

19 Cross-Backbone Intent-vs.-NoIntent (Robustness)↩︎

To check that the Intent-vs.-NoIntent gain reported on gpt-4o-mini is not specific to one backbone, we re-ran the 25 implicit-intent queries on three additional production-grade LLMs (each via its vendor’s official API; judge fixed at gpt-4o-mini to keep the scoring rubric constant). Table 15 summarises the result. The gpt-4o-mini row is the clean calibrated prompt used in the main paper; the other backbones are single-seed robustness probes. Three of four backbones reproduce the gain; gemini-2.5-flash regresses, but the regression is explained by JSON-schema parse failure on \(23/25\) IntentFrame calls and silent fallback to the deterministic heuristic — a format-compliance boundary.

20 Expanded Implicit-Intent v2 Details↩︎

To test whether the 25-query scene is over-specialised, we authored an expanded implicit-intent v2 set with 4 scene snapshots \(\times\) 5 subcategories \(\times\) 5 queries (\(100\) queries; \(300\) scored cells per condition). Scene A preserves the original 25 queries; scenes B–D vary location, time of day, agent rosters, private states, and stale belief-vs-truth mismatches. Each v2 query records gold_required_tools and forbidden_tools; all second-order queries forbid direct get_agent_private_state access because the correct evidence is the believer’s recorded belief, not the target’s ground truth.

20.0.0.1 Subcategory examples.

Representative surface queries by subcategory: availability “where is Lin Wei?” (implicit: “is she free?”); mood “how is Chen Mei today?” (implicit: “is she in a receptive emotional state?”); appropriateness “is now a good time to invite Lin Wei for coffee?” (requires integrating schedule and private state); latent_goal “what is Lin Wei up to?”; second_order “does Lin Wei think Zhang Hao is free?” (the correct answer must report the believer’s recorded belief, not the target’s ground truth

20.0.0.2 Inter-annotator agreement.

Two independent annotators (computer-science graduate students, distinct from the authors and naive to the AURA architecture) re-labelled the 25-query pilot set under the 5-subcategory definitions given in the task instructions. They reached Cohen’s \(\kappa{=}0.61\) (substantial under Landis-Koch; raw agreement \(68\%\), \(17/25\)). All 8 disagreements concentrate on two boundaries: (i) mood vs.appropriateness/availability (4/8; e.g., “Does Zhang Hao look busy?” admits both an availability reading and a mood reading), and (ii) appropriateness vs.literal/availability (3/8; e.g., “Can I ask Wang Jun for a favor right now?” splits between a literal-permission reading and a context-aware appropriateness reading). Per-class agreement is highest on second_order (24/25 between annotators) and latent_goal (24/25); collapsing mood into a single context-aware availability super-category yields \(\kappa{=}0.68\). Raw label dumps are released alongside the queries.

3pt

20.0.0.3 Scene-level read.

Three of four scenes are clearly positive (A/B/C), and the post-event night scene D ties: agents are spatially distributed in D and the public state already telegraphs availability, so the gap mechanism has nothing to add.

20.0.0.4 Subcategory breakdown (Intent vs.NoIntent, cell-level \(n{=}60\) per cat).

availability \(+0.29\) (\(p{=}2.7\times10^{-11}\)), appropriateness \(+0.11\) (\(p{=}8.2\times10^{-4}\)), mood \(+0.07\) (\(p{=}1.7\times10^{-3}\)), second_order \(-0.02\) (\(p{=}0.32\), NS) after a synthesis-prompt fix that drops the public-state dump on belief-state queries and adds a strict “report belief, not actual state” instruction, and latent_goal \(-0.09\) (\(p{=}6.2\times10^{-4}\), residual deficit acknowledged in Limitations).

20.0.0.5 Cross-backbone v2.

Re-running the 100-query set on claude-haiku-4.5 (seed 42 only, via OpenRouter) reproduces the gain at larger magnitude: Intent \(0.876\) vs.NoIntent \(0.790\), paired \(\Delta{=}{+}0.086\), \(p{=}3.7\times10^{-3}\). The scene-D tie pattern replicates (\(\Delta{=}{+}0.008\), \(p{=}0.88\), NS), confirming the night-scene null is a property of the regime rather than a single-backbone artifact.

21 Factual-Grounding Per-Category Paired Contrast↩︎

The aggregate AURA Full vs.AURA No-Probe contrast on factual grounding is a near-null (\(+0.038\) FA, \(p{=}0.060\) paired query-level), but this aggregate hides a heterogeneous per-category structure. Splitting the 50 queries into 5 categories of 10 (spatial / social / temporal / memory / planning), Table 17 shows that probing produces a significant FA improvement only on the social category. The other four categories are saturated by the Perceive/Scene channel, so probing has nothing to add. This is the empirical scope condition for proactive probing referenced in the main text.

22 Routine-Action Grounding (Null Result, Full Table)↩︎

The routine-grounding check measures whether richer environmental access changes Grounding Accuracy on routine daily simulation. The protocol is 100 simulation steps \(\times\) 5 conditions \(\times\) 3 seeds \(= 1{,}500\) judgments per condition; the metric averages four GA sub-dimensions (location consistency, time appropriateness, social awareness, plan adherence). Memory utilisation saturates at \(\approx 1.0\) for every method and is omitted from Table 18. The paired \(t\)-test column reports two-sided \(p\) vs.Vanilla. All five methods fall within \(0.024\) absolute GA spread; every contrast is non-significant. We report this null openly: when most actions are trivially grounded, GA cannot distinguish architectures.

All pairwise paired \(t\)-tests vs.Vanilla give \(p > 0.5\); a non-parametric Wilcoxon signed-rank test gives the same conclusion. The GA spread across five different architectures is \(0.024\), well inside per-condition seed variance. This is evidence the metric is saturated on this workload, not that probing fails; factual grounding (Section 5.1) reaches a \(9.1\times\) gap on queries that stress grounding.

23 Additional Diagnostic Checks↩︎

23.1 Component Ablation (Saturated-Workload Null)↩︎

We ablate each pipeline component on a routine-action workload of \(100\) simulation steps and \(50\) chat queries per configuration, three seeds, source data evaluation/results/rq3_ablation_study_multiseed.json. Table 19 gives the multi-seed mean GA / FA / latency deltas relative to AURA Full. (An earlier draft of this table reported single-seed numbers measured at 20 steps and 20 queries; we replace it here with the full multi-seed configuration to match the actual run.)

23.1.0.1 Interpretation.

Component-level deltas on the routine-action workload are uniformly small (\(|\Delta\text{GA}| \le 0.020\), \(|\Delta\text{FA}| \le 0.028\)). Removing the probing component does not hurt GA or FA on this workload; it saves \(1.3\) s of latency. The same null pattern that drives the routine-grounding saturation result (Section 22) drives the component-ablation null: routine actions like “sleeping at home at 6 AM” pass any reasonable grounding check, and the LLM-as-judge factual scoring with completeness has a \(\pm 0.03\) noise floor that swamps the per-component contribution. Memory has the largest negative GA effect (\(-0.017\)) but with FA actually slightly higher when memory is removed — consistent with the same noise floor, not a clean component effect. The picture changes on the factual-grounding chat workload (Section 5.1), where the same architecture moves FA from \(0.07\) (Vanilla) to \(0.64\) (Full); the bottleneck the ablation in this table fails to expose is the same one the routine-grounding check fails to expose: action-grounding on routine days does not stress the structured-environment-access channel.

23.2 Emergent Social Behaviours (SOTOPIA)↩︎

200-step multi-agent simulation, 36 conversations evaluated on SOTOPIA’s 7 dimensions [12]. Overall quality 7.87/10, strongest dimensions goal (9.5) and believability (9.0); 44 emergent behaviours across 4 categories: collaboration (32), routine adaptation (7), conflict resolution (4), group formation (1).

The collective-behaviour analysis of these numbers is in Appendix 32 (Section 32.1).

23.3 Human Evaluation↩︎

We collected pairwise A/B annotations from 8 independent raters on the 50 chat scenarios, four dimensions each (response helpfulness, environmental awareness, agent believability, factual accuracy) on a 5-point Likert scale, side-randomised and blinded to system identity. This gives \(N{=}400\) paired query-rater observations per dimension. Both responses on each item were generated with the fixed system prompt at the same AURATown simulation tick (warmup 10 steps, seed 42); raters saw the query, the asking agent’s name, the category, and the two anonymous responses but not the underlying simulation scene state.

23.3.0.1 Headline.

AURA receives higher ratings than Vanilla LLM on all four dimensions under the conservative rater-aggregated test (\(N{=}8\) paired rater-means per dimension; Wilcoxon \(p{=}0.017\) each, sign 7-1-0 for every dimension). All four cluster-bootstrap CIs on the per-rater \(\Delta\) exclude zero. The largest gap is on environmental awareness (\(\Delta{=}+1.86\), CI \([+1.08, +2.62]\)), consistent with the environment-mediated design. The cell-level paired test on the 400 (rater \(\times\) scenario) cells gives \(p<10^{-4}\) but treats within-rater repeated measures as independent, so we report the rater-aggregated \(p{=}0.017\) as the primary statistic. Fig. 11 visualises the per-rater means against the pooled distribution.

23.3.0.2 Per-rater profile (transparency).

Per-rater mean \(\Delta\) ranged from \(-0.30\) to \(+3.18\) across the 8 raters; per-rater AURA-better rates were \(\{24.0, 69.0, 81.5, 82.5, 85.0, 85.0, 98.5, 100.0\}\%\). Seven of eight raters preferred AURA on aggregate; one rater (24% AURA-wins, \(\Delta{=}-0.30\)) reported in post-task debrief that they had penalised plausible-but-unverifiable specifics in AURA’s responses as factual errors. We retain that rater in the primary analysis to avoid post-hoc exclusion bias and discuss the implication under “Methodological limitations” below.

23.3.0.3 Direction-agreement at the cell level.

For each of the 200 (scenario, dimension) cells, we count raters preferring AURA, Vanilla, or scoring tied. Defining “consensus” as \(\ge 6\) of 8 raters agreeing on direction, we find: \(\mathbf{0/200}\) cells have a Vanilla consensus, \(\mathbf{148/200}\) (\(74\%\)) have an AURA consensus, and \(52\) are split. Per-dimension AURA-consensus rates: helpfulness \(76\%\), env-awareness \(80\%\), believability \(72\%\), factual-accuracy \(68\%\). Average per-cell AURA-preference rate: \(78.2\%\).

23.3.0.4 Inter-rater reliability.

Pooled across all dimensions, Krippendorff’s \(\alpha_{\text{ord}}\) on the raw 1–5 scores is \(0.43\) (per-dimension range \(0.34\)–\(0.47\)), indicating moderate agreement on absolute quality. Item-level \(\alpha\) on the preference difference \(\Delta\) is much lower (\(\alpha_{\text{ord}}{\in}[0.03, 0.17]\) per dimension) because raters differ systematically in scale-use (one rater uses 5/1 polar ratings, others use 4/2). The direction of preference is nonetheless highly consistent (above: \(74\%\) AURA-consensus, \(0\%\) Vanilla-consensus). We report all three numbers and treat the pattern as: agreement on direction is strong, agreement on magnitude is weak, and headline effect sizes pool through this magnitude variance.

23.3.0.5 Sensitivity analysis.

Excluding the one reverse-preference rater post-hoc yields \(N{=}7\) and strengthens all four dimensions: helpfulness \(\Delta{=}+1.85\), \(d_z{=}1.45\); environmental awareness \(\Delta{=}+2.15\), \(d_z{=}1.62\); believability \(\Delta{=}+1.86\), \(d_z{=}1.41\); factual accuracy \(\Delta{=}+1.65\), \(d_z{=}1.37\). We report this only as a robustness check; the headline numbers in Table 21 are the \(N{=}8\) primary analysis.

23.3.0.6 Per-category structure.

The category ordering is consistent with the factual-grounding per-category analysis: temporal (\(+1.83\) avg) and memory (\(+1.77\)) at the top, spatial (\(+1.29\)) and planning (\(+1.37\)) lower. Social (\(+1.77\)) matches the factual-grounding finding that proactive probing helps most where residual environmental uncertainty is concentrated.

23.3.0.7 Independent fabrication scan.

Independently of the human ratings, we manually scanned all 50 AURA responses for fabricated proper-name entities (locations or characters absent from the AURATown setup, which has 20 named locations and 5 named characters). Two scenarios contain explicit fabrications: scenario id 6 lists “Bookstore, Art Supply Store, Clothing Boutiques, Craft Stores, Gift Shops” (none exist among the 20 locations); scenario id 7 references “Main Street” and “The Cozy Corner Cafe” (AURATown has neither that street nor a cafe by that name; the only cafe is Sunrise Cafe). The other 48 responses cite only roster-real locations and characters, giving a static-entity fabrication rate of \(2/50 = 4\%\). The scan is reproducible from the released response set against the canonical roster in demo/town/assets/town_map.json.

23.3.0.8 Methodological limitations.

(1) Sample size. \(N{=}8\) is small relative to managed crowdsourcing studies. The consistency of direction across raters and the large effect sizes mitigate but do not substitute for a larger study; primary statistics should be read as evidence of a large effect with substantial uncertainty around the precise magnitude. (2) Recruitment. Raters were recruited individually rather than through a managed platform (Prolific, MTurk). (3) Dynamic-state factual accuracy is incompletely measured. The form did not display simulation scene state at query time, so raters’ factual_accuracy judgments mix verifiable static-entity checks (catchable from the on-form roster) with trust-prior on dynamic-state claims (agent positions, current activities). The independent fabrication scan above bounds the static rate at \(4\%\); precise quantification of dynamic-state error requires deterministically recapturing scene state at each query’s generation time, which is future work. (4) IRR is moderate. \(\alpha \approx 0.4\) on raw scores reflects scale-use heterogeneity across raters; we publish all per-rater data so this variance is auditable.

23.4 Probe-Budget Sweep (Full Multi-Seed)↩︎

We vary the probe budget \(B\) from 0 to 5 and measure GA and latency per step (500 GA judgments per budget per seed, averaged across 3 seeds \(\{42, 123, 456\}\)). Fig. 12 visualises the GA-vs-latency Pareto frontier.

The Pareto frontier contains exactly two points, \(\{B{=}0, B{=}1\}\); \(B{=}1\) is the peak. \(B{=}0 \to B{=}1\) adds \(+0.0122\) GA (\(+1.4\%\) relative) at \(+4.1\) s latency; every \(B \ge 2\) is Pareto-dominated. An earlier single-seed pilot reported \(B^* {=} 2\); the 3-seed replication withdraws that claim. On the routine-grounding metric the curve is consistent with a monotonically saturating information channel rather than a clean crossover: one probe fills the scene snapshot, subsequent probes contribute little. The same single probe buys \(+13.7\) pp implicit score in the social sub-regime (Section 5.2, Table 5), confirming that the budget-sweep’s small absolute gain is a feature of the metric, not the mechanism.

23.5 Judge Disagreement↩︎

We quantify judge disagreement between the rule-based pre-filter and the LLM judge across 7,500 multi-seed judgments in Table 23. Disagreement varies by dimension: time appropriateness shows the highest rate (\(61.9\%\), rule stricter in \(99.5\%\)), location consistency \(48.4\%\) (\(92.3\%\) rule-stricter), plan adherence \(32.0\%\) (\(83.0\%\) LLM-stricter), social awareness \(13.5\%\) (\(98.8\%\) LLM-stricter), memory utilisation \(0.0\%\). We resolve disagreements by taking the stricter score (conservative grounding estimate).

24 Heuristic vs.LLM IntentInferrer (Backend Ablation)↩︎

The IntentFrame pipeline of Section 3.3 admits two backends: a deterministic HeuristicIntentInferrer (rule-based gap estimation from a small vocabulary of social/private-state markers) and LLMIntentInferrer (gpt-4o-mini producing the frame as JSON). The main implicit-intent run uses the LLM backend. We isolate the inferrer’s contribution by running the SAME 25 implicit-intent queries \(\times\) 3 seeds with the heuristic backend; all other plumbing (gap-to-budget map, directed probe loop, judge) is identical.

24.0.0.1 Reading.

The heuristic recovers \(+0.18\) over Literal on aggregate but lags the clean calibrated LLM backend by \(-0.44\). Per-subcategory: the heuristic stays near Literal on availability (\(0.27\) vs.\(0.29\)) and ties Literal on latent_goal (\(0.00\) vs.\(0.00\)) because its trigger vocabulary (“available”, “mood”, “appropriate”, “up to”) does not match the surface of those query classes (“where is X?”, “what is X up to?”); the gap estimator returns \(0\) and the heuristic falls through to the literal answer. On second_order it does well (\(0.77\)) because “thinks”, “believes”, and “perspective” do appear in the trigger set. The contrast quantifies what the LLM backend buys: \(+0.44\) aggregate at \(7.3\times\) the heuristic latency, with the LLM doing the work precisely where surface cues fail.

24.0.0.2 Implication.

Section 5.2’s headline gain is attributable to the LLM backend, not the gap-to-budget mapping or the probe-loop machinery. Distilling a faster intent classifier from the LLM backend is a practical optimisation; the rule-based shortcut is not.

25 Cross-Domain Sanity Checks↩︎

The main-body results live in the social-simulation regime where the Environment Agent pipeline was designed. To probe how the architecture transfers, we ran four additional benchmarks outside that regime; we report them here as sanity checks rather than as headline contributions. All four runs are single-seed (vs. seeds for the main implicit-intent and factual-grounding experiments) and per-run sample sizes vary: InteractiveBench Puzzle \(20\) episodes, Trust \(6\) games/condition, Math \(20\) questions, MemoryArena \(n{=}1\) paper across \(5\) subtasks. Trust (\(n{=}6\)) and MemoryArena (\(n{=}1\)) are underpowered for statistical inference and are reported as observational anchors only; we do not run paired tests on them.

25.0.0.1 InteractiveBench — Puzzle (text adventure).

20 multi-turn puzzle episodes per condition, single seed, gpt-4o-mini. AURA (Full) reaches \(0.70\) accuracy, Vanilla LLM \(0.65\), AURA (No-Probe) \(0.45\). The architecture-without-probing under-performs Vanilla here because the No-Probe pipeline injects an empty environment context that consumes turns; restoring probing recovers and slightly exceeds Vanilla (\(+5\) pp absolute, \(+7.7\%\) relative). This is the cleanest cross-domain signal we observe.

25.0.0.2 InteractiveBench — Trust (iterated prisoner’s dilemma).

6 games per condition against three opponent strategies (TFT, GrimTrigger, Random). Aggregate payoff per round: Vanilla \(1.31\), AURA No-Probe \(1.64\), AURA Full \(1.15\). The aggregate is dominated by opponent-mix imbalance: against deterministic strategies all conditions reach the cooperative equilibrium of \(2.00\) payoff/round; against the noisy random opponent, the sample sizes differ (\(n_{\text{rounds}} = 17, 16, 28\)) and the AURA Full mean is \(0.96\). We interpret this as the negative counterpart to Puzzle: when the “environment” is an adversarial opponent whose private state cannot be probed, additional context gathering does not help and may slow convergence. We do not claim a positive result on Trust.

25.0.0.3 InteractiveBench — Math (LaTeX-conditional QA).

20 questions per condition, single seed; all three conditions reach \(\approx 1.9\%\). The LLM judge is conservative on LaTeX-formatted answers and returns repeated parse errors (e.g., “Invalid \escape”) that we manually verified mark correct agent responses as incorrect. We report the result as null and attribute it to judge brittleness, not to a meaningful gap between conditions; a per-domain custom judge is future work.

25.0.0.4 MemoryArena (research-paper Q&A, formal reasoning) — anecdotal \(n{=}1\).

We ran a single-paper smoke test (1 paper \(\times\) 5 subtasks, single seed), which is too small to support a quantitative claim and we do not run statistical tests on it. We report the observation for completeness: AURA (memory only) and AURA (no_probe) reach \(5/5\) partial-success (\(PS{=}1.0\)); AURA (full) reaches \(2/5\) (\(PS{=}0.4\)). The full-pipeline under-performs because probe results pollute the long mathematical context with environment-style snippets—the same “hallucinated context” failure mode observed at \(B \ge 3\) (probes add noise faster than they reduce errors), here amplified by the long-context formal-reasoning regime. Sample is too small to draw a quantitative claim, but the direction is consistent with the scope condition: the probing mechanism degrades when the task is symbolic and the tool returns are off-distribution.

25.0.0.5 Cross-domain takeaway.

The architecture transfers positively to a multi-turn puzzle domain, fails to transfer to adversarial games where opponent state cannot be probed, is masked by judge brittleness on LaTeX math, and under-performs on long-context formal reasoning where probe outputs pollute the context. Together with the GAIA negative-transfer result in Appendix 28, these data points describe the empirical envelope of the probing mechanism beyond the primary social-simulation setting.

26 FANToM External ToM Benchmark (Null Result)↩︎

To probe whether AURA’s intent-directed mechanism transfers to a standard, externally-validated theory-of-mind benchmark, we ran a 400-question stratified split of FANToM [35]: \(80\) questions per type across the five FANToM question types — beliefQA (multi-choice belief), answ_bin, answ_list (answerability binary / list), info_bin, info_list (info-accessibility binary / list). The \(80\) beliefQA questions are sub-stratified \(20{+}20{+}20{+}20\) across first-/second-order \(\times\) accessible/inaccessible. Backbone is gpt-4o-mini, seed=\(42\) (the OpenAI seed kwarg is accepted in this run, so backbone draws are deterministic when supported). Source: run_fantom_full.py; data: evaluation/results/fantom_full_seed42.json.

26.0.0.1 Statistical tests (per-question paired, \(n{=}400\)).

Intent vs.Literal: \(\Delta\text{acc}{=}{+}0.003\), paired \(t\) \(p{=}0.92\); McNemar \(p{=}1.0\). Intent vs.NoIntent: \(\Delta\text{acc}{=}{+}0.025\), paired \(t\) \(p{=}0.26\); McNemar \(p{=}0.31\). Both contrasts null.

26.0.0.2 Interpretation.

FANToM’s narrative ToM questions ship the full conversation in-context, so a competent backbone can answer literally without retrieval; the IntentFrame’s gap calibration finds little to direct, and the additional probe budget adds latency (\(6.5\) s vs.\(0.9\) s for Literal) without lifting accuracy. FANToM is therefore a clean negative case for AURA’s mechanism — the residual uncertainty \(H(\mathcal{E}\mid\mathcal{B})\) after passive context assembly is already low, so probing has nothing to reduce. This bounds the probing claim’s scope: AURA helps when private state lies behind a tool-mediated information frontier (multi-agent simulation, scene-grounded queries with hidden private state), and does not help on narrative ToM transcripts already in-context.

26.0.0.3 Backbone-capability corroboration.

The Intent condition’s IntentInferrer fell back to the deterministic heuristic \(0/400\) times on gpt-4o-mini (vs.\(23/25\) on gemini-2.5-flash in Section 5.2). The contrast confirms that the cross-backbone Gemini regression in Table 15 is a backbone-capability failure (Gemini’s structured-JSON adherence) rather than a problem with the IntentInferrer’s prompt or the AURA pipeline.

27 LoCoMo Long-Term Conversational Memory (Partial Transfer)↩︎

To probe whether the AURA pipeline transfers to the long-term-conversational-memory recall regime, we ran a 200-question stratified split of LoCoMo [36] (10 conversations \(\times\) 19–32 sessions \(\times\) \({\sim}20\) turns/session, \(2{,}206\) QA total across 5 categories). Backbone gpt-4o-mini, seed=\(42\), 8 parallel workers, OpenAI seed kwarg accepted. Source: run_locomo_smoke.py (re-runnable at LOCOMO_N=200); data: evaluation/results/locomo_smoke.json. Adapter at locomo_eval.py maps a conversation’s session list to AURA’s (scene, memories, query, available_tools) quadruple, with three simulated probe tools (get_session(n), search_by_speaker, list_sessions_on_date). Scoring follows the LoCoMo paper exactly: token-F1 with stem normalisation, multi-answer F1 for cat-1, semicolon-alternative for cat-3.

27.0.0.1 Statistical tests (per-question paired, \(n{=}200\)).

Intent vs.Literal: \(\Delta\text{F1}{=}{+}0.151\), paired \(t{=}8.11\), \(\mathbf{p<10^{-15}}\) — highly significant. Intent vs.NoIntent: \(\Delta\text{F1}{=}{+}0.020\), paired \(t{=}1.09\), \(p{=}0.28\) — not significant.

27.0.0.2 Interpretation.

The architecture-and-tools layer (NoIntent: probe-tool harness with no intent reframing) carries most of the gain from \(0.042\) to \(0.173\) F1; AURA’s IntentInferrer adds only an additional \(+0.020\) F1, which is not statistically significant on this sample. Read together with the FANToM null (Appendix 26), LoCoMo gives the same picture: the architectural pipeline transfers to long-term-recall and to narrative ToM, but the intent-direction stage’s marginal contribution above a tool-using baseline is regime-specific. It is significant on AURATown’s hand-designed implicit-intent set (Section 5.2) where private-state needs are deliberately hidden behind the surface form, and small-or-null on benchmarks where the underlying QA does not require this kind of lexical-vs-implicit gap inference.

The \(0/200\) IntentInferrer fallback rate (alongside \(0/400\) on FANToM) is the cleanest external corroboration that the original gemini-2.5-flash cross-backbone regression (Section 5.2) is a backbone format-compliance failure on Gemini’s part, not a problem with AURA’s prompt or schema.

28 GAIA Cross-Domain Run (Negative Transfer)↩︎

We ran the GAIA Level-1/2 question set (139 questions per condition, seed 42, gpt-4o-mini) under two conditions: probe (the AURA Explore stage with the OpenAI Responses API web_search tool) and direct (single-pass LLM, no tools).

28.0.0.1 Reading.

On Level-1 (single-step factual lookup) probing degrades accuracy by \(-1.9\) pp absolute; on Level-2 (multi-step reasoning) the two conditions tie. Total cost: probing spends \(22\times\) more wall time and \(3.5\) tool calls per question for no aggregate benefit.

28.0.0.2 Why the transfer fails.

GAIA’s environment is a search engine wrapped in an LLM-simulated browser. Each “probe” is itself an LLM call summarising a web page, not a structured-state read against a ground-truth simulator as in AURATown. Two consequences: (i) probe outputs inherit the backbone’s failure modes (hallucinated facts compound across the probe loop), and (ii) the residual \(H(\mathcal{E} \mid \mathcal{B})\) that probing was designed to reduce on social-availability queries is not the bottleneck on web-grounded factoid questions, where the backbone’s parametric knowledge dominates. This is the boundary case of the scope condition stated in Section 5.1: probing helps when (a) residual uncertainty after passive perception is non-trivial and (b) tool returns are structurally extractable. GAIA fails (b).

28.0.0.3 What we report.

We report GAIA as evidence about a regime in which the bounded-probing mechanism does not transfer. Coupling this with the InteractiveBench Trust negative and the MemoryArena formal-reasoning degradation, the empirical envelope of AURA’s probing contribution is structured social environments with extractable, non-hallucinated state probes.

29 Memory and Enrichment Protocol Details↩︎

29.0.0.1 Weighted retrieval.

For each memory \(m\), query \(q\), current time \(t\): \[\begin{align} \text{score}(m, q, t) &= w_r \cdot \exp(-\lambda (t - m.t)) \notag\\ &\quad + w_p \cdot \tfrac{m.\text{importance}}{10} \notag\\ &\quad + w_v \cdot \text{sim}(q, m.c) \label{eq:memory95score} \end{align}\tag{1}\] Default weights \((w_r, w_p, w_v) = (0.3, 0.4, 0.3)\), decay \(\lambda = 0.01\). \(\text{sim}(\cdot)\) is a keyword-based relevance function in the current prototype.

29.0.0.2 Memory types.

Following [33]: Observation (direct percepts), Conversation (dialogues), Reflection (synthesised insights every \(\theta = 10\) observations), Plan (daily schedules and goals).

29.0.0.3 Importance scoring.

When an LLM endpoint is available, importance is scored via a dedicated prompt (“Rate the importance of this event 1–10”); otherwise a keyword-based heuristic assigns scores based on emotional salience.

29.0.0.4 Three-stage enrichment protocol.

User query \(q\) to agent \(a_i\) triggers: (1) context gathering (perception + recent memories), (2) proactive probing (1-step for latency), (3) enriched generation with the structured context prepended. Enrichment metadata (tools called, context gathered) is exposed to the user for interpretability.

30 Reproducibility Checklist↩︎

30.0.0.1 Code and data.

All experiments are driven by the runners in scripts/ and run_experiments.py, with results saved to evaluation/results/. Each table or figure traces to a specific result JSON via evaluation/results/MANIFEST.md; the manifest covers factual-grounding multi-seed, factual-grounding Fixed-Probe and GapRouted Pareto controls, the privacy-sensitive distractor slice, implicit-intent clean-prompt multi-seed, fixed-private/oracle-intent controls, no-few-shot prompt ablation, Plan-and-Solve and Reflexion adapter outputs, FANToM 400q, LoCoMo 200q, the four cross-backbone runs, implicit-intent IAA returns, and the strict-precision rescore. The code release will include the AURA agent library, the AURATown simulation, all 50 environment-grounded queries with their templates, all 100 implicit-intent queries (4 scenes \(\times\) 25) with subcategory and target labels, and all per-condition / per-seed details that back the numbers reported here.

30.0.0.2 Models and APIs.

Agent backbone and judge are both gpt-4o-mini via the OpenAI Chat Completions API. Cross-backbone tests additionally use claude-haiku-4-5 (Anthropic), qwen-plus (Alibaba), and gemini-2.5-flash (Google), each via its vendor’s official API. Backbone temperature is 0.7 for action decisions, 0.1 for the judge and the IntentInferrer. We pass the seed parameter to the OpenAI Chat Completions API where the SDK accepts it; on rejection, the LLM engine falls back to a no-seed call and flips an internal flag for the rest of the run. Cross-backbone runs do not all support the seed kwarg, so the multi-seed claim is bounded as: “Python-level random sampling and OpenAI seed when supported.”

30.0.0.3 Determinism caveats.

Multi-seed paired tests for factual grounding / component ablation / implicit-intent vary the seed both at Python’s random module (controlling query ordering, agent shuffles, and template instantiation) and at the OpenAI API seed kwarg. Stochastic backbone decoding above the seed kwarg may still introduce per-seed variance; this is acknowledged in the Limitations and is consistent with the OpenAI API documentation that seed provides a best-effort, not strict, determinism guarantee. The simulation server itself derives its world generation from TownConfig.world_seed and the agent backbone derives its outputs from TownConfig.llm_seed; both are propagated through /api/reset.

30.0.0.4 Strict-paired factual grounding.

The factual-grounding runner (run_experiments.py:run_rq2) operates in two phases. Phase A: reset with the experiment seed, warm 10 steps, then advance one tick per query position to capture 50 ground-truth snapshots. Phase B: each AURA condition resets with the same seed, warms 10, and replays the snapshots; chats run with read_only=True so they do not write event log or memory, leaving the per-tick trajectory deterministic across conditions. External baselines (Vanilla, Static, ReAct, Reflexion, Plan-and-Solve) receive the same Phase-A snapshots. Output JSON stamps a _paired_snapshot_meta block recording seed, n_snapshots, and shared_snapshots_across_conditions=true.

30.0.0.5 Aggregate scripts.

rescore_rq2_strict.py recomputes the strict precision rescore (Appendix 15) from the multi-seed factual-grounding details. aggregate_rq2_multiseed.py collapses per-seed details into the canonical multi-seed summary. run_rq2_fixed_probe.py and run_rq2_aura_gap_routed.py regenerate the saturated and gap-routed factual-grounding controls; rq2_pareto_analysis.py computes FA/probe/disclosure contrasts and plot_rq2_pareto.py renders Figure 2. run_privacy_distractor.py regenerates the 30-query forbidden-tool slice. run_implicit_intent_full.py and run_implicit_intent_v2.py regenerate the primary 25-query and expanded 100-query (4-scene) implicit-intent runs respectively; the v2 runner supports --resume for interrupted multi-seed jobs and a --validate-only pre-flight pass on the benchmark JSON. compute_irr.py produces the IAA Cohen’s \(\kappa\) on the implicit-intent subcategory labels. rq5_rater_aggregated.py produces the per-rater aggregated Wilcoxon used in Table 21. run_fantom_full.py regenerates the FANToM 400-question external bench. run_locomo_smoke.py regenerates the LoCoMo run. audit_paper_numbers.py re-derives every cited headline from the JSON files and is the recommended pre-submission check.

30.0.0.6 Hardware.

All experiments run on a single CPU machine; the LLM is invoked via remote API. No GPU is required. Wall-clock budgets per run: factual-grounding multi-seed \({\sim}30\) min/seed; implicit-intent \({\sim}10\) min/seed; FANToM 400 questions \({\sim}9\) min; LoCoMo 200 questions \({\sim}6\) min; PnS-on-implicit-intent multi-seed \({\sim}16\) min total; Reflexion + PnS on factual grounding multi-seed combined \({\sim}2.5\) h. Total API spend for all reported experiments under $15 USD.

31 Ethics Statement↩︎

31.0.0.1 Research artefacts.

This paper studies an LLM agent architecture and accompanying social simulation. Human involvement consists of the 8 voluntary annotators of the helpfulness study and 2 additional annotators for the implicit-intent label audit. Annotators were friends and colleagues of the authors who consented to evaluate anonymous response pairs or query labels; no demographic data was collected; no personally identifying information appears in saved annotations. Annotators received no compensation; each task was a one-time, optional 15–30 minute evaluation. We retain a dissenting rater in the primary helpfulness analysis to avoid post-hoc exclusion bias and we report rater-level transparency (per-rater preference rates, Krippendorff’s \(\alpha\)) so that readers can inspect inter-annotator dynamics.

31.0.0.2 Simulation content.

AURATown’s 5 agents have hand-authored profiles (occupation, personality, daily routine). The names are fictional. Agent profiles deliberately span ages 20–68 and include contrasting personality types but are not intended to represent any real demographic distribution. The simulation does not emulate real people, real businesses, or real locations.

31.0.0.3 Misuse considerations.

The IntentFrame mechanism produces a structured estimate of a user’s implicit information need from a surface query. In a benign deployment this is used to surface relevant context the user did not lexically request; in an adversarial deployment, the same machinery could be used to surface information the user has not consented to share. The Explore stage’s tool whitelist is the principal mitigation: tools are scoped to the simulation’s structured environment state, not to external data sources. Practitioners deploying a similar IntentInferrer over real personal-data tools should constrain the whitelist accordingly and surface the inferred implicit need to the user (the heads-up prefix in our Interact stage is a minimal version of this).

31.0.0.4 Energy and compute.

All experiments run on remote API endpoints; the only local compute is a single CPU process running the AURATown simulation server. We did not benchmark API energy use; total token consumption across all reported runs is approximately 8 million input tokens and 200 thousand output tokens against gpt-4o-mini.

31.0.0.5 Limitations as ethics.

The paper’s empirical claims are scoped to the regime where structured environment access matters (single-user situated queries with hidden private state). Where the mechanism does not transfer ( narrative ToM in FANToM, web-grounded factoid in GAIA, formal reasoning in MemoryArena ) we report negative results in Appendix 26, 28, and 25. We avoid abstracting from these specific findings to general claims about LLM theory-of-mind or proactive assistance.

32 Collective Behaviour and Supplementary Discussion↩︎

32.1 Collective Behaviour in Multi-Agent AURATown↩︎

In the 200-step SOTOPIA run, 5 agents with independent AURA pipelines (IntentInferrer disabled) produce 44 emergent behaviours: collaboration (32, 73%), routine adaptation (7, 16%), conflict resolution (4, 9%), and group formation (1). SOTOPIA scores (Table 20) show strength on goal (9.5) and believability (9.0) but weakness on social_rules (\(-2.13\)) and secret (\(-0.67\)), indicating that structured environment access supports local coordination but not higher-order social constraint handling. These data supplement the SOTOPIA evaluation; they do not constitute a separate theory-of-mind claim.

References↩︎

---

1. Corresponding author.↩︎