WorksComputer Science
Securing and Auditing Long-Horizon LLM Agents: State-Transfer Auditing and Controls in the Agent Harness
Abstract
Long-horizon LLM agents across codebases, web browsers, and enterprise infrastructure rely on an execution harness to move state between the working context, session history, persistent memory, and external environment. While conventional execution traces log model prompts and tool calls, critical security and reliability failures occur during state transfers: a transfer can admit unchecked content (indirect prompt injections, unverified memory writes), rewrite state lossily (context compaction dropping user constraints, memory consolidation stripping source authority), or restore state incompletely (workspace rollbacks leaving aborted KV state active on the inference server). Because current traces omit what crosses these boundaries, failure attribution and runtime monitors fail on multi-step trajectories. We present a state-transfer audit architecture for the agent harness. At each transfer boundary, we define an audit point specifying the minimal hash-chained record the harness emits, separating low-overhead deterministic checks from model-based semantic checks and binding internal context, memory, and inference-server cache state to external actions. We show that the same transfer records required for causal failure attribution supply the durable state needed by runtime security controls, including least-privilege capabilities, replay-resistant authorization outside the prompt, information flow control, obligation monitors, and transactional recovery across multi-agent and infrastructure pipelines. Finally, we analyze multimodal GUI adaptations and implement and evaluate a reference harness middleware across 240 multi-step fault-injection trajectories, showing that transfer records localize root causes and catch cross-transfer violations missed by lifecycle and tool-only logs at microsecond deterministic overhead.
Introduction
LLM agents now resolve repository issues, operate websites and desktop applications, and automate IT operations, often over many steps. Each tool and data source they read widens the attack surface [1]: AIOps agents, for example, can be steered through manipulated telemetry [2]. Task completion rates do not show whether an agent behaved safely without unauthorized side effects [3]. An operator must also establish, after the fact, why an action was taken, which input caused it, and whether a recovery restored a safe state. Answering these questions depends on what the code around the model records.
We use the term harness for all code that executes between model calls: it parses tool calls, runs them, formats observations, assembles the prompt, compacts history, and reads and writes memory. The harness shapes both cost and accuracy: holding the model fixed, coding harnesses differed by up to 40× in tokens per solved task [4], and model rankings reversed across harnesses [5]. It is also where audit evidence is produced or lost.
Current traces support attribution poorly. On the Who&When benchmark of multi-agent failure logs, the best of three initial methods identified the failure-responsible step in only 14.2% of cases [6], and long-context models performed poorly at locating errors in the human-annotated traces of TRAIL [7]. The traces themselves omit key fields. When existing agent trajectories were replayed through a temporal-logic monitor, the logs rarely included approvals and never included timestamps, reducing history-dependent policies to flagging risky action types [8]. Existing observability schemas trace events across the agent lifecycle § 9.1, without tying each record to a failure it detects.
This paper presents a state-transfer audit architecture across four harness stores:
a state-transfer failure model across coding and GUI harnesses covering three failure modes: admitting unchecked content, lossy rewriting, and incomplete restoration (Sections II–III, Table I);
transfer-level audit points specifying emitted hash-chained record fields, deterministic versus model-based checks, and enforced controls across all eight transfers (Section IV, Table II);
how transfer records directly support causal failure attribution and runtime obligation monitoring (§ 5);
how the same records supply durable runtime state for least-privilege capabilities, replay-resistant authorization, information flow control, tamper-evident accountability, and recovery across multi-agent and infrastructure pipelines (§ 6, Table III);
multimodal GUI adaptations (§ 7), a wrapper-based implementation architecture (§ 8), and an empirical evaluation of wrapper overhead, violation de-
| Transfer | Failure (evidence) | What to record | Check | Control supported |
| Observation | Injected instructions followed [10, 29] | Source, integrity/confidentiality labels, and content hash of each segment; producing tool call; screenshot hash and parsed regions | Det. (label propagation) | Marking [43]; control-flow isolation [36, 44]; IFC [37, 38] |
| Context assembly | 84–96% of security rules in instruction files lacked a control [11] | Hashes of rule files, tool schemas, and recalled memories; declared rule-to-control map; memory admission decisions | Det. (hashes; declared map; policy over stored labels) | Enforced rules; policy-gated memory recall [12] |
| Compaction | Constraints [18] and identifiers dropped | Identifiers and pinned constraints kept or dropped per pass; pointer and hash of full transcript | IDs: Det. match. Constraints: Model check + Det. rule | Pinned constraints [18]; masking instead of rewriting [19] |
| Memory write | Unverified or injected content stored [13, 14] | Source segment IDs, hashes, and labels; write-time authority label; verification result; writer identity | Provenance gate: Det. Authority label: Model. Truth check: Det. with test oracle, else open | Provenance-gated or test-verified writes [16] |
| Consolidation | Authority collapse [20]; stale entries [21] | Source segment IDs and hashes; authority label; validity status; superseded or revoked entry IDs | Lineage, revocation: Det. Authority label: Model | Authority labels [20]; lineage-gated retrieval [39] |
| Action | Unauthorized side effects [3] | Tool, arguments, input lineage and labels; approval ID, capability/lease, execution count, timestamp; GUI clicked element | Det. (policy, capability, IFC); Model lookahead | Capabilities and leases [41, 45]; IFC [36, 38]; staged effects [23] |
| Rollback | Retained KV state changes decisions [25] | Environment, transcript, and memory snapshot IDs bound to inference-server cache/session IDs (or flag when server cache is opaque); committed effects | Det. (ID match) | Cache snapshot restore or rebuild [25]; checkpoints [22] |
| Delegation | Faults propagate with depth [26] | Task, input lineage and labels, and capabilities passed to sub-agent; returned result, hashes, and labels | Det. (subset capability; label propagation) | Per-agent capabilities [45]; leases across delegation [41]; isolation [42] |
Table II. Audit points at state transfers. “Det.” marks checks that need no model call; “Model” marks checks that need one. Evidence and controls are discussed in Sections III–VI.
| Control | Corresponding fields | Examples |
| Least privilege | Action: tool, arguments, capability, approval; delegation capabilities | [53, 54, 55] |
| Durable authorization | Action, compaction, rollback: approval ID, confirmation, execution count; pinned constraints | [56, 57] |
| Information flow control | Observation, memory, consolidation, delegation: integrity/confidentiality labels, lineage | [36, 37, 38] |
| Monitors and guardrails | Action, compaction: timestamp, approval; active obligations, constraints | [8, 35, 52] |
| Accountability | Action (all transfers): hash-chained records; responsible principal | [34, 58] |
| Failure attribution | Step and delegation lineage; intermediate files and stage outputs | [17, 46, 59] |
| Recovery | Rollback: snapshot, cache, session ID | [22, 25, 60] |
Table III. Security controls and corresponding audit fields (Table II).
tection, and attribution ablations against standard tracing schemas (§ 9, Table IV–Table V).
| Transfer wrapper | Median (s) | p99 (s) | Mean size (B) |
| Observation | 16.0 | 58.8 | 421 |
| Context assembly | 12.5 | 23.9 | 499 |
| Compaction | 81.6 | 150.2 | 530 |
| Memory write | 15.2 | 39.0 | 504 |
| Consolidation | 15.3 | 75.1 | 520 |
| Action | 22.1 | 58.9 | 711 |
| Rollback | 14.9 | 52.5 | 479 |
| Delegation | 15.3 | 23.3 | 530 |
Table IV. Deterministic wrapper latency and serialized record size across 20,000 invocations (2,500 per transfer).
| Trace schema / ablation | Recall | FPR | F1 | Step Attr. |
| OTel-GenAI lifecycle spans | 23.3% | 35.0% | 29.5% | 10.8% |
| Tool-Log (tool calls only) | 16.7% | 0.0% | 28.6% | 16.7% |
| Transfer-Audit (Det. only) | 91.7% | 0.0% | 95.7% | 91.7% |
| Transfer-Audit (Full schema) | 98.3% | 0.0% | 99.2% | 98.3% |
| w/o segment lineage (iii–iv) | — | — | — | 48.3% |
| w/o auth/cache bindings (ii, vi) | — | — | — | 65.0% |
| w/o rewrite diffs (v) | — | — | — | 83.3% |
Table V. Multi-transfer violation detection and root-cause step attribution across 240 trajectories (120 benign, 120 fault-injected).
State and Transfers in an Agent Harness
An agent reads and writes state across four stores (Figure 1). The working context is the prompt and its KV cache on the inference server: instructions, rule files, tool schemas, retrieved memories, compacted history, and recent observations. Session history is the full transcript of one run kept outside the prompt. The environment is whatever the agent acts on: files and processes for coding agents, pages and browser sessions for web agents, and windows and application state for desktop agents. Persistent memory holds episodic, semantic, and procedural records across runs [9]. Because the agent can modify the environment and persistent memory and a rollback truncates session history, the harness must keep its own control state—active approvals and the append-only audit log—in a separate store the agent cannot modify.

Figure 1. State transfers in a single-agent harness (Delegation across sub-agents is omitted). Boxes show the four state stores the agent reads and writes; the harness keeps its own control and audit logs outside them. Bold arrows are primary transfers and thin arrows are context-assembly and history reads (page back reloads masked turns). Marker shape indicates how a transfer fails: (1) instructions injected through observations, (2) user constraints dropped during compaction, (3) unverified content admitted at memory write (circle) or source provenance lost during consolidation (diamond), and (4) KV state left on the inference server after rollback (which must also truncate aborted session-history turns and revert uncommitted memory writes). Green annotations list controls with published support; each transfer is an audit point (Table II).
The harness moves state across these stores. Observations bring environment state into the context, and context assembly loads workspace rule files, tool schemas, and retrieved memories. Compaction moves older turns to session history and leaves a condensed summary or placeholder (which page back can later reload on demand); memory writes and consolidation extract and merge entries from the working context or session history across runs. Actions change the environment, and rollback restores prior state across the environment, working context, session history, persistent memory, and inference-server KV cache. Multi-agent harnesses add delegation, which passes a task and state slice to a sub-agent with its own context. Each transfer gives the harness a concrete boundary to record and check what crosses.
A transfer can fail in three ways. It can admit unchecked content: injected tool output, unverified memory writes, or unvetted recall. It can rewrite content lossily: a summary that omits a user constraint, consolidation that discards provenance. It can restore state incompletely: the environment is restored but the KV cache, session history, or uncommitted memory writes are not. These modes correspond to three properties an auditor needs to establish: where content came from, whether it survived a rewrite, and whether a recovery was complete.
How Transfers Fail
Admitting Unchecked Content
Observations carry text that the model may treat as instructions. On InjecAgent, a ReAct-prompted agent on a frontier model followed injected instructions in about a quarter of test cases [10]. Components such as memory, retrieval, web access, and API calls make agents easier to attack than isolated models, and illustrative attacks that require no knowledge of machine learning succeeded against popular open-source and commercial agents [1]. On the APEX-Harm workspace benchmark, agents often produced a correct deliverable yet also took an unauthorized action, showing completion does not imply safety [3].
Context assembly and memory writes extend the reach of admitted content across turns and sessions. During context assembly, workspace rule files are loaded as advisory text rather than enforced invariants: across rule files studied in [11], 84–96% of extracted security rules lacked a matching harness control, and recalling persistent memories without an admission policy can re-admit conflicting or out-of-scope entries [12]. When writing to memory, an attacker with access to a shared RAG or memory store can inject poisoned entries keyed to a trigger phrase in the user prompt without hurting normal accuracy [13]. Even without direct access to the store, a web agent that read one manipulated product page saved injected instructions to memory and later recalled them on other websites, bypassing permission checks [14]. In coding and embodied tasks, test feedback and self-verification check functional correctness [15], [16] and can gate memory writes. Because code or actions that pass tests can still contain vulnerabilities or unauthorized side effects [3], [17], passing a test suite does not prove that an entry is safe or came from a trusted source, so test checks must be paired with source labels; web and office tasks rarely have tests.
Rewriting Content Lossily
Compaction rewrites the working context when it grows. On the ConPAcT suite, compactors kept on average only 17% of user constraints and usually performed worse than not compacting at all, whereas extracting and pinning constraints in a separate pass preserved most of them [18]. Replacing older observations with placeholders, which shortens the context without rewriting it, matched the solve rate of LLM summarization at lower cost on SWE-bench Verified [19]. This suggests that rewriting, rather than shortening, causes constraint loss.
Consolidation rewrites memory. In authority collapse, consolidation keeps a claim but drops the source constraints on its use, so a memory conveys more authority than its source warranted. This occurred in 48 of 49 tested memory-system and model combinations; storing an authority label with each memory eliminated the resulting unauthorized actions [20]. Stale entries cause a related failure: when facts changed over time, append-only memory stores performed worse than having no memory at all once earlier facts reversed, whereas revoking contradicted entries maintained accuracy [21].
Restoring State Incompletely
Removing turns from the prompt undoes neither a file write nor an outbound request. Taking system checkpoints after turns that modify files or processes restored local state where rewinding the chat transcript failed [22], and holding external actions in a staging buffer for validation before execution reduced irreversible mistakes [23]. Complete rollback must also clean up internal stores and the inference server: aborted turns in the working context and session history must be removed or marked so they cannot be reloaded later, and uncommitted writes to persistent memory must be undone [24]. On the inference server, across seven open-weight model families,
KV state retained after an aborted branch changed a protected decision in 25 of 63 audited cases, although the discarded tokens were absent from the request [25]. Rebuilding the cache resolved every failure, and restoring a per-turn KV cache snapshot fixed the leak without flushing the entire cache. The failure requires a serving session that keeps KV state across the abort, so we expect it to concentrate in stateful multi-turn sessions rather than in prefix caches keyed on exact tokens.
Cross-Transfer Fault Propagation
Faults introduced at one transfer are carried by later ones. A large observation fills the context and triggers compaction early, risking constraint loss on each pass [18]. Extracting memories from a summary then turns paraphrase errors into stored facts. In controlled failure-injection probes, fault propagation increased with the depth of multi-agent pipelines, and blind retries repeated the same underlying errors rather than fixing them [26]. Unified security benchmarks such as Agent Security Bench (ASB) evaluate mixed attacks alongside prompt injection and memory poisoning in text-tool settings [27], and observation-to-memory-to-action poisoning has been measured in web agents [14]; however, end-to-end chains combining prompt injection, lossy compaction, authority collapse, and incomplete KV-cache rollback remain to be evaluated in a unified benchmark. Most measurements come from coding agents and text tools. Table I compares transfer failures between coding and GUI agents; Section VII discusses web and desktop settings.
| Transfer | Coding and text-tool agents | Web and desktop agents |
| Observation | Injected instructions followed [10]; attacks and defenses compared in shared environments [27, 28] | Pop-ups and static injections succeed [29, 30] |
| Compaction | Constraint loss measured; masking compared with summaries [18, 19] | Screenshot history affects success [31]; constraint loss unmeasured |
| Memory write | Functional test gates [16] (do not check security) | Poisoning through observation alone [14]; no automated test check |
| Consolidation | Authority collapse measured across models; agent type not varied [20] | Across memory systems |
| Rollback | Retained KV state measured [25]; checkpoints [22] | Actions often irreversible; lookahead instead [32] |
Table 1. Transfer failure surfaces across coding/text-tool and GUI agents.
Audit Points
An audit point specifies, for one transfer, the record the harness emits and the check it enables. Table II lists one per transfer, shaped by a trust model and three principles.
Threat and trust model. We assume that an adversary can control content reaching the agent through observations (web pages, repository files, tool output, screenshots), and through what the agent writes to memory. The adversary cannot modify the harness or the harness-owned store that holds audit records; such stores, based on hash chaining, have been built for agent actions (§ 6). Because the model may misreport what it read or why it acted, harness code emits each record at the transfer boundary and appends it to a store the agent cannot modify. Benign failures, such as constraint loss during compaction or stale memory, require the same records, so the audit points serve fault diagnosis as well as security. A compromised harness or inference server, and an operator who can rewrite the store, are out of scope. Under this model, an attacker can still plant fake provenance strings in observations, flood the harness with events, or cause records to be skipped (by steering the agent onto an unlogged side channel, tricking a model-based extractor into omitting a field, or overflowing a log buffer). Write isolation blocks direct agent edits, signed hash-chained logs detect tampering and deletions [33, 34, 35], and attaching source labels at tool return counters fake provenance; unlogged side channels and flooding remain open. To protect sensitive data in audit records, fixed identifiers (segment IDs, rule hashes, cache IDs) can be stored as keyed hashes (HMACs), while full text needed for review or policy checks (dropped constraints, tool arguments, raw transcripts) is kept in an access-controlled or encrypted store. Session-history turns whose content flows into persistent memory must be kept for the life of that memory so cross-session links resolve.
Records follow content across transfers. Most entries record a label together with the content: its source and trust level at observation, its lineage through compaction and consolidation, and the authority under which an action was taken. This is information flow control applied to the harness. Each segment carries an integrity label (source trust or authority), checked against injection and authority collapse, and a confidentiality label (data sensitivity), checked against leakage. Recent systems enforce such labels in the harness: FIDES propagates confidentiality and integrity labels across messages, tool arguments, and outputs and hides sensitive tool outputs behind variables [36]; RTBAS uses model-based dependency screeners and prevented all targeted attacks on AgentDojo with a small utility loss [37]; FLOWSEAL enforces confidentiality with a tool-level interceptor grounded in provenance and a label lattice [38]; and column-lineage gating removed measured leakage in shared analytical memory [39]. Labels must survive every rewrite: if compaction or consolidation drops a provenance label, later checks fail and authority collapses [20]. Conversely, if compaction merges many turns into one summary that takes the lowest trust label of any input turn, a single untrusted observation marks the whole summary as untrusted. Harnesses can avoid this by summarizing trusted and untrusted turns separately, tracking provenance per claim, masking old observations instead of summarizing [19], or keeping untrusted outputs in referenced variables [36].
Deterministic checks first. Most audit points can be checked without a model call: comparing hashes of loaded rule files, string-matching identifiers before and after compaction, checking that an action’s capability is a subset of the delegating agent’s, and matching snapshot and cache identifiers after rollback. Some cannot. A summarizer may paraphrase user constraints; preserving them requires running a dedicated extractor alongside compaction, which adds a model call [18]. Authority labels are likewise predicted at write time [20]. This asymmetry determines both cost and attack surface: deterministic checks add only logging and comparison, whereas model-based extractors and labelers process untrusted context and can be targeted by indirect prompt injection. A middle ground uses the model only to extract structured attributes and leaves the allow/deny decision to deterministic rules, as in MetaPermit [40] and IntentCap [41]. For compaction, the harness can extract and pin user constraints from trusted user turns before untrusted observations enter the context, so an injected observation cannot alter the baseline list. After compaction, a model checks whether each pinned constraint holds in the summary, and a deterministic rule blocks or repairs the summary if any is missing. Recording the checker’s prompt and output lets an auditor inspect the model check afterward, whereas preventing prompt injection against the checker at run time requires deterministic IFC planners [36] or isolated execution [42].
Record integrity and completeness. A provenance field is useful only if an adversary cannot forge it. In the replay study, a single planted line defeated a naive provenance check on most of the runs it would otherwise have flagged, and binding tool returns to issued calls—rather than trusting provenance text inside tool output—closed this evasion [8]. Completeness matters as well: in lineage-gated memory, blocking measured leakage required recording 75–90% of lineage [39].
A common record format. The rows of Table II share a structure, which suggests one hash-chained record type emitted at every transfer. Each record contains (i) the transfer type, step, session, previous-record hash, and a harness timestamp; (ii) the acting component (harness, model, sub-agent, or user), responsible principal, and active authorization state (capability or lease, user approval, approval ID, and how many times that approval has been executed); (iii) identifiers, content hashes, and integrity/confidentiality labels of the input segments; (iv) identifiers, content hashes, and assigned labels of the output segments, together with pointers and hashes for full transcripts or model-check prompts and outputs kept in the backing store; (v) the checks run and their results (each marked deterministic or model-based), active obligations or pinned user constraints, and transfer-specific metadata (such as the rule-to-control map, revoked entry IDs, or intermediate file and stage snapshots); and (vi) for actions and rollbacks, the environment, transcript, and memory snapshot IDs bound to the inference-server cache and session IDs (or a flag when the server does not expose cache state). Fields (iii) and (iv) link records into a verified lineage graph across transfers [46], while fields (i), (ii), and (v) track active obligations and supply the timestamps and approvals missing from replayed corpora [8]. Records can be emitted as spans in existing tracing infrastructure.
Cost of recording. Most fields are identifiers, hashes, and labels; full content resides in the backing store, so a record points to it with a payload hash instead of copying it. Deterministic logging adds little overhead, whereas content scanning and model-based checks dominate latency. Most turns produce no recovery-relevant state [22]. Derivation checks added 13.8 s worst-case overhead [39] and hash-chained action logs added about 48 s median latency and 512 bytes per event [34]. Pre-execution scanning added 8.3 ms median latency [35], and constraint or authority extraction adds a model call [18, 20]. As an illustration only, at 512 bytes per event a run with a thousand recorded transfers produces about half a megabyte of audit records (and a million such runs per day about half a terabyte), plus backing-store retention for cross-session lineage slices. Screenshots are the main exception, since auditing requires archiving originals (Section VII).
Worked trace. Consider a five-step failure chain: (1) the agent reads a web page with an embedded instruction; (2) the large observation triggers compaction, which drops a user constraint; (3) content from the page is written to memory [14]; (4) a later session retrieves that entry via context assembly and takes a prohibited action; and (5) the harness rolls back the workspace while the inference server retains the session’s KV state. With the records in Table II, an auditor can trace the prohibited action’s lease and input lineage through context assembly and the memory write back to the untrusted observation, see from the pinned constraint set that compaction dropped a rule, and see from the rollback record that the workspace snapshot was not bound to a fresh cache identifier.
Together, these transfer records reconstruct the causal chain from observation to action and flag both the dropped constraint and the unreset server cache, which Section IX evaluates under field-level attribution ablations.
Observability in Practice
Trace analysis and failure attribution. Failure attribution asks which agent and which step caused a failure [6]. Modeling dependencies among trajectory events helps: DeFA traces failures backward through a dependency graph and achieved the highest agent- and step-level attribution accuracy among evaluated methods on Who&When [46]. CEG-Agent links execution events, errors, and failure outcomes in typed causal graphs [47]. Both infer which event affected later steps; lineage records would supply the data-flow links directly. Failures that raise no error are harder to localize. For vulnerable patches that passed functional checks, the origin rarely coincided with the edit; judges agreed more on origin type than exact turn, and least when traces kept only the final file [17]. Traces therefore need intermediate state as well as final outcomes. In infrastructure operations, benchmarks now grade whether an agent’s diagnostic reasoning is grounded in evidence as well as whether it localizes the fault [48]. In ITBench, agents resolved few site reliability, compliance, or financial scenarios [49].
Runtime monitors and guardrails. Guardrails check content as it crosses a transfer boundary. Programmable rails, designed for conversational systems, control model output at run time independently of the underlying model [50]. Monitors based on temporal logic can express multi-step, data-dependent policies, but their value depends on the trace. On replayed trajectories, generic obligations caught most attack chains but also flagged 29.3% of benign runs because the traces lacked approvals and timestamps [8]. A monitor checking a fixed set of rules catches a high share of attacks only when failures cluster into a few recurring patterns, so the same rules covered many attacks on some models and few on others [51]. Forbidden actions are not the only risk: on a coding safety benchmark, unfulfilled obligations outnumbered explicit forbidden actions, and off-the-shelf models achieved at most 49% recall on coding and terminal trajectories [52]. Detecting omissions therefore requires recording active obligations and preserving constraints across compaction.
Shared infrastructure. Enterprise agents may share a memory store and an inference server. When multiple agents share an analytical memory store, restricting retrieval by which database columns an entry was derived from blocked leakage of sensitive columns and helped document EU AI Act compliance [39]. Because rollback correctness spans the harness and the inference server [25], binding snapshot to cache identifiers is a cross-layer record that neither layer can produce alone.
Security Controls Built on Audit Records
The records in Table II support runtime enforcement as well as post-hoc diagnosis: proposed agent controls rely at run time on transfer state that these fields are designed to capture. Table III maps each control to the corresponding fields.
Authorization is state that crosses transfers. Least-privilege enforcement checks each tool call against an explicit policy. Progent uses an LLM to draft and update symbolic rules over tool names and arguments, checks calls deterministically, and uses an SMT solver so privilege expansions require approval [53]. AC4A organizes application resources into hierarchies and scopes agent permissions to specific APIs and web page elements [54]. SEAgent enforces mandatory access control over an agent–tool information flow graph and blocked privilege escalation, including a multi-agent confused-deputy variant [55]. Other designs check each call against typed per-agent capabilities, short-lived leases derived from user intent, or authorization contracts compiled before untrusted execution [41, 45, 61]. At the planner and runtime boundary, FIDES tracks confidentiality and integrity labels across messages, tool arguments, and outputs to check policies before tool calls [36], and IsolateGPT runs untrusted applications in isolated spokes mediated by a central permission hub [42]. Framework defaults lag behind: an audit of three agent frameworks found that all gate tool exposure, but none check per-call argument values by default [62].
Authorization must also be recorded as durable state outside the prompt rather than inferred from the transcript. When a user revises part of an instruction, tracking which permissions depend on which part of the prompt lets the harness revoke only the affected permissions, improving both action safety and task success with three LLMs on two tasks [57]; compaction must still preserve those instruction revisions so the agent and monitors see the updated constraints. When agents replan, retry, delegate, or resume after a crash, a single user approval can be executed several times under freshly issued single-use tokens; preventing this required tracking each approval’s execution count in persistent state at the issuer [56]. Because rollbacks and retries truncate or replay the transcript, authorization instances and execution counts belong with the action and rollback records outside the prompt.
Tamper-evident records. Section IV assumed a store that the agent cannot alter, and such stores now exist for agent actions. The Agent Flight Recorder serializes each action as a structured event, hash-chains events and batches them into Merkle trees, and can anchor epoch roots on a public ledger. On synthetic workloads it detected edit, delete, reorder, and fork tampering, and structured forensic queries were more precise than text search over unstructured logs on guardrail and delegation lookups [34]. AEGIS interposes on the tool-execution path, holds high-risk calls for human approval, and records each decision in a signed, hash-chained trail [35]. Both systems center on tool calls and their provenance. As described, neither records compaction, consolidation, nor the state of the inference server, which Table II adds. Accountability also requires linking an agent to a responsible principal. One national agent-identity system links each agent to a verified legal principal across two separated public-agency stores, requiring separate legal compulsion of both to re-identify an owner [58].
Cascading faults in multi-agent pipelines. Faults in multi-agent pipelines often raise no exception. MAS-FIRE injects faults through prompt modification, response rewriting, and message routing; across its benchmarks, stronger foundation models were not uniformly more fault-tolerant [63]. Silent tool failures are the hardest case: in ToolMaze, recovery dropped most when tools returned plausible but corrupted data without an error code, because agents trusted the output [64]. Compromise also spreads between agents. INFA-Guard distinguishes compromised benign agents from originally malicious ones, traces how an attack spread across agents, and reduced attack success [65]. We argue that each of these analyses needs to know which agent produced which message and which tool output a decision consumed; these are the lineage fields of the observation and delegation records. Instrumentation for this is appearing: llmmas-otel combines OpenTelemetry step tracing with fault injection at inter-agent messages, tool calls, and model invocations [66]. Recovery must be recorded as well. AgentRewind keeps aligned checkpoints of the agent context and a controlled environment, and resumes with information from earlier attempts [60]. Because blind retries repeated the same underlying errors in failure-injection probes [26], we suggest that retry policies consult the audit record to choose a checkpoint rather than replaying inputs.
Agents that operate infrastructure. Agents that manage IT and data infrastructure raise the stakes of each transfer. AIOpsLab deploys microservice environments, injects faults, exports telemetry, and evaluates agents across the incident lifecycle [67]. Telemetry is an observation channel that an adversary can write to. Crafted requests planted misleading telemetry that steered AIOps agents into compromising their own clusters; structure-aware telemetry sanitization blocked these attacks without hurting normal performance [2]. For diagnosis, splitting root-cause analysis into four logged stages made it possible to pinpoint which stage failed and replay the workflow from that stage with a fix [59]. A zero-trust harness for cloud engineering combines identity, authorization, policy-scoped capabilities, and isolation; in evaluation, each run ended in either a verified deployment or a logged failure after bounded retries [68]. Because telemetry streams and long runs make full-content logging expensive at scale, records should store identifiers, hashes, and labels with pointers (Section IV).
Multimodal Agents: What Changes
Evidence for web and desktop agents is thinner than for coding agents, and three differences affect the audit points.
Observations are images. Screenshots carry instructions that a text filter does not see. Adversarial pop-ups, which human users would recognize and ignore, led vision-language agents in OSWorld and VisualWebArena to click them in most trials, reducing task success. Simple defenses, such as instructing the agent to ignore pop-ups, were ineffective [29]. Computer-use agents also complied with many deliberate misuse requests and were relatively vulnerable to static prompt injection on OS-Harm [30]. RιοSWorld separates user-originated from environmental risks across web, email, office, and operating-system tasks [69]. For audit, the observation record logs the screenshot hash and candidate regions detected by a screen parser [70], while the subsequent action record logs the clicked element or coordinates with a link back to that observation; dependency-based attribution has been applied to such image and video trajectories [46]. A pixel-only parser helps locate what was clicked after the fact, but assigning source trust labels at run time requires matching coordinates to DOM or OS window metadata, or treating the screen as untrusted.
Screenshots cannot be re-fetched from the environment. Observation masking works for command output because the harness can retrieve the original later. Screenshots of a changing interface cannot be re-fetched. GUI agents therefore keep text summaries of earlier steps [71], compress older images [72], or keep all frames on disk and restore only a budgeted subset to the prompt, which improved success over summary-only memory on OSWorld-Verified [31]. Summaries, image pruning, and unrestored frames still lose context: checking whether identifiers survive screenshot compaction requires OCR or parser tokens, and constraint retention under visual compaction remains unmeasured. Archiving full screenshots across a thousand transfers also takes hundreds of megabytes to gigabytes rather than about half a megabyte of text pointers, and images cannot be replaced with keyed hashes; storing cropped regions, encoding frame deltas, or redacting visual personal data before archival cuts storage and privacy risk.
Actions often cannot be undone. On live websites, submitted forms and sent messages cannot be rolled back, so harnesses evaluate candidate actions before committing them, for example by simulating interactions with a learned world model [32]. When a harness runs such pre-commit lookahead, the action record’s checks field logs the candidate action, predicted outcome, and policy decision as a model-based check. Because web tasks lack a test oracle to gate memory writes, poisoning through observation alone [14] makes write-time lineage critical.
Implementing Audit Points
Implementing audit points requires no model changes: the harness routes each transfer through a wrapper that logs the hash-chained record and runs boundary checks before applying the state change. Our Python reference middleware implements all eight wrappers directly; for existing harnesses, adoption can proceed in four incremental steps ordered by overhead and risk coverage.
Step 1: actions and authorization. Interpose on the tool-execution path, as pre-execution firewalls do [35], and record each call with its arguments, the capability or approval that authorized it, and a harness timestamp. Keep authorization instances and their execution counts in a durable store outside the prompt [56], supplying the approvals and timestamps missing from replayed logs [8] for least-privilege checks [53].
Step 2: observation labels and lineage. Assign each segment entering the prompt a source, an integrity label, and a confidentiality label, and carry segment identifiers through memory writes. This supports information flow control [37, 38], and we expect it to let an auditor trace the observation-to-memory-to-action chain measured in [14].
Step 3: rewrites. At each compaction and consolidation, record identifiers and the constraint list before and after, the lineage of each output entry, and its authority label. Identifier matching is deterministic; constraint and authority checks need a model call whose prompt and output are logged (Section IV).
Step 4: recovery and the inference server. Bind each environment, transcript, and memory snapshot to the cache and session identifiers on the inference server, and record which side effects were already committed. Self-hosted servers can expose cache identifiers directly [25]; when a commercial model API hides internal KV-cache state, the harness logs a flag in field (vi) and falls back on rollback to re-sending the prompt without server state or with a cache-busting prefix.
Accountability limits. Audit records support attributing a technical failure to a state transfer, but technical attribution is distinct from allocating legal or organizational responsibility. In a causal-model analysis of human–agent teams, once combined autonomy passes a threshold and interactions form a feedback loop, no attribution rule satisfies four basic accountability requirements at once; audits and oversight cannot restore them without restricting autonomy [77].
Evaluation
Reference middleware and setup. Because static failure corpora such as Who&When and TRAIL [6, 7] omit internal transfer state, we implemented a Python reference middleware interposing on all eight harness transfers with SHA-256 hash chaining, product-lattice integrity/confidentiality labels, durable approval execution counters, and snapshot-to-cache bindings. We evaluate deterministic wrapper overhead across 20,000 invocations (2,500 per transfer) and evaluate violation detection and root-cause attribution across 240 multi-step trajectories: 120 benign runs (exercising approved privileged actions, compactions, memory consolidations, delegations, and clean rollbacks) and 120 fault-injected runs [75] spanning six families (20 each): indirect observation injection with spoofed in-band provenance, syntactic and paraphrased compaction constraint drops, memory consolidation authority collapse, approval replay across rollback, incomplete rollback with unreset server KV state, and sub-agent capability/taint violations.
Wrapper latency and record size. Table IV reports per-transfer deterministic wrapper latency and serialized record size. Seven transfers complete in 12.5–22.1 s median latency (23.3–75.1 s p99), while compaction adds 81.6 s median latency (150.2 s p99) due to syntactic identifier diffing across turns. Records average 524 bytes (421–711 bytes), matching the ≈0.5 MB per thousand transfers estimate in Section IV.
Violation detection and attribution ablations. Following replay verification [8] and dependency attribution [46], Table V compares an OpenTelemetry GenAI lifecycle span baseline (OTel-GenAI), a tool-call-only firewall log (Tool-Log), and our transfer-audit middleware. Lacking durable approval records, OTel-GenAI over-flags benign privileged actions (35.0% FPR) while missing spoofed provenance and internal rewrites (23.3% recall); Tool-Log avoids false positives (0.0% FPR) but misses cross-transfer memory taint, replayed approvals after rollback, and stale KV state (16.7% recall). Deterministic transfer checks alone reach 91.7% recall (95.7% F1, missing only paraphrased constraint drops that drop no syntactic identifiers), and full transfer records reach 98.3% recall (99.2% F1) at 0.0% FPR. On the 120 faulty runs, backward traversal over emitted records raises exact root-cause step attribution from 10.8–16.7% to 98.3%; ablating segment lineage (fields iii–iv), auth/cache bindings (ii, vi), or rewrite diffs (v) drops step accuracy to 48.3%, 65.0%, and 83.3%.
Comparison with tracing standards. Current tracing schemas cover only part of the common record format in Section IV. OpenTelemetry GenAI spans, llmmas–otel [66], TRAIL [7], and AgentOps tools [76] record timestamps, component roles, and tool-call IDs, which supply the step metadata in fields (i) and (ii). They omit source trust and sensitivity labels in fields (iii) and (iv), compaction constraint diffs in field (v), memory consolidation lineage, authorization execution counts, and the snapshot-to-cache bindings in field (vi).
Evaluate model–harness pairs. The harness changes both cost and model rankings [4, 5]; on SWE-bench Verified, changing the harness around the same model varied solve rates by more than the gap across the top thirty leaderboard entries (though leaderboard submissions do not isolate causal effects) [73]. Results thus characterize a model–harness pair, so reports should specify tool schemas, truncation, compaction, memory policies, and emitted audit records.
Metrics tied to audit points. Each transfer suggests a metric:
observation: attack success under indirect or visual injection [28, 29];
compaction: retention of user constraints [18] and identifiers after compaction;
memory: rate of unverified, unauthorized, or poisoned writes and their downstream effects [14, 20];
action: unauthorized side effects alongside task success, since the two are not exclusive [3], and unfulfilled obligations [52];
rollback: decision shifts on rollback without cache reset [25];
reliability: consistency across repeated trials (pass) [74].
Testbeds. Existing environments already inject faults and export traces, and can host these measurements. AIOpsLab injects faults into microservice deployments and exports their telemetry [67], and MAS-FIRE injects faults into the messages and prompts of multi-agent systems [63]. ToolMaze perturbs tool outputs with explicit and implicit, transient and permanent failures [64], while llmmas-otel aligns injected faults with distributed traces [66]. Because these testbeds perturb observations, actions, and delegation, covering all transfers requires adding fault injectors for compaction, consolidation, and KV-cache rollback, or pairing them with ConPACT and authority-collapse suites [18, 20, 25]. Known injection points give ground truth for attribution ablations.
Related Work
Agent observability tools trace events across the execution lifecycle [76], while threat and failure studies analyze attack surfaces [1], multi-agent coordination breakdowns [78], and post-hoc step localization [6, 7]. Replaying trajectories through temporal-logic monitors shows how missing approvals and timestamps limit runtime verification [8]. Our audit records build on tamper-evident logging [33] and complement recent agent security controls that interpose mainly on tool execution (§ 6). Rather than logging events solely by lifecycle stage or tool call, we instrument the harness at state transfers—including compaction, memory consolidation, and rollback—so each emitted record directly supports a deterministic or model-based check and a runtime control.
Limitations and Open Problems
Each row of Table II pairs a transfer failure with a check and control; while our reference middleware measures deterministic overhead, detection, and attribution on controlled fault-injection trajectories, live LLM workloads across production infrastructure and multimodal web and desktop interfaces require broader end-to-end evaluation.
Several problems remain open. Checking constraint retention needs a model call whose cost and recall on real failures are unmeasured. Web and office tasks lack a test oracle for memory writes, leaving open whether replay admission or reversible writes [24] work better. Write-time labelers can be attacked, commercial APIs that hide server KV state prevent direct cache-rollback checks, and audit records hold user data that require explicit retention and access policies.
Conclusion
Many failures in long-horizon agents occur when the harness transfers state. Observations and memory writes admit injected content, compaction and consolidation drop constraints and provenance, and rollbacks leave KV state on the inference server. Treating each transfer as an audit point specifies what the harness should record, which checks are deterministic, and which controls those records support. The same records serve execution-trace analysis, access control, information flow control, guardrails, and recovery; authorization in particular belongs in durable state outside the prompt. Evaluating these controls on live production deployments and extending them to multimodal web and desktop agents are the next steps.
References
- [1]A. Li, Y. Zhou, V. C. Raghuram, T. Goldstein, and M. Goldblum, “Commercial LLM Agents Are Already Vulnerable to Simple Yet Dangerous Attacks,” arXiv preprint arXiv:2502.08586, 2025.arxiv.org/abs/2502.08586
- [2]D. Pasquini, E. M. Kornaropoulos, G. Ateniese, O. Akgul, A. Theocharis, and P. Efstathopoulos, “When AIOps Become ‘AI Oops’: Subverting LLM-driven IT Operations via Telemetry Manipulation,” arXiv preprint arXiv:2508.06394, 2025.arxiv.org/abs/2508.06394
- [3]Z. Yang, A. Bibi, G. Li, B. Ghanem, and C. Hinojosa, “APEX-Harm: Evaluating Agent Safety in Shared Professional Workspaces,” arXiv preprint arXiv:2610.13623, 2026.arxiv.org/abs/2610.13623
- [4]N. Vats and O. Golev, “The Scaffold Effect in Coding Agents: Harness Choice as a Hidden Variable in Coding-Agent Evaluation,” arXiv preprint arXiv:2607.22585, 2026.arxiv.org/abs/2607.22585
- [5]Y. Li, Y. Zhou, Y. L. Teng, F. Yang, Y. Deng, Z. Lyu, X. Dong, F. Chen, and B. An, “Finding the Right Fit: Model-Harness Interactions across Agent Tasks,” arXiv preprint arXiv:2610.00917, 2026.arxiv.org/abs/2610.00917
- [6]S. Zhang, M. Yin, J. Zhang, J. Liu, Z. Han, J. Zhang, B. Li, C. Wang, H. Wang, Y. Chen, and Q. Wu, “Which Agent Causes Task Failures and When? On Automated Failure Attribution of LLM Multi-Agent Systems,” arXiv preprint arXiv:2505.00212, 2025.arxiv.org/abs/2505.00212
- [7]D. Deshpande, V. Gangol, H. Mehta, J. Krishnan, A. Kannappan, and R. Qian, “TRAIL: Trace Reasoning and Agentic Issue Localization,” arXiv preprint arXiv:2505.08638, 2025.arxiv.org/abs/2505.08638
- [8]N. Kekatos, S. Basagiannis, M. Chinthri, A. Lekidis, T. Nianios, I. Seitoglou, A. Temperikidis, and P. Katsaros, “Formal Runtime Verification for Tool-Using LLM Agents: An Offline Same-Benchmark Study on AgentDojo and STAC,” arXiv preprint arXiv:2610.09793, 2026.DOI
- [9]T. R. Sumers, S. Yao, K. Narasimhan, and T. L. Griffiths, “Cognitive Architectures for Language Agents,” arXiv preprint arXiv:2309.02427, 2023.
- [10]Q. Zhan, Z. Liang, Z. Ying, and D. Kang, “InjecAgent: Benchmarking Indirect Prompt Injections in Tool-Integrated Large Language Model Agents,” arXiv preprint arXiv:2403.02691, 2024.arxiv.org/abs/2403.02691
- [11]T. Yan, “When “Do Not” Is Not Deni: Security Rules in CLAUDE.md vs Built-In Controls,” arXiv preprint arXiv:2608.23550, 2026.arxiv.org/abs/2608.23550
- [12]C. Liu and D. Ding, “What to Admit and How to Present: Governing Persistent Memory in LLM Agents,” arXiv preprint arXiv:2610.11188, 2026.arxiv.org/abs/2610.11188
- [13]Z. Chen, Z. Xiang, C. Xiao, D. Song, and B. Li, “AgentPoison: Red-teaming LLM Agents via Poisoning Memory or Knowledge Bases,” arXiv preprint arXiv:2407.12784, 2024.arxiv.org/abs/2407.12784
- [14]W. Zou, M. Dong, M. R. Calvo, S. Chang, J. Guo, D. Lee, X. Niu, X. Ma, Y. Qi, and J. Jiang, “Poison Once, Exploit Forever: Environment-Injected Memory Poisoning Attacks on Web Agents,” arXiv preprint arXiv:2604.02623, 2026.arxiv.org/abs/2604.02623
- [15]N. Shinn, F. Cassano, E. Berman, A. Gopinath, K. Narasimhan, and S. Yao, “Reflexion: Language Agents with Verbal Reinforcement Learning,” arXiv preprint arXiv:2303.11366, 2023.arxiv.org/abs/2303.11366
- [16]G. Wang, Y. Xie, J. Jiang, A. Mandlekar, C. Xiao, Y. Zhu, L. Fan, and A. Anandkumar, “Voyager: An Open-Ended Embodied Agent with Large Language Models,” arXiv preprint arXiv:2305.16291, 2023.arxiv.org/abs/2305.16291
- [17]W. Bai, M. Waseem, Z. Rasheed, J. Peltonen, and P. Abrahamsson, “Where Did the Repair First Go Wrong? Localizing the Origins of Silent Failures in Agentic Vulnerability Repair,” arXiv preprint arXiv:2610.06163, 2026.arxiv.org/abs/2610.06163
- [18]Z. Wang, Y. Zhang, D. Lee, N. Baracaldo, and Y. Yang, “Lost in Context Compaction: When LLM Systems Drop Side Constraints,” arXiv preprint arXiv:2608.11242, 2026.arxiv.org/abs/2608.11242
- [19]T. Lindenbauer, I. Slinko, L. Felder, E. Bogomolov, and Y. Zharov, “The Complexity Trap: Simple Observation Masking Is as Efficient as LLM Summarization for Agent Context Management,” arXiv preprint arXiv:2508.21433, 2025.arxiv.org/abs/2508.21433
- [20]Q. Zhan, R. Zhang, S. Guo, L. Zhao, and Z. Liu, “When Memory Becomes Authority: Benchmarking Authority Collapse at the Memory Consolidation Boundary,” arXiv preprint arXiv:2608.01679, 2026.arxiv.org/abs/2608.01679
- [21]Y. Zhou, Y. Ouyang, K. Zheng, and S. Xiang, “TEGA: Revoking Stale Memories for Conflict-Robust Language Agents,” arXiv preprint arXiv:2608.07429, 2026.arxiv.org/abs/2608.07429
- [22]T. Wu, W. Chang, L. Cao, W. Gao, and W. Wang, “Crab: A Semantics-Aware Checkpoint/Restore Runtime for Agent Sandboxes,” arXiv preprint arXiv:2604.28138, 2026.arxiv.org/abs/2604.28138
- [23]Z. Chen, H. Liu, D. Xu, D. Dong, J. Li, B. Pu, and J. Zhai, “Cordon: Semantic Transactions for Tool-Using LLM Agents,” arXiv preprint arXiv:2606.17573, 2026.arxiv.org/abs/2606.17573
- [24]Y. Su, W. Xu, C. Zuo, and E. Bertino, “ChronoMem: Version Control and Semantic Rollback for Large Language Model Agent Memory,” arXiv preprint arXiv:2607.27773, 2026.arxiv.org/abs/2607.27773
- [25]G. Zhang and H. Yang, “Aborted but not Forgotten: KV-Cache Retention Breaks Rollback Consistency in Language Agents,” arXiv preprint arXiv:2608.15939, 2026.arxiv.org/abs/2608.15939
- [26]Y. Ye, H. Gu, N. Vidra, S. Setty, and S. Zheng, “OrchestraBench: Evaluating Multi-Agent Orchestration Failure Modes, Recovery, and Decomposition Quality,” arXiv preprint arXiv:2608.05263, 2026.
- [27]H. Zhang, J. Huang, K. Mei, Y. Yao, Z. Wang, C. Zhan, H. Wang, and Y. Zhang, “Agent Security Bench (ASB): Formalizing and Benchmarking Attacks and Defenses in LLM-based Agents,” arXiv preprint arXiv:2410.02644, 2024.arxiv.org/abs/2410.02644
- [28]E. Debenedetti, I. Zhang, M. Balunović, L. Beurer-Kellner, M. Fischer, and F. Tramèr, “AgentDojo: A Dynamic Environment to Evaluate Prompt Injection Attacks and Defenses for LLM Agents,” arXiv preprint arXiv:2406.13352, 2024.
- [29]Y. Zhang, T. Yu, and D. Yang, “Attacking Vision-Language Computer Agents via Pop-ups,” arXiv preprint arXiv:2411.02391, 2024.arxiv.org/abs/2411.02391
- [30]T. Kuntz, A. Duzan, H. Zhao, F. Croce, Z. Kolter, N. Flammarion, and M. Andriushchenko, “OS-Harm: A Benchmark for Measuring Safety of Computer Use Agents,” arXiv preprint arXiv:2506.14866, 2025.arxiv.org/abs/2506.14866
- [31]J. Luo, Z. Liao, J. Teng, and Y. Wang, “CausalCache: Conditional High-Fidelity Restoration for Long-Horizon GUI Agents,” arXiv preprint arXiv:2608.22577, 2026.arxiv.org/abs/2608.22577
- [32]Y. Gu, K. Zhang, Y. Ning, B. Zheng, B. Gou, T. Xue, C. Chang, S. Srivastava, Y. Xie, P. Qi, H. Sun, and Y. Su, “Is Your LLM Secretly a World Model of the Internet? Model-Based Planning for Web Agents,” arXiv preprint arXiv:2411.06559, 2024.arxiv.org/abs/2411.06559
- [33]S. A. Crosby and D. S. Wallach, “Efficient data structures for tamper-evident logging,” in Proceedings of the 18th USENIX Security Symposium, 2009.
- [34]L. Bindschaedler, Q. Botha, and C. Siebenbrunner, “Agent Flight Recorder: Tamper-Evident Audit Trails with On-Chain Anchoring for Long-Horizon Tool-Using Agents,” arXiv preprint arXiv:2609.01931, 2026.arxiv.org/abs/2609.01931
- [35]A. Yuan, Z. Su, and Y. Zhao, “AEGIS: No Tool Call Left Unchecked – A Pre-Execution Firewall and Audit Layer for AI Agents,” arXiv preprint arXiv:2603.12621, 2026.arxiv.org/abs/2603.12621
- [36]M. Costa, B. Köpf, A. Kolluri, A. Paverd, M. Russinovich, A. Salem, S. Tople, L. Wutschitz, and S. Zanella-Béguelin, “Securing AI Agents with Information-Flow Control,” arXiv preprint arXiv:2505.23643, 2025.
- [37]P. Y. Zhong, S. Chen, R. Wang, M. McCall, B. L. Titzer, H. Miller, and P. B. Gibbons, “RTBAS: Defending LLM Agents Against Prompt Injection and Privacy Leakage,” arXiv preprint arXiv:2502.08966, 2025.arxiv.org/abs/2502.08966
- [38]M. Shim, R. R. Karim, R. Jakkula, K. Zhou, X. Liu, X. E. Wang, and Z. Li, “Confuse the Model, Control the Flow: Understanding and Mitigating Privacy Leakage from LLM Agents with Information Flow Control,” arXiv preprint arXiv:2609.14003, 2026.arxiv.org/abs/2609.14003
- [39]V. M. Sangaraju and S. Vissa, “Lineage-Aware Memory Governance: A Derivation-Gated Framework for Privacy-Preserving Column-Level Access Control in Enterprise AI Agents,” arXiv preprint arXiv:2610.07258, 2026.DOI
- [40]H. Ma, A. Hariri, T. Shen, B. Zou, Q. Zheng, J. Wang, L. Yi, N. Jia, Y. Liu, H. Chen, L. Wang, and D. Roy, “MetaPermit: Scalable and Auditable Access Control for AI Agents via LLM-Inferred Meta-Attributes,” arXiv preprint arXiv:2609.31039, 2026.arxiv.org/abs/2609.31039
- [41]Y. Zheng, W. Zhang, and Y. Mao, “LLM Agent Capabilities Should Follow Task Intent and Context Source,” arXiv preprint arXiv:2609.14631, 2026.arxiv.org/abs/2609.14631
- [42]Y. Wu, F. Roesner, T. Kohno, N. Zhang, and U. Iqbal, “IsolateGPT: An Execution Isolation Architecture for LLM-Based Agentic Systems,” in Proceedings of the Network and Distributed System Security (NDSS) Symposium, 2025.arxiv.org/abs/2403.04960
- [43]H. Kines, G. Lopez, M. Hall, F. Zarfati, Y. Zunger, and E. Kiciman, “Defending Against Indirect Prompt Injection Attacks With Spotlighting,” arXiv preprint arXiv:2403.14720, 2024.
- [44]E. Debenedetti, I. Shumailov, T. Fan, J. Hayes, N. Carlini, D. Fabian, C. Kern, C. Shi, A. Terzis, and F. Tramèr, “Defeating Prompt Injections by Design,” arXiv preprint arXiv:2503.18813, 2025.arxiv.org/abs/2503.18813
- [45]D. S. Bouras, Y. Dai, and S. Mechtaev, “Authority Is Not a String: A Capability-Scoped Harness for Prompt-Injection-Resistant Coding Agents,” arXiv preprint arXiv:2609.08371, 2026.arxiv.org/abs/2609.08371
- [46]B. Deng, X. Zheng, Y. Wei, K. Zhou, C. Tao, R. Liang, X. Chen, L. Guo, and C. Zhang, “DeFA: Dependency-Guided Failure Attribution for LLM Agents,” arXiv preprint arXiv:2610.01256, 2026.arxiv.org/abs/2610.01256
- [47]S.-X. Yang, Y. Wang, Z. Feng, B. Wen, J. Gui, D. Yang, W. Yu, H. Zhang, J. Tang, and C. Wang, “From Anomalies to Failures: Constructing Causal Error Graphs for Agentic Trace Diagnosis,” arXiv preprint arXiv:2609.32514, 2026.arxiv.org/abs/2609.32514
- [48]Y. Cai, X. Nie, K. Yin, C. Pei, Y. Sun, S. Zhang, H. Liu, G. Liu, X. Wen, F. Situ, and D. Pei, “A Multi-Dataset Benchmark for Evaluating LLM Agents in Microservice Failure Diagnosis,” arXiv preprint arXiv:2606.29193, 2026.arxiv.org/abs/2606.29193
- [49]S. Jha et al., “ITBench: Evaluating AI Agents across Diverse Real-World IT Automation Tasks,” arXiv preprint arXiv:2502.05352, 2025.
- [50]T. Rebedea, R. Dinu, M. Sreedhar, C. Parisien, and J. Cohen, “NeMo Guardrails: A Toolkit for Controllable and Safe LLM Applications with Programmable Rails,” arXiv preprint arXiv:2310.10501, 2023.
- [51]R. Zhang, “Why Formal Monitors Fail: Attack Distribution Entropy as a Coverage Bound for LTL-Based LLM Agent Safety,” arXiv preprint arXiv:2608.01388, 2026.arxiv.org/abs/2608.01388
- [52]Y. Feng, Y. Zhang, Y. Liu, and J. Li, “Safe Actions Alone Do Not Ensure Safe Agents: Identifying Unfulfilled Obligations with Guard Models,” arXiv preprint arXiv:2610.11773, 2026.arxiv.org/abs/2610.11773
- [53]T. Shi, J. He, Z. Wang, H. Li, L. Wu, W. Guo, and D. Song, “Prompt: Securing AI Agents with Privilege Control,” arXiv preprint arXiv:2504.11703, 2025.arxiv.org/abs/2504.11703
- [54]R. K. Sharma and D. Grossman, “AC4A: Access Control for Agents,” arXiv preprint arXiv:2603.20933, 2026.
- [55]Z. Ji, D. Wu, W. Jiang, P. Ma, Z. Li, Y. Gao, S. Wang, and Y. Li, “Taming Various Privilege Escalation in LLM-Based Agent Systems: A Mandatory Access Control Framework,” arXiv preprint arXiv:2601.11893, 2026.arxiv.org/abs/2601.11893
- [56]J. Xu, L. Fan, Z. Wang, X. Li, and H. Liu, “Beyond Single-Use Tokens: Durable Authorization State for Replay-Resistant LLM Agent Actions,” arXiv preprint arXiv:2608.01710, 2026.arxiv.org/abs/2608.01710
- [57]Q. Wang, C. Wang, J. Meng, R. Qin, K. Peng, Z. Wei, and W. Shen, “Authorization Closure Graph: Minimal Repair for LLM Agents with Evolving User Instructions,” arXiv preprint arXiv:2609.32428, 2026.arxiv.org/abs/2609.32428
- [58]Y. He, Z. Shan, L. Luo, and W. Wang, “Accountable yet Anonymous AI Agents - Split-Knowledge Binding in National Agent-Identity Layer in China,” arXiv preprint arXiv:2607.23207, 2026.arxiv.org/abs/2607.23207
- [59]J. Wang, X. Liao, and W. Wu, “STAR: A Stage-attributed Triage and Repair framework for RCA Agents in Microservices,” arXiv preprint arXiv:2605.15581, 2026.
- [60]Y. Zhang, K. Chen, Y. Duan, S. Zheng, J. Li, and X.-Y. Zhang, “AgentRewind: Recoverable Execution for Long-Horizon LLM Agents,” arXiv preprint arXiv:2608.14380, 2026.arxiv.org/abs/2608.14380
- [61]X. Zheng, X. F. Guo, Z. Hao, F. Yang, X. Qian, J. Du, J. Xu, Z. Xing, S. Yang, and X. Wang, “APEX: Active Protection at Execution Boundaries for LLM Agents,” arXiv preprint arXiv:2610.06966, 2026.arxiv.org/abs/2610.06966
- [62]D. M. Zuvic, “Capability Gates Are Not Authorization: Confused-Deputy Failures in LLM Agent Frameworks,” arXiv preprint arXiv:2606.28679, 2026.arxiv.org/abs/2606.28679
- [63]J. Jia, Z. Deng, Z. Chen, Y. Wang, and Z. Zheng, “MAS-FIRE: Fault Injection and Reliability Evaluation for LLM-Based Multi-Agent Systems,” arXiv preprint arXiv:2602.19843, 2026.arxiv.org/abs/2602.19843
- [64]D. Zhu, X. Ma, Y. Shen, X. Li, Y. Zhao, S. Wang, L. Yan, and D. Yin, “When Tools Fail: Benchmarking Dynamic Replanning and Anomaly Recovery in LLM Agents,” arXiv preprint arXiv:2606.05806, 2026.arxiv.org/abs/2606.05806
- [65]Y. Zhou, X. Lu, D. Liu, J. Yan, and J. Shao, “INFA-Guard: Mitigating Malicious Propagation via Infection-Aware Safeguarding in LLM-Based Multi-Agent Systems,” arXiv preprint arXiv:2601.14667, 2026.arxiv.org/abs/2601.14667
- [66]Z. Seyedghorban, E. Klimov, A. van Deursen, A. Panichella, and B. K. Ozkan, “Observability and Fault Injection for LLM-Based Multi-Agent Systems in Software Engineering,” arXiv preprint arXiv:2608.24271, 2026.DOI
- [67]Y. Chen, M. Shetty, G. Somashekar, M. Ma, Y. Simmhan, J. Mace, C. Bansal, R. Wang, and S. Rajmohan, “AIOpsLab: A Holistic Framework to Evaluate AI Agents for Enabling Autonomous Clouds,” arXiv preprint arXiv:2501.06706, 2025.arxiv.org/abs/2501.06706
- [68]S. S. Sakhinana and V. Runkana, “Towards Agentic Cloud Engineering: Graph and Loop Engineering with a Zero-Trust Agent Harness,” arXiv preprint arXiv:2609.00050, 2026.arxiv.org/abs/2609.00050
- [69]J. Yang, S. Shao, D. Liu, and J. Shao, “RiOSWorld: Benchmarking the Risk of Multimodal Computer-Use Agents,” arXiv preprint arXiv:2506.00618, 2025.arxiv.org/abs/2506.00618
- [70]Y. Lu, J. Yang, Y. Shen, and A. Awadallah, “OmniParser for Pure Vision Based GUI Agent,” arXiv preprint arXiv:2408.00203, 2024.arxiv.org/abs/2408.00203
- [71]Y. Xie, S. Chen, J. Xing, W. Jiang, Z. Zhu, Y. Wang, P. Bu, J. Song, Y. Jiang, and B. Zheng, “SeeAgent: Efficient Mobile GUI Agent with Semantic Context,” arXiv preprint arXiv:2603.08533, 2026.arxiv.org/abs/2603.08533
- [72]Z. Xu, B. Zhou, Q. Wang, S. Feng, and J. Xiao, “Spatio-Temporal Token Pruning for Efficient High-Resolution GUI Agents,” arXiv preprint arXiv:2602.23235, 2026.arxiv.org/abs/2602.23235
- [73]F. Liu, Y. Liu, R. Sun, L. Luo, and S. Guo, “Coding Agents Have Converged: Why the SWE-bench Leaderboard Can No Longer Order Its Top Entries, and What to Measure Instead,” arXiv preprint arXiv:2609.17394, 2026.arxiv.org/abs/2609.17394
- [74]S. Yao, N. Shinn, P. Razavi, and K. Narasimhan, “τ-bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domains,” arXiv preprint arXiv:2406.12045, 2024.arxiv.org/abs/2406.12045
- [75]J. Owotogbe, “Assessing and Enhancing the Robustness of LLM-based Multi-Agent Systems Through Chaos Engineering,” arXiv preprint arXiv:2505.03096, 2025.arxiv.org/abs/2505.03096
- [76]L. Dong, Q. Lu, and L. Zhu, “AgentOps: Enabling Observability of LLM Agents,” arXiv preprint arXiv:2411.05285, 2024.arxiv.org/abs/2411.05285
- [77]H. Tibbeau and H. Shemtaga, “The Accountability Horizon: An Impossibility Theorem for Governing Human-Agent Collectives,” arXiv preprint arXiv:2604.07778, 2026.
- [78]M. Cemri, M. Z. Pan, S. Yang, L. A. Agrawal, B. Chopra, R. Tiwari, K. Keutzer, A. Parameswaran, D. Klein, K. Ramchandran, M. Zaharia, J. E. Gonzalez, and I. Stoica, “Why Do Multi-Agent LLM Systems Fail?” arXiv preprint arXiv:2503.13657, 2025.arxiv.org/abs/2503.13657