acceptodds
Under review as a conference paper at ICLR 2027

Executable Memory with Authenticated Runtime Admission for Long-Term Agents

Abstract

Long-term agent memory becomes operational when stored instructions govern tool use. Retrieval-based systems ask language models both to select relevant memory and to reconstruct its authorized effect, coupling semantic judgment with security-sensitive execution. We introduce Executable Memory with Authenticated Runtime Admission (EMARA), a systems architecture that represents registered, authority-bearing memory as typed programs and mediates their use at runtime. EMARA separates learned semantic nomination from trusted, state-bound admission. The model nominates public program handles; a reference monitor evaluates current-state predicates and releases only actions bound to authenticated certificates. We evaluate EMARA on MemBind-Bench, a long-context benchmark spanning web policies, workspace boundaries, secret handling, atomic program composition, and time-scoped knowledge use. Comparisons with textual, retrieval, external-memory, and executable baselines show that separating nomination from admission enables reliable, state-consistent execution across diverse memory settings. Controlled studies isolate semantic nomination, stored program content, action realization, certificate verification, request wording, and backbone choice. Together, the results identify runtime admission, rather than retrieval alone, as the mechanism that enables authorized execution from long-term agent memory.

Primary area:
other topics in machine learning (i.e., none of the above)
Keywords:
Natural Language Processing, Machine Learning, Long-Term Memory

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_TZiLOpenReview ↗
Rating
2
Confidence
2
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

This paper proposes Executable Memory with Authenticated Runtime Admission (EMARA), which is an architecture for using persistent, authority-bearing rules in tool-using agents. The motivation is that an LLM often nominates a bounded set of registered program handles, while a trusted runtime checks current state and produces authenticated certificates specifying permitted effects. The authors introduce MemBind-Bench. Additional experiments examine nomination, execution, verification, credential protection, and authority lifetime.

Critical strengths

S1. The paper addresses a relevant practical problem. Honestly, distinguishing retrieved information from permission to execute an action is important for agents.

S2. The paper is well written to some extent, though it is too concise to be a main track submission.

Critical weaknesses

W1. The introduction moves quickly from the general problem to the proposed architecture and headline results, without sufficiently discussing what existing executable-memory and runtime-security approaches cannot already provide. Section 2 talks about some related work, but the distinction is mostly stated rather than demonstrated.

W2. The evaluation is varied within one construction, but its external validity remains limited. Although MemBind-Bench includes five families and three dialogue sources, the policies and final requests are controlled interventions, every case has a 16-candidate bank, and the required program set contains only one or two targets.

W3. Several material details remain unresolved in the supplied manuscript. The presentation is way too much compressed in places where more specificity is needed. The abstract also claims controlled studies of request wording and backbone choice, but those results are not presented in the submitted main text.

Questions for authors
  1. What capability or guarantee does EMARA add beyond a simpler runtime using the same registered policies, authenticated state, deterministic action construction, and complete request-time authorization?

  2. How are registered programs and state adapters produced and audited? Please provide one end-to-end example distinguishing general runtime logic, family-specific implementation, and benchmark-specific construction.

  3. Other questions please refer to the weaknesses.

Reviewer_68UyOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes EMARA, an architecture that separates LLM-based memory selection from trusted runtime authorization. Agents nominate program handles, while a reference monitor validates state-bound certificates before executing typed actions. The authors introduce MemBind-Bench with 5,532 cases across five task families. EMARA achieves 88.02% task success and 0% unsafe actions, compared with 56.56% and 23.08% for the strongest non-oracle baseline. Additional experiments study component contributions, secret protection, routing errors, and authority expiration.

Critical strengths
  1. EMARA treats LLM-selected memory as untrusted evidence rather than execution authority. The use of typed grants, state-bound certificates, and deterministic execution provides a well-defined security boundary (Section 4). This is particularly relevant to agents that retain operational instructions across sessions.
  2. The 5,532-case benchmark covers five distinct authorization settings. Table 2 demonstrates substantial improvements over textual and executable-memory baselines. The paired ablations in Table 3 and lifecycle tests in Table 5 further support the effectiveness of deterministic execution and state-bound verification.
Critical weaknesses
  1. The central idea of separating untrusted semantic selection from trusted execution is not new. Prior work such as AgentSpec (ICSE 2026), Progent (2025), and CaMeL (2025) has already explored structured policy enforcement, deterministic authorization, and separating LLM decisions from trusted execution. EMARA introduces authenticated certificates, but it remains unclear what fundamentally new security property this design provides beyond established runtime enforcement mechanisms.
  2. EMARA restricts its scope to authority-bearing memory, while real agents rely on multiple interacting components, including system prompts, skills, tools, and persistent memory. Authorization-relevant behavior may originate from any of these components or their interactions. Existing approaches such as Progent and Safety Sidecar already operate at broader agent execution boundaries rather than being limited to memory-derived instructions. The paper does not investigate how EMARA handles scenarios across components.
  3. Established benchmarks such as Agent Security Bench (ASB, ICLR 2025), AgentDojo (NeurIPS 2024), and Agent-SafetyBench provide more realistic agent interaction and security scenarios. ASB is particularly relevant because it includes memory poisoning, prompt injection, and tool-use attacks. Progent has already been evaluated on ASB and AgentDojo, making these natural candidates for comparative evaluation. Can the authors evaluate EMARA on relevant datasets?
Questions for authors
  1. What are EMARA's key technical contributions beyond existing runtime enforcement frameworks such as AgentSpec, Progent, and CaMeL? Can the authors provide direct comparisons with these approaches?
  2. Why does EMARA focus specifically on memory rather than providing general authorization enforcement across agent components? How would it handle security risks arising from interactions between memory, prompts, skills, and tools?
  3. Can the authors evaluate EMARA on relevant subsets of established benchmarks such as ASB, AgentDojo, or Agent-SafetyBench to demonstrate its effectiveness in realistic agent security scenarios?
Reviewer_nugFOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

EMARA studies how an agent can use executable memories without treating retrieval as permission to act. An LLM router nominates at most k opaque handles from a public catalog. A trusted probe evaluates each registered program against current state. A reference monitor releases only actions bound to an authenticated certificate, which covers the program, state, grant, principal, validity window, revocation epoch, nonce and batch. The paper also introduces MemBind-Bench: 5,532 paired cases from 922 dialogues in five families, each case with a 16-candidate bank, scored deterministically. On Qwen2.5-14B-Instruct, EMARA raises task success from 56.56% to 88.02% over the strongest baseline and cuts unsafe actions from 23.08% to 0.00%. Further experiments cover component ablations, certificate mutations, routing budgets and lifecycle tests. Admission blocks invalid actions under the benchmark’s assumptions, but end-to-end success stays bounded by routing recall.

Critical strengths
  1. The paper treats authority-bearing memory as a runtime authorization problem rather than a retrieval problem: the LLM only nominates handles, and a trusted monitor decides release.

  2. MemBind-Bench is a useful. It tests whether remembered authority is applied correctly, not just recalled.

  3. Extensive experiments.

Critical weaknesses
  1. No comparison with agent authorization systems. CaMeL (Debenedetti et al., 2025) and Progent (2025) already pair an untrusted LLM proposer with deterministic policy enforcement, and neither is cited. [1] Defeating Prompt Injections by Design [2] Progent: Programmable Privilege Control for LLM Agents

  2. All results use one backbone (Qwen2.5-14B), one seed, a closed 16-candidate bank and a self-built benchmark.

  3. Inconsistent baselines and populations.

  • Table 3’s “Schema LLM, no admission” is described the same way as Text Memory + Script (§6, §7.2, Fig. 3 caption), but the numbers differ: Atomic 38.40 vs 59.48, Knowledge 60.31 vs 23.02.
  • Text Memory + Script’s unsafe rate in Table 4 is non-monotonic in k (50.09 → 25.83 → 48.90 for k = 2, 3, 4). The explanation that “more candidates destabilize realization” does not account for the dip exactly at the chosen k = 3.
  • RQ3 tests “all 618 Secret-Handle cases from 104 dialogues”, but Table 1 lists 1,290 cases from 215 dialogues, and EMARA scores 99.35% there vs 97.29% in Table 2.
Questions for authors
  1. How do task success and the unsafe rate degrade when you inject program bugs (missing predicates, overly broad grants), adapter errors, or state influenced by untrusted input?

  2. Who writes the programs? If they are compiled from dialogue by an LLM, what are the registration error rate and the end-to-end results? How are requests with no matching program handled?

  3. What exactly distinguishes Text Memory + Script from “Schema LLM, no admission”, and do Text Memory + Script’s probe results include the grant? Please report Text Memory + Script at every k under one configuration. How was the 618-case RQ3 subset selected, and what are the results on all 1,290 cases?

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.