Paper deep dive

Experience Graphs: The Data Foundation for Self-Improving Agents

Gang Liao, Yujia He, Abdullah Ozturk, Zhouyang Li, Ying Wang, Zhitong Guo, Hongsen Qin, Yaobin Qin, Tao Yang, Zewei Jiang, Dianshi Li, Jort Gemmeke, Jiangyuan Li, Liyuan Li, Nathan Yan, Masha Basmanova, Uladzimir Pashkevich, Matt Steiner, Pedro Pedreira, Rob Fergus, Anirudh Goyal, Carole-Jean Wu, Gaoxiang Liu, Andrew Witten, Daniel J. Abadi

Year: 2026Venue: arXiv preprintArea: cs.DBType: PreprintEmbeddings: 69

Intelligence

Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 92%

Last extracted: 7/5/2026, 2:51:32 AM

Summary

The paper proposes 'Trellis', a new data foundation designed for long-horizon agentic tasks (e.g., code generation, scientific discovery). It introduces the concept of an 'Experience Graph'—a structured, causal tree of executable artifacts, tool outputs, and rewards—to replace ephemeral JSON logs. Unlike traditional agent memory (declarative, procedural, episodic), the experience graph is treated as a first-class, queryable database state. This allows for advanced database access patterns such as frontier selection, cross-session reuse via vector-seeded graph retrieval, and the extraction of training data (SFT, DPO, GRPO) as materialized views. The design is grounded in 'KernelEvolve' at Meta, demonstrating that treating experience as a database enables stateless, serverless agents and a closed-loop training flywheel for recursive self-improvement (RSI).

Entities (6)

Claude Code · agent-framework · 100%Experience Graph · data-structure · 100%KernelEvolve · production-system · 100%Meta · organization · 100%Trellis · systemdata-foundation · 100%Recursive Self-Improvement (RSI) · concept · 90%

Relation Signals (4)

Experience Graph → contains → Executable Artifacts

confidence 100% · executable artifacts, tool outputs, rewards, sibling comparisons, and causal lineage.

Trellis → manages → Experience Graph

confidence 100% · We propose Trellis: a data foundation that treats the experience graph as first-class, governed, queryable database state.

Trellis → enables → Recursive self-improvement

confidence 90% · When the database owns the experience graph... a closed-loop training flywheel emerge as architectural byproducts.

KernelEvolve → isgroundedin → Trellis

confidence 90% · We ground the design in KernelEvolve, a production accelerator-kernel optimizer at Meta

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:The database community has repeatedly advanced the state of the art by recognizing that new workloads demand new system architectures. We argue that long-horizon agentic tasks -- code generation, scientific discovery, hardware design -- are such a workload. These agents explore: they generate artifacts, execute tools, observe failures, branch, and repair over hundreds of steps. This search produces a structured object we call an experience graph: executable artifacts, tool outputs, rewards, sibling comparisons, and causal lineage. Yet existing agent frameworks treat this experience as disposable state -- JSON checkpoints and session logs that cannot be recovered after a crash, queried across users, or materialized into training data. We propose Trellis: a data foundation that treats the experience graph as first-class, governed, queryable database state. The core insight is that search over experience graphs is a database access pattern. Frontier selection is a query, cross-session reuse is vector-seeded graph retrieval, training-data extraction is a materialized view, and reconstructing what an agent knew at any past step is a time-travel query. When the database owns the experience graph, agents become stateless compute, and crash recovery, horizontal scaling, and a closed-loop training flywheel emerge as architectural byproducts. We ground the design in KernelEvolve, a production accelerator-kernel optimizer at Meta, where cross-session reuse reaches a target speedup roughly 10x faster at 52% lower token cost. More broadly, Trellis turns inference-time search from disposable computation into a durable institutional asset: logs made databases reliable; experience graphs may make agents cumulative.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

68,325 characters extracted from source content.

Expand or collapse full text

Experience Graphs: The Data Foundation for Self-Improving Agents Gang Liao † Yujia HeAbdullah OzturkZhouyang LiYing Wang Zhitong Guo Hongsen QinYaobin QinTao YangZewei JiangDianshi LiJort Gemmeke Jiangyuan LiLiyuan LiNathan YanMasha BasmanovaUladzimir Pashkevich Matt SteinerPedro Pedreira Rob FergusAnirudh GoyalCarole-Jean WuGaoxiang Liu † Meta Platforms gangliao@meta.com,gaoxiang@meta.com Andrew WittenDaniel J. Abadi † University of Maryland, College Park abadi@umd.edu Abstract The database community has repeatedly advanced the state of the art by recognizing that new workloads demand new system architectures. We argue that long-horizon agentic tasks—code generation, scientific discovery, hardware de- sign, security research—are such a workload. Rather than producing a single answer, these agents explore: they gener- ate artifacts, execute tools, observe failures, branch, repair, and compare alternatives over hundreds of steps, improv- ing over a baseline as they go. This search produces a rich, structured object we call an experience graph: executable ar- tifacts, tool outputs, objective rewards, sibling comparisons, mutable search statistics, and causal lineage. Yet existing agent frameworks treat this experience as disposable state— serialized into JSON checkpoints and session logs that cannot be recovered after a crash, queried across users, searched by similarity, or materialized into training data without brit- tle, after-the-fact scraping. Even the file-based memory that production agents have converged on—declarative facts, pro- cedural skills, episodic logs—captures what an agent knows, not the reward-bearing experience graph of what its search tried. We propose Trellis 1 : a data foundation that treats the experience graph as first-class, governed, queryable data- base state rather than ephemeral logs. The core insight is that search over experience graphs is a database access pattern. Frontier selection is a query, cross-session reuse is vector- seeded graph retrieval, training-data extraction is a materi- alized view, and reconstructing what an agent knew at any past step is a time-travel query. When the database owns the experience graph instead of the agent process, agents become stateless, serverless compute, and crash recovery, hor- izontal scaling, and a closed-loop training flywheel emerge 1 A trellis is the structural lattice that plants climb and grow on—it does not grow itself, but supports and guides all growth. That is the role of the data foundation: agents explore, evolve, and improve; the trellis holds the shape. as architectural byproducts. We ground the design in Ker- nelEvolve, a production accelerator-kernel optimizer at Meta, where cross-session reuse reaches a target speedup roughly 10×faster at 52% lower token cost per valid solution. More broadly, Trellis turns inference-time search from disposable computation into a durable institutional asset: logs made databases reliable; experience graphs may make agents cu- mulative. 1 Introduction Database systems tailor-designed for workloads outperform generic systems [44,45]. Transaction processing, warehous- ing, streaming, graphs, and key-value serving have each grown into its own research area once its access patterns were named precisely. We expect that long-horizon agen- tic tasks [50,53] are driving the next wave that transforms database design. These tasks are solved not by one-shot inference but by it- erative search: the agent explores, evaluates, fails, repairs, and refines solutions over tens to hundreds of steps before con- verging, each attempt informed by the ones before it. Because every converged solution raises the baseline for the next, this loop is a concrete form of recursive self-improvement (RSI) [13,46]. Agentic applications are already adopted in real production environments at scale. For example, AlphaE- volve [33] uses evolutionary search to discover algorithms, optimizes TPU circuits, and improves Spanner [10] com- paction heuristics. Anthropic’s Project Glasswing [4] chains multi-step exploits to find vulnerabilities across every major OS and browser. Meta’s KernelEvolve [26–28] uses Monte Carlo Tree Search (MCTS) [5,23] and evolutionary search algorithms to generate optimized kernels for AI hardware— programs that translate machine learning model operations into chip-specific instructions—for NVIDIA, AMD, Meta Training Inference Accelerators (MTIA) [9], and CPU targets, delivering over 60% inference throughput improvement on † Corresponding authors. arXiv:2606.29823v1 [cs.DB] 29 Jun 2026 CIDR’27, January 19-22, 2027, Amsterdam, The NetherlandsLiao, et al. production ranking and recommendation workloads [28]. A growing ecosystem of frameworks [1,6,20,38,47,49] has emerged that drives ML engineering and scientific discovery through agentic tree search. This search leaves behind far more than a final answer. Each step records the prompt the model saw, the artifact it produced, the tool outputs it observed, an objective reward, and causal links to its parent and siblings—together forming what we call an experience graph. Yet every one of the systems above keeps this graph in Python objects and JSON check- points. We learned the cost of this firsthand. KernelEvolve’s first implementation stored its search tree in process-local state and file checkpoints; this sufficed for a single session but failed as a production foundation. Progress was lost on crashes, parallel workers needed ad hoc coordination, prior discoveries could not be reused systematically, and training data had to be scraped from logs after the fact. Each miss- ing capability was really the same missing abstraction: the experience graph was not a database object. A purpose-designed database for long-horizon agentic tasks dissolves these problems. We therefore explore the system architecture design space, leading to a new data foundation—Trellis—that treats the experience graph as first-class, governed, queryable database state rather than ephemeral logs. The core insight is that search over experi- ence graphs is a database access pattern: recovery is a query against the frontier, cross-session reuse is a vector-seeded graph traversal, training-data extraction is a materialized view, and agent replay is an as-of temporal query. Trellis is our attempt to define the database architecture for agentic tasks before accidental abstractions become permanent. This paper makes three important contributions. First, we define the self-improving agentic system as a two-loop architecture: an inner loop of skill-driven agent sessions, and an outer loop of RSI tree search over a persistent data substrate that renders agents stateless and serverless. We then show how this framework extends from a single-agent search to multi-agent scientific societies where agents share hypotheses, critiques, and distilled knowledge (Section 2). Second, we show that declarative, procedural, and episodic memory tiers around which production agents have con- verged are an incomplete, ungoverned special case, and de- scribe a concrete data foundation that unifies them with the reward-bearing experience graph through a query layer composing graph traversal, vector similarity, and structured filters. In doing so, we identify common access patterns— append-heavy writes mixed with multi-hop path updates, vector retrieval, and as-of temporal reconstruction—that could benefit from new system architectures (Sections 3–5). Third, we introduce new database research opportunities— multi-modal query planning, consistency for concurrent tree search, physical design for the above-described access pat- tern, governed view maintenance, bi-temporal memory, and database semantics for multi-agent institutions. We believe these are new important areas that need more investments from the data management community (Section 7). Through- out this paper, we ground the research on real-world produc- tion measurements from KernelEvolve—an agentic kernel coding framework deployed in the production environment, including a controlled study in which cross-session memory converges 10×faster at 52% lower token cost while revealing an exploration–anchoring tradeoff (Section 6). 2 Self-Improving Agentic Systems The first generation of AI assistants, such as GitHub Copilot and ChatGPT, was one-shot: prompt in, answer out, session over. The current generation, such as Claude Code [3] and Codex [34], is agentic: the tool reads files, runs commands, observes errors, and iterates within a single session. These agents are no longer session-isolated. They persist declara- tive facts across sessions (CLAUDE.md,MEMORY.md), accumu- late reusable skills, maintain searchable episode archives, and run consolidation pipelines—such as Claude’s dreaming pass—that distill and prune what they have learned. But the state these tiers capture is knowledge: what the agent knows, what it prefers, how it solved a class of problems before. Long-horizon tasks produce a different kind of state. Sci- entific discovery, hardware design, security research, and infrastructure optimization are problems where the right answer emerges only after dozens or hundreds of failed at- tempts, each informed by the failures before it. The state this search generates is not knowledge to be recalled but a reward-bearing experience graph: a causal tree of attempts, fitness scores, sibling comparisons, and the tool outputs that justify each decision. No file-based memory tier has a place for this graph, and no existing agent framework exposes it as queryable, governed, shared state. A single session is insuffi- cient; the system must orchestrate many sessions into a struc- tured search, accumulate results across sessions, and learn from the entire history. This is the RSI process introduced above. We call the system that supports RSI a self-improving agentic system, and argue that it has three essential compo- nents (Figure 1): an inner loop that executes individual steps, an outer loop that orchestrates search, and a persistent data substrate that records everything both loops produce. The inner loop. Each node in the experience graph is produced by a single execution of the inner loop—an au- tonomous agent session (Claude Code, Codex, or any tool- using LLM) driven by skills 2 . A skill tells the agent what to do, how to evaluate the result, and what constitutes success. For example, one skill generates and benchmarks GPU ker- nels; another runs timing analysis on a chip design; another measures binary size after a compiler-pass reordering; an- other searches for security vulnerabilities. The inner loop 2 Skills are reusable, user-defined task specifications for agent ses- sions; see https://platform.claude.com/docs/en/agents-and-tools/agent- skills/overview. Experience Graphs: The Data Foundation for Self-Improving AgentsCIDR’27, January 19-22, 2027, Amsterdam, The Netherlands Outer Loop — Search Orchestration MCTSEvoGreedyLinear One-Shot Frontier Select · Assemble Context · Insert · Update Rewards Inner Loop — Agent Session Skill → Meta LLM → Sandbox → Evaluate → Persist Claude CodeCodexMeta LLM Generate · Benchmark · Debug · Optimize · Validate context result insert / querypersist Trellis — Data Foundation TasksSessionsNodesPromptsEmbeddingsArtifacts SQLCypherVector Axiom Optimizer · Velox Engine · XDB/MySQL · Hive views Training Views SFT Trajectories DPO Preference Pairs GRPO Groups materialized views over operational state sample → expand N → train → append 1 Self-Improving Flywheel Better Models Better Exploration Better Data every round compounds on the last feedback loop data flowfeedback loopentity / component Figure 1. Architecture of a self-improving agentic system. does not change across skills. It always follows the same pattern: consume a task description and context from the outer loop, generate candidate artifacts via LLM inference, execute and evaluate in an isolated sandbox, and persist the structured output—execution logs, evaluation metrics, cor- rectness results, analysis report, fitness score—as the node’s record. The agent then terminates; it holds no state. The outer loop. The outer loop decides which step to take next based on a search strategy. Each step becomes a point in an experience graph. Figure 2 shows some exam- ple search strategies and the experience graphs that they produce. A one-shot search strategy produces a single node graph. Linear strategies chain revisions into a path. Greedy strategies draft multiple candidates, pick the best, and deepen. MCTS strategies balance exploration and exploitation via UCB scores [5,23,43]. Evolutionary search maintains multi- ple islands with mutation, selection, crossover, and migration, producing a DAG [41]. The outer loop selects a frontier node based on the search strategy, assembles context from the existing experience graph—ancestors, siblings, prior failures—invokes the inner loop, and records the result. It is task-agnostic: it reads fitness scores and selects frontiers over the same data interface, regardless of the skill. The outer loop is a control plane. These strategies are not different systems but different policies over the same substrate: one-shot, linear, greedy, MCTS, and evolutionary search all read the current graph and decide which node to expand next, differing only in how that decision is made. It is therefore a mistake to equate the outer loop with any single algorithm. The outer loop is a control plane that selects a policy, and the policies form a spectrum. At one end, fixing the outer loop to a single expansion and letting the inner loop iterate internally yields the “auto research” configura- tion [22], in which one self-managing agent session runs the entire search and its experiment history survives only as in-context state and a flat log—queryable by no one. At the other, many workers expand a wide tree or a population of islands concurrently, and collaboration across heterogeneous harnesses (Codex, Claude Code, and others) is just another point on the same spectrum. What is invariant across all of them is the substrate: every policy reads frontier nodes and writes results through one data interface. The control plane decides how to search; the data foundation is indifferent to that choice. Memory scaling through external state. The two loops produce a graph. The question is where it should live. The central claim of this paper is that all exploration state should be placed inside a persistent, queryable store. When the database owns the graph, the system acquires memory scal- ing [12]: performance improves as the store grows, because new sessions query prior solutions, borrow high-fitness sub- trees, and skip dead ends. Knowledge compounds rather than evaporates. Separating compute from state. Persisting the graph in this way is not a mere convenience; it is the same archi- tectural move that has frequently reshaped data systems. Shared-disk parallelism, cloud storage disaggregation [11], and serverless functions [18,25] all rest on one principle: once durable state lives in a storage tier and the compute tier holds nothing it cannot afford to lose, compute becomes elastic, interchangeable, and fault-tolerant. A self-improving agent should be built the same way. Because every node, reward, and frontier pointer lives in the database, the agent process holds no irreplaceable state—it is disposable com- pute. Any worker can claim any frontier node at any time; a worker that dies mid-expansion loses at most one inner-loop invocation, never the search tree. There is no checkpoint to deserialize, no session pinned to a machine, and no warm-up. How much a crash costs depends on the granularity at which the graph is externalized: a single step when every step is a node, but an entire task when the outer loop is one and the CIDR’27, January 19-22, 2027, Amsterdam, The NetherlandsLiao, et al. One-ShotLinearGreedyMCTSEvolutionary R R R R island Aisland B insert one node no frontier query expand latest leaf parent_id chain deepen best leaf ORDER BY fitness UCB select + backprop visit_count, reward islands + migration generation, island_id rootvalidbest so farbuggyevolutionary islands increasing graph complexity Every strategy writes the same exploration_nodes table — only the selection query and mutated fields differ. Figure 2. Example search strategies and the experience graphs they produce. inner loop runs long. The foundation collapses this differ- ence by treating the inner-loop session itself as resumable state—each node references the session that produced it—so an interrupted session is reattached rather than restarted. Ex- ternalization granularity thus becomes a tuning knob rather than a correctness boundary, and the recovery guarantee holds at either extreme. Recovery is a query against the fron- tier, and scaling is adding or removing workers against a shared store. The self-improving loop. The two loops, connected through a shared store, form a recursive intelligence system. Exploration populates the store with structured trajectories. These trajectories are materialized as training views—supervised examples, preference pairs, reinforce- ment groups [16,39,42]—and used to post-train specialized models. These post-trained models drive better exploration, which produces higher-quality data, which trains better models. The system improves by using itself. Taken further, the data substrate can support not just parallel workers over a single tree but a society of agents that propose hypotheses, critique each other’s results, and distill lessons into shared memory—scientific compounding, not just parallel search. None of this is possible if the data substrate is ephemeral. Without a durable, queryable, governed foundation, the loop cannot close. 3 Why Agent Memory Is a Database Workload At first blush, it may seem that agent memory can be re- duced to retrieval-augmented generation: embed text, search by nearest neighbor, and inject the results into the context window. Such a design would miss most of the workload. Beyond files: the three-tier memory model is incom- plete. Section 2 noted that production agents already main- tain persistent memory across sessions. To make the gap con- crete, consider the three tiers on which they have indepen- dently converged. Declarative memory stores durable facts and preferences—Claude Code’sCLAUDE.md[3], Hermes’s MEMORY.mdandUSER.md[32]. Procedural memory stores reusable how-to playbooks—the skills of Section 2. Episodic memory stores searchable records of past sessions—ranging from plain transcripts to SQLite-backed hybrid vector-plus- FTS5 indexes with background consolidation pipelines. Sev- eral of these systems bolt on a process that distills and prunes the tiers—Claude Code’s dreaming pipeline, OpenClaw’s three-phase consolidation, Hermes’s curator—an implicit admission that memory must evolve, not merely accumulate. These tiers are genuine engineering achievements, yet they all capture what the agent knows—facts, preferences, playbooks, and past transcripts. Long-horizon search pro- duces a fundamentally different kind of state: a reward- bearing experience graph—a causal tree of attempts, each carrying the executable artifact it produced, the tool outputs and objective reward that scored it, the sibling comparisons that say which variant won, and the mutable search statistics (visit counts, UCB scores) that the algorithm rewrites as it learns. This graph is orthogonal to the three knowledge tiers, not a replacement for them. The knowledge tiers tell each inner-loop agent how to generate a candidate; the graph records what happened when it did. Table 1 makes the struc- tural gap concrete across seven dimensions: an episodic tran- script can be searched; an experience graph can be queried, traversed, versioned, and trained from. Yet no file-based mem- ory tier has a place for this graph, and no existing agent framework exposes it as queryable, governed, shared state. In a future where agents act increasingly independently, running their own code and yielding rewards, these pro- cedural memory stores consisting of local files or single- embedded database are becoming hard to manage and con- trol centrally. This complicates querying across these data stores. Fundamentally, a unified, governed data foundation is needed in order to provide an infrastructure for independent agents to work together in harmony, all serving as workers that produce and consume a rich, integrated dataset that includes the cross-agent experience graph. To see why this is a database workload, we must consider the properties of the experience-graph data, the requirements Experience Graphs: The Data Foundation for Self-Improving AgentsCIDR’27, January 19-22, 2027, Amsterdam, The Netherlands Table 1. The structural differences between the experience graph and episodic memory Episodic memoryExperience graph Recordswhat the agent said (transcript)what search tried and how well it worked (executable artifacts + objective rewards) Structureflat text chunkstree / DAG: nodes with parent links, rewards, and siblings Retrieval FTS5 keyword / vector similaritygraph traversal (ancestor, subtree, sibling paths) + vector + structured filters Mutabilityappend-onlymutable: visit_count, ucb_score, island_id rewritten by search algorithms Time travelnoneCDC changelog→ AS-OF reconstruction at any step Trainingnot extractedSFT trajectories, DPO sibling pairs, GRPO groups as materialized views Sharingper-agent, per-machinegoverned cloud store, cross-user, cross-session Table 2. Agent operations as queries over the data foundation, and the properties and requirements each relies on: Causality, Executability, Reward (data properties); Collectivity, Governance (substrate requirements). OperationWhat the database must supportDraws on ResumeLook up a session’s frontier, pending jobs, and best node.C, R Reuse Find similar prior tasks via vector search, then retrieve their high-fitness subtrees via graph traversal.C, R, Co RepairQuery all prior failures sharing the same error signature to avoid repeating known dead ends.E, R, Co TrainExtract path trajectories, sibling preference pairs, and reward groups as materialized views.C, E, R ReplayReconstruct a node’s state as of any past step.C, E ObserveQuery search progress, reward distributions, and algorithm comparisons; render lineage graphs.C, R AuditTrace which prior attempts, tool outputs, and documents influenced a given decision.C, G Govern Enforce policy over raw traces and the artifacts derived from them—embeddings, distilled skills, and training views alike. G, Co those properties place on any substrate data foundation that holds all four tiers together, and the operations agents run against it. Data properties (of the experience graph). Three proper- ties are intrinsic to RSI traces and absent from both retrieved documents and the file-based tiers. Causality. A failed action only has value given the context of its parent plan, the tool output it reacted to, and the sibling that succeeded—a path query, not a similarity search. Executability. Memories are programs, configurations, test cases, and tool outputs—artifacts that must be replayed, diffed, and reused, not passages to be embedded. Reward. Every node carries objective feedback: cor- rectness, latency, throughput. Memory is an experience buffer [29,31] for both future search and model training—not only context for the next prompt. Substrate requirements (across all four tiers). Collectivity. One engineer’s discovery should seed ev- ery future session on a similar workload—not merely shared high-fitness starting points, but shared claims, evidence, cri- tiques, and replications that compound scientific knowledge rather than accumulate isolated data points. This applies equally to declarative facts (a distilled rule should be visible to every agent), procedural skills (a proven playbook should be reusable organization-wide), episodic history (prior fail- ures should be queryable across users), and the experience graph (prior subtrees should seed future search). Governance. Traces contain generated code, production metadata, and hardware-specific signals. Policies must apply to raw traces and derived artifacts—embeddings, distilled rules, and training examples. Governance is a cross-cutting constraint on the entire foundation: a distilled skill inherits the access policy of the episodes it was derived from, and a training view inherits the policy of the exploration nodes it materializes. Operations. Agents run eight operations against this foun- dation (Table 2). Most are queries over the experience graph; Reuse and Repair also reach across tiers, since vector search spans episodic and declarative memory. The table maps each operation to the properties and requirements it relies on. Every one of these operations is a query over the same gov- erned data foundation—there is no separate search engine, training pipeline, or observability stack. The resulting access pattern is unlike any existing work- load. Writes are a mix of appends (new nodes) and local- ized path updates (MCTS backpropagation walks the ances- tor chain to update visit counts and cumulative rewards). Reads span four modalities: ordered scans for frontier se- lection, multi-hop graph traversal for ancestor and subtree context, vector similarity for cross-session reuse, and full table scans for training-data extraction. No existing system— OLTP, OLAP, graph database, or vector store—is designed for this combination. A vector store cannot answer “which sibling approach succeeded where this one failed.” A JSON checkpoint cannot support ten concurrent workers exploring the same tree. CIDR’27, January 19-22, 2027, Amsterdam, The NetherlandsLiao, et al. 4 The Data Foundation No existing system is optimized to serve as the data founda- tion for self-improving agents. The workload demands an operational store for online search with sub-50 ms latency, a graph substrate for multi-hop traversal, and a training-data warehouse for offline learning—all over the same governed state. The architecture therefore separates a unified logical model from heterogeneous physical backends. Logical model. The experience graph and episodic history—two of the four memory tiers of Section 3—share a relational schema with a four-level hierarchy. Tasks define the problem: specification, target environment, and success metric. Sessions record who is searching, with which algorithm, and how far they have gotten. Nodes capture every individual attempt: parent link, generated artifacts, execution output, fitness score, evaluation evidence, and algorithm-specific metadata (UCB score for MCTS, genera- tion and island for evolutionary search). Prompt histories preserve the exact messages the LLM saw and produced. Task-description embeddings support vector similarity search across sessions—given a new task, the system can use these to find prior tasks with similar specifications and retrieve their best results. Large artifacts—logs, traces, binaries—live in object storage, linked by reference, keeping the relational tables lean while preserving full lineage. This four-table schema is thus algorithm-agnostic, task-agnostic, and skill-agnostic. Context as managed state. A recurring failure mode in tree search is context discontinuity: a new node re-derives what its ancestors already established, wasting tokens and reintroducing bugs that were already solved. Existing frame- works mitigate this by threading a session identifier from parent to child, or by resuming the parent’s session in place— but there the session lives in agent memory and is lost when the process exits. Trellis makes context a property of the sub- strate instead. Theprompt_historytable serves two roles: it supplies the transcript that trajectory replay requires for training, and it lets a child node either inherit its parent’s session as a cheap resume or reconstruct context from the graph through an ancestor query. Which of the two is used is a decision for the data foundation, not a constant wired into the agent. The context that justifies a node is thus durable, queryable, and shared, rather than trapped in a live process. Physical architecture: separating storage from com- pute. The architecture disaggregates a stateless query and execution engine from durable storage—the same separation that makes the agents stateless (Section 2), applied one level down. Although this architecture allows for any engine to be used, the current implementation uses Axiom [30], a cost-based optimizer over Velox [37], Meta’s open-source vectorized execution engine. Axiom plans SQL, Cypher [14], and vector retrieval into a single physical plan and routes each fragment to the backend that can serve it—an opera- tional store for sub-50 ms frontier queries, a vector index for similarity search, and a columnar warehouse for training extraction—all over one logical schema. Cypher exposes virtual parent–child edges over the foreign key, enabling traversal without a separate edge table—an approach proven effective for tree-structured metadata in distributed file sys- tems [24]—and compiles to the same engine that serves SQL, so graph and relational queries are run over the same copy of the data. Skills and memory as evolvable shared state. The pro- cedural and declarative tiers (Section 3) need to support fast reads and writes since they are consulted on nearly ev- ery inner-loop invocation, yet must change as agents learn. Trellis stores them as versioned artifacts in a distributed file system, mounted read-mostly into each stateless worker over FUSE. A worker sees an ordinary local path, while a write, such as a refined skill or a corrected fact, commits centrally. The background distillation that today rewrites a machine- localCLAUDE.mdorMEMORY.mdthus becomes a governed, audited update to shared state, with provenance linking each distilled skill back to the episodes and exploration nodes that justified it. Why a unified query layer matters. Today’s agent mem- ory retrieval stitches together three or four service calls at every step: a vector retrieval RPC, a structured-filter query, a graph traversal for context, and a scope check for gover- nance. A graph query layer with hybrid retrieval collapses these into a single optimizable statement—one round-trip instead of four, with the planner choosing join order and predicate pushdown across modalities. This is particularly important for the tree operations at the core of search—ancestor chains, subtree expansion, and sibling comparison. Walking parent pointers in application code issues푂(퐷)round-trips per lookup. Although recursive SQL operators can solve the round-trip problem, they tend to materialize every intermediate path rather than expand a frontier, and, do not currently compose with vector similarity. The Trellis graph layer instead offers first-class variable- length traversal ([:HAS_CHILD*1..k]) and path predicates, and, most importantly, fuses traversal, relational filters, and vector seeding into one planned statement. Collective intelligence via vector-seeded graph re- trieval. Vector indexes over task-description embeddings enable cross-session and cross-user knowledge reuse through a query pattern we call vector-seeded graph expansion. Given a new task, the system first retrieves semantically similar prior tasks via approximate nearest- neighbor search, then follows the relational links from matching tasks to their sessions, and from sessions to their highest-fitness exploration nodes. A graph traversal then expands each top-푘candidate into its full optimization Experience Graphs: The Data Foundation for Self-Improving AgentsCIDR’27, January 19-22, 2027, Amsterdam, The Netherlands trajectory. This pattern composes three query modalities— vector similarity, relational joins, and variable-length graph traversal—in a single logical request: MATCH (t:tasks) WHERE t.embedding <~> $q > 0.8 MATCH (t)<-[:BELONGS_TO]-(s:sessions) MATCH (s)<-[:IN_SESSION]-(n:nodes) WHERE n.is_buggy = false AND policy_allows($user, n) RETURN t.task_id, score(t), n.node_id, n.fitness_score ORDER BY score(t) DESC, n.fitness_score DESC LIMIT 10 This allows early sessions to perform the hard exploration, while later sessions can begin with the best prior solutions surfaced as reference context and refine from there. The same retrieval also runs during a session, injecting similar prior nodes step by step at a tunable rate. Thus, the more sessions the store accumulates, the less work each new one requires— a network effect at the database level. How aggressively to inject prior nodes trades off convergence against exploration, a knob we quantify in Section 6. Concurrent multi-agent search. Managing the tree in the database system allows multiple agents to explore the same session in parallel. Workers read frontier nodes, invoke the inner loop independently, and insert results. An interesting database question is what happens dur- ing backpropagation. After evaluating a node, MCTS walks the ancestor chain and updates each ancestor’s visit count and cumulative reward. When two workers backpropagate through a shared ancestor simultaneously, the visit-count increment must be atomic. Stale UCB scores may cause sub- optimal frontier selection but do not compromise correctness. In practice, the workload tolerates eventual consistency on statistics while requiring durability on node insertion—a mixed isolation profile that does not map cleanly to standard OLTP levels. Understanding the right consistency semantics for concurrent tree search is an open research question. Multi-version state and time travel. Nodes are inserted once and never deleted, but some fields are mutated in place: backpropagation rewrites visit counts and rewards along the ancestor chain, and evolution reassigns a node’s island. To avoid discarding history, Trellis captures every field-level mutation in a lightweight change log keyed by a logical step number, the evaluation order rather than wall-clock time, so that progress is comparable across machines and runs. This turns the experience graph into a multi-version object: any past state is reconstructible by replaying the log backward to a target step. Multi-version state is not merely an observability convenience—it is a correctness requirement for training. The statistics an agent acted on—the visit counts and UCB scores that drove a frontier choice—are exactly the fields backpropagation later overwrites; reconstructing a trajec- tory from final state would train the model on decisions justified by information that did not yet exist. 5 From Memory to Training Many agent systems bolt on training-data collection as an afterthought, scraping logs into a separate pipeline. That approach loses structure, provenance, and governance. In our architecture, training data is not collected—it is queried. The same node table that drives online search yields training data as materialized views. SFT trajectories. Root-to-leaf paths through non-buggy, high-fitness nodes are multi-turn agentic trajectories. The prompt_historytable preserves the exact messages the LLM saw at each step. But message fidelity is not enough: the numeric state that drove each decision—visit counts, UCB scores, island membership—is mutated in place by later search, so replaying it from final state leaks future infor- mation into the example. A faithful trajectory reads each node as of its own step, an AS-OF reconstruction over the change log of Section 4. A recursive ancestor query then reconstructs any trajectory with full provenance. DPO preference pairs [39]. Siblings with the same par- ent where one has substantially higher fitness are natural preference pairs—a graph pattern match, not a post-hoc log scrape: MATCH (p)-[:HAS_CHILD]->(a), (p)-[:HAS_CHILD]->(b) WHERE a.fitness_score > b.fitness_score + $m AND a.is_buggy = false RETURN a AS chosen, b AS rejected GRPO: database as episode buffer [42]. Rolling out a complete search tree can take hours to days; generating mul- tiple trees from the same starting point for group-relative training is prohibitively slow. The database eliminates this bottleneck. We sample a state from the persistent buffer, generate푁child candidates (a GRPO group), evaluate them in the target environment, compute group-normalized ad- vantages, train using the policy gradient, and append one canonical node back. Multi-turn rollout cost collapses to single-step expansions. Advantages are computed via SQL window functions over same-depth or same-generation co- horts. Value models over experience-graph states. The same store defines the state space for learned control of the outer loop. A value model can estimate the expected gain from expanding a given frontier node, reusing a prior subtree, merging two branches, or invoking a verifier—conditioning not on a token sequence but on graph features the database already holds: ancestor rewards, sibling diversity, failure signatures, artifact diffs, retrieval scores, visit counts, and remaining budget. The experience graph is therefore not CIDR’27, January 19-22, 2027, Amsterdam, The NetherlandsLiao, et al. only a replay buffer for policy training; it is the structured state over which future inference-time search policies are themselves learned. The closed loop. Production exploration populates mem- ory. Memory improves retrieval and frontier selection. The resulting traces train future models via SFT/DPO/GRPO [16, 39,42]. Improved models produce higher-quality attempts. The flywheel compounds: more users→more states→ better RL→better models→better exploration→higher- quality states. Every production session is simultaneously a serving operation and a training-data generation pipeline— because both are views over the same governed store. This coupling raises a governance question: when a source node is retracted or invalidated, the training examples derived from it must be retracted too. The data foundation must propagate these retractions through materialized views while respect- ing access policies that may differ between the source trace and its derivatives. 6 Early Measurements KernelEvolve [26–28], built on Trellis, optimizes accelera- tor kernels across four hardware platforms (NVIDIA, AMD, MTIA, CPU). Its data foundation has accumulated a substan- tial corpus of experience graphs spanning many tasks and sessions. We report preliminary results across three dimen- sions; a fuller evaluation is left to future work. Recovery and statelessness. In the prior in-memory ar- chitecture, a crashed session lost all progress. With database- native state, any worker resumes from the last committed node: recovery is a frontier query rather than checkpoint deserialization, with no warm-up and nothing pinned to the failed machine. In production, sessions that hit infrastructure failures resume automatically on another worker with no lost nodes—durability we never engineered as a feature but inherited from putting the state in the database. Cross-session reuse. Cross-session memory embeds each task description and node analysis, retrieves semantically similar prior tasks and nodes, and injects them as reference context during exploration; the injection rate푝is a tunable knob. Holding the model, step budget (100 steps), worker count, and greedy search strategy fixed, we compared no memory against푝=0.1 and푝=0.5 over∼100-node sessions (Figures 3–4). All figures are averaged over three indepen- dent sessions per configuration to control for the high vari- ance of LLM sampling, and the trends reported below were consistent across runs. Memory cuts the buggy-node rate from 55% to 34% (푝=0.1) and 21% (푝=0.5), raises the frac- tion of valid nodes meeting the baseline speedup from 79.5% to 90.8% and 100%, and reaches a 1.2×speedup within∼5 steps versus 51 for a cold start—a 10×acceleration. Because buggy nodes trigger expensive debug-retry loops, avoiding Baseline (no memory)CS p=0.1CS p=0.5 best fitness so far (speedup) 0 0.5 1.0 1.2 1.5 1.2× threshold 1251020305075100 evaluated step memory clears 1.2× by ~step 5 baseline: step 51 Figure 3. Best fitness over evaluated steps. Both memory settings clear 1.2×within∼5 steps; the no-memory base- line takes 51 steps—a 10×early-convergence improvement. Memory converges fast but plateaus early; the baseline keeps climbing and eventually reaches the single best point (1.49×), illustrating the exploration–anchoring tradeoff that the in- jection policy must manage (Section 7). Valid (non-buggy)Buggy — triggers debug-retry Baseline 44 valid55 buggy55% CS p=0.1 65 valid34 buggy34% CS p=0.5 78 valid2121% 0 2550 75100 Figure 4. Valid versus buggy nodes per configuration (of ∼100 each). The baseline wastes 55% of compute on buggy nodes; cross-session memory cuts that to 34% (푝=0.1) and 21% (푝=0.5). Because each buggy node triggers an expensive debug-retry loop, this failure reduction drives the 52% token- cost saving. them cuts tokens per valid node by 52%, even though each individual step costs the same. These gains come with a tradeoff the architecture must expose rather than hide. Higher injection makes search more consistent (lower variance, fewer bugs) but more anchored: at푝=0.5 the agent collapses onto 8 strategy combinations versus 20 for a cold start, and the single best solution comes from no memory (1.49×versus 1.36×). The balanced setting 푝=0.1 retains most of the convergence win while producing the most high-quality (≥1.3×) solutions. Memory accelerates and stabilizes search, but unbounded reuse suppresses the diversity that finds the best answers—making the injection policy a first-class tuning question for any memory-backed agent (Section 7). Training data without re-rollout. Every production ses- sion leaves behind complete multi-turn trajectories, so train- ing data—SFT paths, DPO sibling pairs, GRPO cohorts—is extracted as queries over the same store rather than produced Experience Graphs: The Data Foundation for Self-Improving AgentsCIDR’27, January 19-22, 2027, Amsterdam, The Netherlands by a separate pipeline (Section 5). The payoff is wall-clock. The multi-turn rollout that dominates agentic RL—where a single search tree takes hours to days and group-relative methods need many from the same state—collapses into reuse of trajectories the store already holds, plus single-step expansions from a sampled state when fresh samples are needed. Every production run is thus simultaneously a serv- ing operation and a training-data generator, with full prove- nance (task, hardware, session, algorithm) attached. 7 Beyond Kernels and Research Agenda KernelEvolve is one instance of a general pattern, and we have already exercised that generality. We retargeted the same Trellis foundation from optimizing machine learning kernels to validating MTIA silicon hardware—a different ap- plication use case entirely—by changing only the fitness function and the skills. Instead of rewarding speedup, the agent is incentivized for finding bugs—a mismatch between the silicon simulator and the golden reference scores high while a clean pass scores zero. The skills now describe the in- struction set architecture (ISA), known errata, and coverage- guided bug-hunting strategies; cross-session memory tracks an ISA coverage matrix so each session targets the gaps left by prior ones, and self-evolving search expands a single bug into a family across dtypes, shapes, and hardware units. The experience graph, query layer, search orchestration, train- ing views, and observability carried over unchanged—the infrastructure is domain-agnostic, and the domain is just a skill. We have exercised this silicon-validation configuration end to end. Drug discovery, chip floorplanning, compiler optimization, and automated scientific research [7,36] share the same structure—tree-structured exploration traces with objective rewards. Query planning for multi-modal composition. Vector- seeded graph expansion (Section 4) composes vector similar- ity, relational joins, and variable-length graph traversal in a single logical request. No existing query planner has a cost model for this composition: the vector index’s selectivity determines the join fan-out, which determines the traversal cost, but no system maintains cross-modal statistics [2,21]. Building a planner that reasons across these three stages is an open problem. Consistency for concurrent tree search. As discussed in Section 4, MCTS backpropagation is a multi-hop read- then-write that tolerates eventual consistency on statistics but requires durability on node insertion. Formalizing the right isolation level for this mixed profile—and proving that relaxed consistency does not degrade search quality beyond a bounded factor—is a question the database community is well-equipped to answer. Physical design. The workload combines appends, path updates, ordered reads, multi-hop traversals, vector similar- ity, and full scans. No existing physical design—row store, column store, LSM tree, or graph-native storage—is opti- mized for this combination [44,45]. What indexing and lay- out strategies minimize total cost across all access patterns? Governed view maintenance. Training views are materi- alized from operational state (Section 5). When a source node is retracted, all derived training examples must be invalidated—a view-maintenance problem under governance constraints where access policies may differ between the source trace and its derivatives [14, 37]. Retrieval policy and memory quality. Section 6 showed that how much prior memory to inject is a tunable knob with a sharp tradeoff: more reuse converges faster and fails less, but anchors the search and suppresses the diversity that finds the best solutions. This is a retrieval-planning and data-quality problem in disguise. What is the right in- jection policy—fixed, decayed over a session, or chosen per query from the selectivity and confidence of the match? How should the store score memory quality, detect stale or low- quality entries that would reinforce past mistakes [12], and keep retrieval fresh as hardware and workloads drift? Treat- ing reuse as a cost-based, quality-aware retrieval decision rather than a fixed heuristic is an open problem the database community is well-positioned to tackle. Bi-temporal memory. The change log of Section 4 ver- sions exploration state along a single axis—evaluation order— which already supports time travel over a search. Full bi- temporal semantics add a second axis, separating valid time (when a fact was true) from transaction time (when the entry was committed), unlocking late-arriving corrections, memory-drift detection across environment changes, and distillation audit (“what did the agent know at time푇, and was it still true?”). Lifting versioning from a field-level log to first-class temporal predicates in the query layer—and plan- ning queries that range over both axes—is an open problem. Learned control over experience graphs. A database of experience graphs turns the outer loop from a fixed search heuristic into a policy learned from accumulated experience. Value models over graph state (Section 5) can predict which frontier node, retrieved subtree, verifier call, or repair is worth the next unit of compute, making the database the state representation for inference-time control. What graph features, freshness guarantees, and training objectives such a controller needs—and how to serve its predictions within the agent loop’s latency budget—are open questions. From parallel search to scientific societies. The concur- rent search model in Section 4 treats agents as independent workers over a shared tree. A more ambitious design orga- nizes agents as a scientific society: ideator agents propose CIDR’27, January 19-22, 2027, Amsterdam, The NetherlandsLiao, et al. hypotheses, builder agents implement them, reviewer agents critique results and request replications, and distiller agents consolidate lessons into reusable memory. Each institution in this society—a leaderboard that separates score from con- fidence, an idea store whose claims carry state machines (proposed→tested→replicated→distilled), a structured forum for evidence-linked peer review, and a scheduler that converts disagreement into compute allocation—maps to database tables, state transitions, and queries. The data foun- dation becomes the institutional infrastructure for collective intelligence. Designing the transactional semantics, consis- tency models, and governance policies for such multi-agent institutions is, we believe, among the most consequential open problems at the intersection of databases and AI. 8 Related Work Trellis sits at the intersection of agent memory, recursive self- improvement, graph/vector data management, and training- data infrastructure. Agent memory systems. MemGPT [35] introduced the OS analogy—paging information between fast (in-context) and slow (external) memory—establishing that agents need a memory hierarchy, not just a larger window. Trellis takes the complementary database analogy: MemGPT is a trans- port layer; Trellis is the storage engine underneath—how you structure, index, query, version, and govern the data that lives outside context. Dedicated agent-memory services such as Mem0 [8] add structured long-term memory; Graphiti [40] goes further with a temporal knowledge graph that dynami- cally synthesizes conversational data—the closest prior work in spirit, though aimed at enterprise memory rather than RSI experience graphs and without CDC, materialized train- ing views, or a graph-native query layer. Production coding agents have moved further still with declarative facts, pro- cedural skills, and episodic transcripts (Section 3), yet these remain per-agent local files or embedded databases with no cross-user query and no governance. A recent comprehen- sive survey [19] calls for treating memory as a “first-class primitive”—precisely Trellis’s thesis, which the survey moti- vates but does not realize as a database system. Recursive self-improvement systems.AlphaE- volve [33], FunSearch [41], AIDE [20], AIRA [47], the AI Scientist [49], and open frameworks such as OpenEvolve [1] show that long-horizon exploration can produce valuable results, building on code-generation foundations [7] and multi-agent simulation [36]. All keep their traces as appli- cation state—Python objects and JSON checkpoints. Trellis treats those traces as the primary database workload. Experiment tracking and ML metadata. Run trackers such as MLflow [51] and ModelDB [48], and dataset/metadata catalogs such as Google Goods [17], record runs, hyperparameters, metrics, and artifact lineage, and might appear to already cover the experience graph. They do not. These are offline, sidecar registries that log metrics about runs after the fact. They do not serve the online, sub-50 ms frontier queries that drive an agent’s next step; they do not model the mutable search statistics (visit counts, UCB scores) that search rewrites in place; they offer no as-of reconstruction of the state an agent acted on; and they provide no graph-native ancestor/sibling traversal fused with vector retrieval. Trellis is the operational store that drives search and materializes training views from the same state, not a record of experiments past. Agent orchestration. Meta-harness systems such as Om- nigent [52] lift orchestration above individual harnesses, providing multi-agent composition, policy governance, and real-time collaboration. Sakana Fugu [15] trains an orches- trator to dynamically compose agentic scaffolds over a pool of frontier workers, with inter-workflow shared memory and GRPO-based training—demonstrating that multi-agent coordination increasingly requires persistent, shared state. These systems validate the need for a shared layer above agents but operate at the control plane—session routing, cost budgets, cross-vendor review. The data plane—how to per- sist, query, version, and train from the exploration state these agents produce—remains unaddressed and is precisely the gap Trellis fills. Graph/vector data management. Graph databases [2] and Cypher [14] provide the language of paths and neigh- borhoods. Vector indexes [21] provide semantic retrieval. The Trellis workload needs both at once, composed with structured filters, transactional updates, and temporal recon- struction. Its contribution is not a new graph language or a new vector index, but the composition required by agent memory. RL data and temporal databases. Experience replay [29, 31], DPO [39], and GRPO [42] motivate the training views. The database contribution is provenance and fidelity: exam- ples are extracted from the operational store with rewards, siblings, trajectories, and AS-OF state rather than scraped after the fact. Temporal databases, MVCC, and CDC provide the historical lineage for the time-travel design. Trellis ap- plies those old ideas to a new object: the mutable search state of a self-improving agent. 9 Conclusion Self-improving agent memory is a database problem. Larger models and longer context windows will not solve it. What self-improving agents need is a durable, governed data foun- dation where the experience graph—every artifact, reward, decision, and causal link—lives as queryable, shared, training- ready state. We design, implement, and demonstrate Trellis for long-horizon agentic coding tasks, running in production. The properties that matter most—crash recovery, horizontal scaling, cross-user reuse, and training-view materialization— are addressed by an application-specific database design Experience Graphs: The Data Foundation for Self-Improving AgentsCIDR’27, January 19-22, 2027, Amsterdam, The Netherlands rather than engineered as one-off features. But the deeper prize is not infrastructure efficiency; it is collective intelli- gence. Today’s self-improving systems are individual agents searching alone over private trees. The architecture we de- scribe makes it possible for populations of agents to share structured knowledge, critique each other’s results, and com- pound discoveries across sessions, users, and time. When the data foundation becomes the institutional infrastructure for multi-agent scientific societies—with leaderboards, struc- tured peer review, and governed distillation—the result is not just agents that remember but agents that learn as a community. The decades of research in databases have defined clean, functional interfaces and system architectures for transac- tions, warehousing, streaming, and graphs that power the Internet. Agentic memory is the next wave of workloads, demanding new interfaces and database designs, thereby shaping the future of AI. Logs made databases reliable; expe- rience graphs may make agents cumulative. Acknowledgments We thank Jia Jiunn Ang, Ming Chen, Barry Dong, Amit Dutta, Yuanwei Fang, Zacharias Fisches, Vishal Gandhi, Ali- cia Golden, Chanoch Goldfeder, Wei Guo, Samuel Hsia, Ro- hit Jain, Jacob Kahn, Michael Kuchnik, Richard Li, Yiting Li, Jimmy Lu, Keyur Muzumdar, Michael Norris, Dmitrii Ped- chenko, Honghao Qiu, Andrii Rosa, Shiqin Wang, Ruichao Xiao, Chao Xie, Yavuz Yetim, Hongtao Yu, and Roger Zheng for discussions and feedback that helped shape the systems agenda in this paper. References [1] Algorithmic Superintelligence Inc. 2025.OpenEvolve: Open- Source Evolutionary Coding Agent.https://github.com/ algorithmicsuperintelligence/openevolve. [2]Renzo Angles, Marcelo Arenas, Pablo Barceló, Aidan Hogan, Juan Reutter, and Domagoj Vrgoč. 2017. An Introduction to Graph Data Management. Springer (2017). [3]Anthropic. 2025. Claude Code: An Agentic Coding Tool. https://docs. anthropic.com/en/docs/claude-code. [4] Anthropic. 2025. Project Glasswing: Securing Critical Software for the AI Era. https://w.anthropic.com/glasswing. [5]Cameron B. Browne, Edward Powley, Daniel Whitehouse, Simon M. Lucas, Peter I. Cowling, Philipp Rohlfshagen, Stephen Tavener, Diego Perez, Spyridon Samothrakis, and Simon Colton. 2012. A Survey of Monte Carlo Tree Search Methods. IEEE Transactions on Computational Intelligence and AI in Games 4, 1 (2012), 1–43. [6] Nicholas Carlini. 2026. Building a C Compiler with a Team of Par- allel Claudes. https://w.anthropic.com/engineering/building-c- compiler. [7] Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al.2021. Evaluating Large Language Models Trained on Code. arXiv preprint arXiv:2107.03374 (2021). [8]Prateek Chhikara, Dev Khant, Saket Aryan, Taranjeet Singh, and Deshraj Yadav. 2025. Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory. arXiv preprint arXiv:2504.19413 (2025). [9]Joel Coburn, Chunqiang Tang, Sameer Abu Asal, Neeraj Agrawal, Raviteja Chinta, Harish Dixit, Brian Dodds, Saritha Dwarakapuram, Amin Firoozshahian, Cao Gao, et al.2025. Meta’s Second Generation AI Chip: Model-Chip Co-Design and Productionization Experiences. In Proceedings of the 52nd Annual International Symposium on Computer Architecture. 1689–1702. [10] James C Corbett, Jeffrey Dean, Michael Epstein, Andrew Fikes, Christo- pher Frost, Jeffrey John Furman, Sanjay Ghemawat, Andrey Gubarev, Christopher Heiser, Peter Hochschild, et al.2013. Spanner: Google’s Globally Distributed Database. ACM Transactions on Computer Systems (TOCS) 31, 3 (2013), 1–22. [11]Benoit Dageville, Thierry Cruanes, Marcin Zukowski, Vadim Antonov, Artin Avanes, Jon Bock, Jonathan Claybaugh, Daniel Engovatov, Mar- tin Hentschel, Jiansheng Huang, et al.2016. The snowflake elastic data warehouse. In Proceedings of the 2016 International Conference on Management of Data. 215–226. [12]Databricks AI Research Team. 2026. Memory Scaling for AI Agents. https://w.databricks.com/blog/memory-scaling-ai-agents. [13]Marina Favaro and Jack Clark. 2026. When AI Builds Itself. https:// w.anthropic.com/institute/recursive-self-improvement. Anthropic Institute, 2026. [14]Nadime Francis, Alastair Green, Paolo Guagliardo, Leonid Libkin, To- bias Lindaaker, Victor Marsault, Stefan Plantikow, Mats Rydberg, Pe- tra Selmer, and Andrés Taylor. 2018. Cypher: An Evolving Query Language for Property Graphs. Proceedings of the 2018 International Conference on Management of Data (SIGMOD) (2018), 1433–1445. [15]Fugu Team, Sakana AI. 2026. Sakana Fugu Technical Report. Technical Report. June 2026. [16] Daya Guo, Dejian Yang, He Zhang, Junxiao Song, Runxin Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al.2025. DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Rein- forcement Learning. arXiv preprint arXiv:2501.12948. [17]Alon Halevy, Flip Korn, Natalya F. Noy, Christopher Olston, Neoklis Polyzotis, Sudip Roy, and Steven Euijong Whang. 2016. Goods: Or- ganizing Google’s Datasets. In Proceedings of the 2016 International Conference on Management of Data (SIGMOD). ACM, New York, NY, USA, 795–806. [18]Joseph M. Hellerstein, Jose Faleiro, Joseph E. Gonzalez, Johann Schleier- Smith, Vikram Sreekanti, Alexey Tumanov, and Chenggang Wu. 2019. Serverless Computing: One Step Forward, Two Steps Back. In Confer- ence on Innovative Data Systems Research (CIDR). [19] Yuyang Hu, Shichun Liu, Yanwei Yue, Guibin Zhang, Boyang Liu, et al. 2025. Memory in the Age of AI Agents: A Survey—Forms, Functions and Dynamics. arXiv preprint arXiv:2512.13564 (2025). [20]Zhengyao Jiang, Dominik Schmidt, Dhruv Srikanth, Dixing Xu, Ian Kaplan, Deniss Jacenko, and Yuxiang Wu. 2025. AIDE: The Machine Learning Engineer Agent. arXiv preprint arXiv:2502.13138 (2025). [21]Jeff Johnson, Matthijs Douze, and Hervé Jégou. 2019. Billion-Scale Similarity Search with GPUs. IEEE Transactions on Big Data 7, 3, 535–547. [22]Andrej Karpathy. 2026. autoresearch. https://github.com/karpathy/ autoresearch. [23] Levente Kocsis and Csaba Szepesvári. 2006. Bandit Based Monte- Carlo Planning. In European Conference on Machine Learning. Springer, 282–293. [24]Gang Liao and Daniel J. Abadi. 2023. FileScale: Fast and Elastic Meta- data Management for Distributed File Systems. In Proceedings of the 2023 ACM Symposium on Cloud Computing (SoCC). 459–474. [25]Gang Liao, Amol Deshpande, and Daniel J Abadi. 2023. Flock: A Low-Cost Streaming Query Engine on FaaS Platforms. arXiv preprint arXiv:2312.16735 (2023). [26]Gang Liao, Hongsen Qin, Ying Wang, Alicia Golden, Michael Kuchnik, Yavuz Yetim, Jia Jiunn Ang, Chunli Fu, Yihan He, Samuel Hsia, Zewei Jiang, Dianshi Li, Liyuan Li, Uladzimir Pashkevich, Varna Puvvada, CIDR’27, January 19-22, 2027, Amsterdam, The NetherlandsLiao, et al. Feng Shi, Matt Steiner, Ruichao Xiao, Nathan Yan, Xiayu Yu, Zhou Fang, Roman Levenstein, Kunming Ho, Haishan Zhu, Alec Hammond, Richard Li, Ajit Mathews, Kaustubh Gondkar, Abdul Zainul-Abedin, Ketan Singh, Hongtao Yu, Wenyuan Chi, Barney Huang, Sean Zhang, Noah Weller, Zach Marine, Wyatt Cook, Carole-Jean Wu, and Gaoxiang Liu. 2026. KernelEvolve: Scaling Agentic Kernel Coding for Heteroge- neous AI Accelerators at Meta. arXiv preprint arXiv:2512.23236 (2026). Meta Technical Report. [27]Gang Liao, Hongsen Qin, Ying Wang, Alicia Golden, Michael Kuch- nik, Yavuz Yetim, Ruichao Xiao, Jia Jiunn Ang, Chunli Fu, Yihan He, Samuel Hsia, Zewei Jiang, Roman Levenstein, Dianshi Li, Liyuan Li, Ajit Mathews, Varna Puvvada, Feng Shi, Nathan Yan, Xiayu Yu, Uladz- imir Pashkevich, Matt Steiner, Carole-Jean Wu, and Gaoxiang Liu. 2026. KernelEvolve: Scaling Agentic Kernel Coding for Heteroge- neous AI Accelerators at Meta. In Proceedings of the 52nd International Symposium on Computer Architecture (ISCA). [28]Gang Liao, Yavuz Yetim, Ruichao Xiao, Zewei Jiang, Raghav Boinepalli, Sheela Yadawad, Liyuan Li, Nathan Yan, Ajit Mathews, Chunqiang Tang, Carole-Jean Wu, and Gaoxiang Liu. 2026.KernelEvolve: How Meta’s Ranking Engineer Agent Optimizes AI Infrastructure. https://engineering.fb.com/2026/04/02/developer-tools/kernelevolve- how-metas-ranking-engineer-agent-optimizes-ai-infrastructure/. [29]Long-Ji Lin. 1992. Self-Improving Reactive Agents Based on Rein- forcement Learning, Planning and Teaching. Machine Learning 8, 3–4 (1992), 293–321. [30]Meta Platforms. 2025. Axiom: A Cost-Based Optimizer for Multi-Modal Query Planning. https://github.com/facebookincubator/axiom. Open source. [31] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, An- dreas K. Fidjeland, Georg Ostrovski, et al.2015. Human-Level Control Through Deep Reinforcement Learning. Nature 518, 7540 (2015), 529– 533. [32]Nous Research. 2025.Hermes Agent.https://hermes-agent. nousresearch.com/docs. [33] Alexander Novikov, Ngân V ̃ u, Marvin Eisenberger, Emilien Dupont, Po-Sen Huang, Adam Zsolt Wagner, Sergey Shirobokov, Borislav Ko- zlovskii, Francisco J. R. Ruiz, Abbas Mehrabian, M. Pawan Kumar, Abigail See, Swarat Chaudhuri, George Holland, Alex Davies, Sebas- tian Nowozin, Pushmeet Kohli, and Matej Balog. 2025. AlphaEvolve: A Coding Agent for Scientific and Algorithmic Discovery. arXiv preprint arXiv:2506.13131 (2025). [34]OpenAI. 2025. Codex: A Cloud-Based Software Engineering Agent. https://openai.com/index/introducing-codex/. [35]Charles Packer, Sarah Wooders, Kevin Lin, Vivian Fang, Shishir G. Patil, Ion Stoica, and Joseph E. Gonzalez. 2023. MemGPT: Towards LLMs as Operating Systems. arXiv preprint arXiv:2310.08560 (2023). [36]Joon Sung Park, Joseph C. O’Brien, Carrie J. Cai, Meredith Ringel Morris, Percy Liang, and Michael S. Bernstein. 2023. Generative Agents: Interactive Simulacra of Human Behavior. In Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology (UIST). [37] Pedro Pedreira, Orri Erling, Masha Basmanova, Kevin Wilfong, Laith Sakka, Krishna Pai, Wei He, and Biswapesh Chattopadhyay. 2022. Velox: Meta’s Unified Execution Engine. Proceedings of the VLDB Endowment 15, 12 (2022), 3372–3384. [38] Alberto Pepe, Chien-Yu Lin, Despoina Magka, Bilge Acun, Yannan Nel- lie Wu, Anton Protopopov, Carole-Jean Wu, and Yoram Bachrach. 2026. Agentic Discovery of Neural Architectures: AIRA-Compose and AIRA-Design. arXiv preprint arXiv:2605.15871 (2026). [39] Rafael Rafailov, Archit Sharma, Eric Mitchell, Stefano Ermon, Christo- pher D. Manning, and Chelsea Finn. 2023. Direct Preference Optimiza- tion: Your Language Model Is Secretly a Reward Model. In Advances in Neural Information Processing Systems. [40] Preston Rasmussen, Pavlo Paliychuk, Travis Beauvais, Jack Ryan, and Daniel Chalef. 2025. Graphiti: Building Real-Time Knowledge Graphs for AI Agents. arXiv preprint arXiv:2501.13956 (2025). [41]Bernardino Romera-Paredes, Mohammadamin Barekatain, Alexander Novikov, Matej Balog, M. Pawan Kumar, Emilien Dupont, Francisco J. R. Ruiz, Kai Olav Ellefsen, et al.2024. Mathematical Discoveries from Program Search with Large Language Models. In Nature, Vol. 625. 468–475. [42]Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Mingchuan Zhang, Y. K. Li, Y. Wu, and Daya Guo. 2024. DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models. arXiv preprint arXiv:2402.03300 (2024). [43]David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al.2017. Mastering the Game of Go Without Human Knowledge. Nature 550, 7676 (2017), 354–359. [44]Michael Stonebraker, Daniel J. Abadi, Adam Batkin, Xuedong Chen, Mitch Cherniack, Miguel Ferreira, Edmond Lau, Amerson Lin, Sam Madden, Elizabeth O’Neil, Pat O’Neil, Alex Rasin, Nga Tran, and Stan Zdonik. 2005. C-Store: A Column-Oriented DBMS. In Proceedings of the 31st International Conference on Very Large Data Bases (VLDB). 553–564. [45]Michael Stonebraker and Ugur Çetintemel. 2005. “One Size Fits All”: An Idea Whose Time Has Come and Gone. Proceedings of the 21st International Conference on Data Engineering (ICDE) (2005), 2–11. [46]John Sviokla. 2026. The Most Important Idea in AI: Recursive Self- Improvement (RSI). https://w.forbes.com/sites/johnsviokla/2026/ 03/16/the-most-important-idea-in-ai-recursive-self-improvement- rsi/. Forbes, March 2026. [47] Edan Toledo, Karen Hambardzumyan, Martin Josifoski, Rishi Hazra, Nicolas Baldwin, Alexis Audran-Reiss, Michael Kuchnik, Despoina Magka, Minqi Jiang, Alisia Maria Lupidi, Andrei Lupu, Roberta Raileanu, Kelvin Niu, Tatiana Shavrina, Jean-Christophe Gagnon- Audet, Michael Shvartsman, Shagun Sodhani, Alexander H. Miller, Abhishek Charnalia, Derek Dunfield, Carole-Jean Wu, Pontus Stene- torp, Nicola Cancedda, Jakob Nicolaus Foerster, and Yoram Bachrach. 2025. AI Research Agents for Machine Learning: Search, Exploration, and Generalization in MLE-bench. arXiv preprint arXiv:2507.02554 (2025). [48] Manasi Vartak, Harihar Subramanyam, Wei-En Lee, Srinidhi Viswanathan, Saadiyah Husnoo, Samuel Madden, and Matei Zaharia. 2016. ModelDB: A System for Machine Learning Model Management. In Workshop on Human-In-the-Loop Data Analytics (HILDA). ACM, New York, NY, USA. [49]Yutaro Yamada, Robert Tjarko Lange, Cong Lu, Shengran Hu, Chris Lu, Jakob Foerster, Jeff Clune, and David Ha. 2025. The AI Scientist- v2: Workshop-Level Automated Scientific Discovery via Agentic Tree Search. arXiv preprint arXiv:2504.08066 (2025). [50] Justin Young. 2025.Effective Harnesses for Long-Running Agents. https://w.anthropic.com/engineering/effective-harnesses- for-long-running-agents. Anthropic Engineering, November 2025. [51]Matei Zaharia, Andrew Chen, Aaron Davidson, Ali Ghodsi, Sue Ann Hong, Andy Konwinski, Siddharth Murching, Tomas Nykodym, Paul Ogilvie, Mani Parkhe, Fen Xie, and Corey Zumar. 2018. Accelerating the Machine Learning Lifecycle with MLflow. IEEE Data Engineering Bulletin 41, 4 (2018), 39–45. [52] Matei Zaharia, Kasey Uhlenhuth, and Corey Zumar. 2026. Intro- ducing Omnigent: A Meta-Harness to Combine, Control and Share Your Agents. https://w.databricks.com/blog/introducing-omnigent. Databricks, June 2026. [53] Zhipu AI. 2026. GLM-5.2: Built for Long-Horizon Tasks. https://z.ai/ blog/glm-5.2. June 2026.

Instant research discovery