Technical Summary: User as Code (UaC)

1. Problem Statement

Personalized AI agents require a persistent model of the user ("user memory") that accumulates across sessions. Current memory systems typically store this information as unstructured text, knowledge graphs, or flat fact stores, relying on retrieval mechanisms (e.g., vector similarity) to fetch relevant entries. The authors identify three critical limitations in this "bag-of-facts" paradigm:

1. Separation of Representation and Verification: Storing a fact and acting on it are distinct steps. Retrieval-based systems struggle to resolve contradictions, aggregate data across many records, or enforce logical rules because the representation is not directly executable.
2. Inability to Handle Aggregate Queries: Questions requiring computation over the entire history (e.g., "How many international trips did I take last year?") cause retrieval-based systems to collapse, as top-k retrieval only sees a subset of records.
3. Lack of Proactive Service: Existing benchmarks focus on reactive recall. They fail to test "Active Service"—the ability of an agent to generate unsolicited, safety-critical alerts (e.g., drug-allergy conflicts) triggered by state changes rather than user queries.

2. Methodology: The User as Code Architecture

The paper proposes User as Code (UaC), a paradigm where the agent's model of a user is a living software project. The user's state is represented as typed Python objects, and the rules governing them are encoded as ordinary Python functions. This unifies representation and reasoning in a single medium executable by an interpreter.

The architecture relies on a two-phase pipeline to convert raw conversation into this executable code:

Phase 1: Memorize (Append-Only Extraction)

• Process: For each conversation session, an LLM extracts individual facts as flat strings.
• Key Feature: These facts are appended to a running log and never overwritten or deleted. Relative dates are resolved to absolute dates against the session timestamp.
• Storage: Facts are indexed in a vector store (ChromaDB) for retrieval fallback. Raw conversation chunks are also archived.

Phase 2: Structure (Periodic Regeneration)

• Process: Periodically, an LLM regenerates the entire structured Python code from the complete accumulated fact corpus.
• Output: Facts are organized into typed dataclass instances (e.g., PassportInfo, Medication).
• Constraint Generation: A "coding agent" writes Python functions (constraints) that operate on this typed state. These functions are executed deterministically in a sandbox.
• Alerting: The results of these constraints (e.g., ACTIVE_ALERTS) are surfaced in a compact manifest loaded at the start of every new session, enabling proactive alerts without user queries.

Retrieval and Usage

UaC employs a Multi-Strategy Retrieval system that composes three channels:

1. Structured Code State: The typed Python state is included verbatim in the prompt (truncated if necessary).
2. Fact-Vector Retrieval: Top-k facts from the append-only log are retrieved via cosine similarity to cover details not captured in the schema.
3. Archive Retrieval: Raw conversation chunks are retrieved as a fallback for verbatim queries.

3. Key Contributions

1. A Two-Phase Memory Architecture: UaC achieves 78.8% accuracy on the full 10-conversation LOCOMO benchmark (600 QAs), statistically tied with the Full-Context upper bound (79.8%) and significantly outperforming same-backbone re-implementations of SOTA systems (MemMachine: 72.7%, Hindsight: 69.7%).
2. Analytical Inference Benchmark: The authors introduce a benchmark for aggregate questions (counts, sums, averages) over user history. UaC achieves 99% accuracy, whereas retrieval-based systems collapse (MemMachine: 43%, Mem0: 6%). This is because the answer is a one-line computation over typed state rather than a search over text.
3. Active Service Benchmark: A new benchmark testing proactive alerting (40 standard + 20 hard scenarios). UaC achieves 100% detection on standard scenarios and 85% on hard scenarios (involving complex date arithmetic and multi-domain constraints), a capability retrieval-based systems cannot provide without explicit queries.
4. Ablation Studies:
   • Append-only extraction is the single most significant factor for recall (+19pp over code-only baselines).
   • Two-phase separation (separating fact extraction from code structuring) prevents the information loss seen in incremental code rewriting (+12.3pp over incremental code).
   • Modularity: Loading only relevant domains on demand reduces token costs by 14.9× with no accuracy loss on large state sizes (500 records).
5. Cost Amortization: While structuring incurs a one-time cost, UaC becomes ~15× cheaper than reloading raw records for repeated queries (after 3–11 queries depending on state size).

4. Results and Performance

• LOCOMO: UaC (78.8%) is statistically indistinguishable from the Full-Context upper bound (79.8%, p=0.65) and beats all competing memory systems.
• LongMemEval: UaC scores 83.0%, statistically tied with MemMachine (84.8%) and Full Context (85.4%).
• Analytical Inference: UaC maintains near-perfect accuracy (99%) across record counts from 20 to 500, while retrieval-based systems degrade significantly as record count increases.
• Latency: UaC has a median answer latency of 3.62s (slightly higher than Full Context's 1.78s) due to the complexity of the multi-channel prompt, but remains within conversational pacing.
• Robustness: Results hold across different LLM backbones (GPT-5.4 vs. Gemini 3 Flash) and cross-judge evaluations (Claude Opus 4.7), with high inter-judge agreement (Cohen's κ ≥ 0.74).

5. Significance and Claims

The paper argues that User as Code fundamentally shifts the capability of AI memory. By treating user memory as a versioned, typed software project rather than a passive database, UaC enables:

• Deterministic Verification: Rules (constraints) execute deterministically, ensuring safety-critical checks (e.g., drug interactions) are reliable.
• Proactive Service: The system can surface alerts based on state changes without waiting for a user query, addressing the "initiation asymmetry" in personalized agents.
• Scalable Reasoning: Aggregating over large histories becomes a trivial computational task rather than a retrieval failure.

The authors position UaC not as a replacement for retrieval, but as a complementary layer where retrieval handles surface-level recall, while the executable code layer handles analytical inference and constraint checking. The work suggests that the "representation" between recording and recalling is the critical lever for agent intelligence, and that typed, executable code is a superior medium for this representation compared to unstructured text.

Limitations Acknowledged:

• The structured state is roughly neutral for pure single-hop recall (contributing only -1.3pp in ablation), indicating its primary value lies in aggregation and constraints.
• The "all-at-once" regeneration in Phase 2 faces scalability limits at hundreds of sessions, motivating future work on hierarchical structuring.
• Active Service performance on "hard" scenarios (n=20) is promising but statistically inconclusive against the strongest baseline (Mem0) due to sample size.