WorksComputer Science
OpenKAGE: Open-Ended Lifelong Learning in the Open World via Knowledge-Sharing Agent-Group Evolution
Abstract
Building autonomous agents that continually explore open worlds and acquire new capabilities through experience is a long-standing aspiration in artificial intelligence. Existing research often pursues lifelong learning within predefined tasks, curricula, or objectives, with self-improvement largely confined to individual agents. We introduce OpenKAGE, an agent-group evolution framework for open-ended lifelong learning. Within this framework, agents autonomously explore open worlds and continually acquire new capabilities by accumulating and reusing knowledge from their own interactions and the experience of others. OpenKAGE builds on two key mechanisms: (1) a two-layer knowledge representation, with a memory layer for situated memories and an experience layer for transferable experience and skills that retains the applicability conditions needed for reuse; and (2) a knowledge-sharing mechanism that semantically consolidates textual experience into a continuously evolving shared knowledge graph, while executable skills are shared verbatim. In Minecraft, OpenKAGE supports open-ended lifelong learning, enabling agent groups to sustain exploration and reach advanced technological milestones. Furthermore, the accumulated knowledge can be transferred to a newly initialized agent group on a different backbone model, improving its survival and exploration progress.
Introduction
We study open-ended lifelong learning as a continuing process in which agents autonomously generate goals, accumulate knowledge from interaction, and reuse that knowledge to acquire new capabilities. Unlike learning toward a fixed terminal task, this process is not organized around a predefined endpoint. A suggestive image comes from The Wild Robot: cast ashore on an unfamiliar island with only her built-in directives, Roz learns to coexist with the wildlife and, by raising an orphaned gosling, comes to belong to the island. Future autonomous agents may likewise enter physical or digital worlds carrying only system-level directives, and must confront unfamiliar phenomena, discover new things to do, and devise new strategies without human intervention …
Toward this vision, substantial progress has been made in enabling agents to learn and act in open worlds. Reinforcement and imitation learning support long-horizon control [2, 5], while LLM-based agents combine planning, memory, and reflection to tackle increasingly complex tasks (Zhu et al., 2023; Wang et al., 2025; Shinn et al., 2023). Systems such as Voyager, Optimus-1, and AriGraph further demonstrate how reusable skills, structured experience, and knowledge graphs can support knowledge accumulation and reuse [1] (Wang et al. 2024; Li et al. 2024). Despite these advances, much of the research remains organized around predefined tasks, curricula, or objectives, with self-improvement largely confined to individual agents. Although systems such as Voyager support autonomous exploration, an individual agent still learns primarily from its own interactions, limiting the range of experience available to guide its development. Open-endedness research does generate new challenges rather than fixing them, by co-evolving environments with their solvers or by asking a foundation model which tasks are interesting (Wang et al., 2019; Zhang et al., 2023), but this concerns what a single learner pursues next. Knowledge acquired by one agent does not automatically become available to others. This motivates moving beyond individual learning toward agent-group evolution, where experience acquired through diverse interactions can contribute to a shared, growing body of knowledge.
Figure 1. Open-ended lifelong learning through shared knowledge in OpenKAGE. Agents explore separate Minecraft worlds and keep situated memories local; transferable experience, with its applicability conditions, is consolidated into a shared knowledge graph, and executable skills are shared verbatim. The bottom strip illustrates milestones, not a prescribed curriculum.
Learning from others offers a natural route from individual learning to collective improvement. CAMEL and MetaGPT enable agents to collaborate through role-based communication and structured workflows [6] (Li et al. 2023), while Generative Agents combines memory, reflection, and social interaction to support information diffusion and coordination (Park et al., 2023). More directly, Group-Evolving Agents (GEA) shares evolutionary traces across agents and turns them into framework-level improvements through reflection (Weng et al., 2026). Memory systems such as G-Memory and LLMA-Mem keep shared memory across LLM agents (Zhang et al., 2025; Wu et al., 2026), and selective-sharing methods pass only chosen experiences or policy modules between agents [4] (Nath et al. 2026). These approaches demonstrate different ways for agents to benefit from one another, from coordinating actions to improving their own implementations or sharing memory and experience, though most are evaluated with tasks given in advance. For open-ended lifelong learning, we focus on a complementary challenge: how to turn knowledge acquired through individual interactions into a shared resource that supports continued exploration and capability acquisition across the group. This calls for distinguishing memories tied to an agent’s particular circumstances from experience that can be reused by others, and continually consolidating the latter as agents explore and learn.
To this end, we introduce OpenKAGE, an agent-group evolution framework for open-ended lifelong learning (Figure 1). OpenKAGE enables agents to autonomously explore open worlds and continually acquire capabilities by accumulating and reusing knowledge from their own interactions and the experience of others. Two mechanisms underpin this process. First, a two-layer knowledge representation separates private situated memories from transferable experience and skills, retaining the applicability conditions needed for reuse across agents. Second, a knowledge-sharing mechanism semantically consolidates textual experience into a continuously evolving shared knowledge graph, while executable skills are shared verbatim and remain maintained by their authors. Situated memories remain private, while transferable knowledge becomes a cumulative resource for the group rather than remaining isolated within individual agents. To bring this accumulated knowledge into subsequent decisions, intent-aware subgraph retrieval draws relevant knowledge from both the agent’s local graph and the shared graph to support its ongoing exploration.
We evaluate OpenKAGE in Minecraft, where agents must survive, explore, and develop increasingly advanced capabilities through sustained interaction with an open world. Starting with empty knowledge stores, agents accumulate and share knowledge acquired through their own exploration. Across four backbone models, OpenKAGE supports sustained exploration and progression to advanced technological milestones, obtaining obsidian on all four and entering the Nether on three, while reducing deaths relative to the planner-only control; on the default backbone it also outperforms Voyager and an Echo baseline, neither of which reaches obsidian or the Nether within the evaluated horizon. Furthermore, knowledge accumulated by one group can be transferred to a newly initialized group using a different backbone model, substantially improving its survival and exploration progress. Together, these results show that knowledge accumulated through individual interactions supports continued learning within a group and capability acquisition by new agents.
OpenKAGE
Overview
OpenKAGE enables a group of agents to accumulate and reuse knowledge from their individual interactions with an open world (Figure 2). Each agent interacts with a separate Minecraft world instance, and agents exchange knowledge rather than in-world messages or resources. Each agent runs a ReAct loop organized into game-day cycles ((Yao et al., 2023)), using a planner to act and a reflector to separate situated memories from transferable experience; an aggregator merges experience-layer knowledge into the shared graph, semantically consolidating textual experience records and adding executable skills verbatim as isolated nodes; an intent-aware retriever supplies relevant subgraphs to the planner. This subsection describes how these pieces operate over time.
Figure 2. OpenKAGE overview. Each agent’s local graph has a private memory layer and a shareable experience layer; only experience-layer records leave it. Textual records are consolidated into the shared graph every days, and skills enter it verbatim under their authors’ names. An intent-aware retriever serves the planner. Schematic; agents receive text observations, not images.
Planner. During each game-day cycle, the agent alternates between thinking, acting, and observing. Each morning it sets a plan for the day (a goal and ordered steps); planning with a goal triggers retrieval from the agent’s own graph and the shared graph, so the day’s work is informed by previously accumulated group knowledge. The agent then acts by writing short asynchronous JavaScript programs, one program per step, over the environment’s low-level native Mineflayer API (pathfind-and-move, dig, place, craft, equip, …). The API provides no task-level routines for gathering, smelting, or shelter construction; packaging them into skills is precisely the agents’ job. Executed programs return structured observations (position, health, inventory, nearby entities and blocks, time, advancements). Following Wang et al. (2024), code is the action space: programs are temporally extended, compositional, and directly executable.
Figure 3. Operation in game-day cycles. Left: structured observation and execution feedback (schematic). Right: within each 24,000-tick day the planner alternates between thinking, acting, and observing; at dawn the world pauses for reflection, and aggregation runs every days.
Reflector. At the end of each game-day cycle (at dawn), the world pauses and the agent reflects on the elapsed day in two phases. The first re-reads the day’s trajectory and writes both layers of its local graph. It extends the timeline, updates locations and possessions, and proposes decontextualized experience-layer concepts supported by the day’s events. The second updates its skills based on per-skill success and failure counts. The reflector also emits a one-line factual summary of the day’s progress. Apart from the knowledge stores, this summary and the previous day’s goal are the only free-form text carried from one day to the next; everything else lives in the graphs.
Aggregator. Skills written or revised in a dawn reflection enter the shared graph immediately; every days, after all reflectors finish, the textual experience records are consolidated as well, so the agents enter the next -day aggregation window with the shared graph already updated. The loop of act, reflect, aggregate, and retrieve continues for the whole run: competence that any single agent acquires is consolidated where every agent can find it, and the group’s knowledge compounds. No step of the loop involves human feedback, a human-authored curriculum, or parameter updates.
Two-layer knowledge graphs
OpenKAGE represents world knowledge as directed labeled graphs : nodes are concepts, each carrying typed facets (short textual statements describing one aspect of the concept), and edges assert typed relations . Each agent owns a local graph , maintained by its reflector and consisting of a private memory layer and a shareable experience layer; the group maintains one shared graph that consolidates the agents’ experience over the run.
The two layers follow the complementary learning systems account of memory [7]: , with each concept carrying its layer :
Memory layer. Situated, first-person records of what happened to this agent: a dated, agent-bound episode, illustrated with a concrete concept identifier and its episode text in Appendix § 9.§ 2 (Figure 7). Nodes are bound to the agent’s coordinate frame and timeline, forming a day-chained backbone with locations, possessions, and events attached.
Experience layer. Transferable knowledge abstracted from the agent’s interactions. Records in this layer abstract away agent-specific locations, timestamps, and identities while preserving task-relevant preconditions and applicability conditions. The layer contains two forms of transferable knowledge: textual experience records, which state a reusable procedure or failure condition, and executable skills, which are parameterized programs produced by the reflector and invoked by the planner. Nodes use agent-independent concept names, so they are useful to any agent facing a similar situation. Concrete record texts, skill names and concept identifiers are given in Appendix § 9.§ 2.
Figure 7. Situated memory and transferable experience. Five examples from different agents and runs: left, private memory keeps episode-specific events and locations; right, the experience layer holds reusable textual knowledge records and executable skills. Arrows mark thematic correspondence, not graph edges.
The two forms influence behavior through different channels. Textual experience records are retrieved into context and inform planning; executable skills are injected into the execution environment and implement behavior directly.
The separation is enforced at the level of access: the reflector declares the layer of every concept, and the aggregator is given only the experience layers as input, , so memory-layer records are not provided to the aggregator; the reflector is instructed to omit agent-specific coordinates and timestamps from shareable records. The two layers have different access channels: the experience layer is consulted by intent (goal-conditioned retrieval), while the memory layer is injected each morning as a bounded slice of persistent context, with per-category budgets (episodic, spatial, lesson, status; Appendix A.2) so that high-volume daily records cannot displace slowly changing spatial records (camps, chests, mines) that may not be retrieved by goal-directed queries.
Knowledge sharing
Sharing operates on both forms of knowledge in the experience layer, and the two call for different treatment. Textual experience records reach an agent only through its context, so the group is free to rewrite them into whatever consolidated wording serves best: they are semantically consolidated into the shared graph every days. Executable skills are executed rather than read, so their code must not be rewritten: each skill enters the shared graph verbatim as an isolated node, without semantic consolidation, in the same dawn reflection in which it is written or revised.
Textual-experience consolidation. Every days, the aggregator reads the agents’ experience-layer text and updates the shared graph (Appendix A.6). It consolidates textual experience records rather than merely appending them: merging synonyms, where several agents’ wordings of one insight become a single concept: a vector-similarity pre-screen nominates candidate duplicates, and names already in use are reused, so a concept named once keeps its name; recording cross-agent corroboration, where a facet states explicitly when experience is confirmed by multiple agents, an unconfirmed claim still being admitted to await corroboration; reconciling contradictions, where conflicts are first tested for differing applicability conditions (one observation holds by day, the other fails at night) and corrected in place when one side is simply wrong; and aligning with prior knowledge, where new experience is folded into existing concepts wherever they match.
Let denote the textual nodes in agent ’s experience layer. After a successful aggregation, these local textual records are cleared, , so each agent’s shareable textual output stays bounded at days of reflection while the shared graph grows across windows.
Skill sharing. Skills bypass semantic consolidation. A skill node in the shared graph carries its author’s code unchanged, together with its author and its cumulative success and failure record; it has no edges, so retrieval reaches it by matching the goal against the skill’s stated intent (a one-line description of when to use it), as in vector anchoring, rather than by relational expansion. A skill is propagated verbatim and selected by its record; the author alone revises or retires it, so what circulates in the group is exactly the set of skills their authors still stand behind. The skill nodes are implemented as a read-only registry over the agents’ own skill libraries, so code is neither copied nor rewritten in transit (Appendix A.9). For skills, code delivery and context presentation use different channels: the code is injected wholesale into the execution environment, while only the signatures of the top- skills with the strongest execution records occupy the context, supplemented by signatures retrieved for the current goal.
Intent-aware subgraph retrieval
The retriever is the component bringing the graphs back to agents: it is triggered by intent, i.e., the agent’s current goal or a query it issues, and during the day the agent may query or expand at will. Unlike skill-library or RAG memory ((Wang et al., 2024; Lewis et al., 2020)), it exploits graph structure for intent-aware retrieval, in three stages.
Vector anchoring. The query is embedded and matched against concept embeddings; among the top- candidates, an anchor is admitted only if its similarity is within a ratio of the best match, i.e., its cosine similarity is at least times the best candidate’s. The gate is relative because absolute cosine similarities are not comparable across embedding models and corpora. The number of anchors is set by the query’s semantics, not by a fixed count or an absolute threshold.
Figure 4. Intent-aware subgraph retrieval (schematic). The retriever selects anchors by relative similarity, then expands along relations scored by query-conditioned relevance and retrieval-use strength; blue solid arrows trace one sampled path, dashed arrows the other candidates. A structured subgraph is returned, not a ranked list.
Relational expansion. From the anchors, retrieval walks the graph’s edges outward for up to hops. For a frontier concept with an edge of type to a neighbor , the edge score is
where is the query embedding, is the embedding of the relation’s text prefixed with ’s name, and are the mean and standard deviation of raw cosine similarities across the relations at (when the standard deviation is zero, as at a node with a single relation, the query-relevance terms are set to zero). The cosine-similarity standardization is performed within each node rather than globally. Here is the neighbor’s retrieval-use strength, a monotone counter of how often retrieval has used ; it is initialized at 1 and updated only through retrieval (Appendix A.8).
The unnormalized sampling weight of an edge is thus proportional to , combining query relevance with retrieval-use strength. The candidate edges of a hop, , are softmax-normalized jointly at temperature , so that an anchor with many good edges is not outvoted by a one-edge anchor, then pruned to a nucleus of cumulative mass and renormalized; each surviving edge is then taken independently with probability
where is the score of edge from equation (1), is renormalized over the nucleus, and is the number of frontier nodes. This rule bounds the expected number of selected edges per hop by the frontier size; it does not enforce equal expansion across frontier nodes, and multiple selected edges may lead to the same node. Lower-probability edges retained in the nucleus may still be sampled: retrieval explores the graph rather than looking it up.
Subgraph recall. The returned representation contains the anchors, the nodes reached by expansion, all their facets, the edges internal to this set, and the edges leading outward (directions available for further expansion, reported as outgoing-relation metadata). The agent receives a structured subgraph, potentially containing multiple connected components, rather than a flat ranked list.
Experiments
Setup
Experimental setup. Runs last 30 Minecraft game days on one fixed world seed (seed 7) at hard difficulty with inventory retained after death; game time advances only during action execution. Each group has agents in separate worlds with distinct personas, aggregating every days. DeepSeek-V4.1-Flash (DS-V4.1F) is the default backbone, GLM-5.3, hy4-preview and Kimi-K3 are additional backbones, and GLM-5.3-Flash is the target of the transfer experiment (§ 3.4); one backbone serves all roles of a run. Every run starts from empty knowledge stores, each method–backbone cell has 10 independent group runs, and reported values are averages over them. Full configuration and sources of randomness are in Appendix § 12.§ 1.
Baselines. The planner-only control has the same backbone, personas, action API, world seed and horizon but no persistent memory, reflection or skill library (Appendix § 12.§ 3), so it measures the combined effect of the knowledge components, not sharing alone. On the default backbone we also re-implement two external methods under the same world, interface and horizon: Voyager (Wang et al., 2024) (automatic curriculum, iterative code generation, self-verification, skill library) and Echo (Li et al., 2026) (successful tasks stored as structured experience, new tasks induced by analogy). Differences from both originals are in Appendix § 12.§ 3.
Main results
We evaluate OpenKAGE on two long-horizon capabilities over 30 game days: exploration progress and survival. Every cell contains 10 independent group runs of three agents on world seed 7. Table 1 compares methods on the default backbone, and Table 2 compares OpenKAGE with its planner-only control across backbones. Metrics are defined in Appendix § 12.§ 2; per-run values are in Appendix § 12.§ 4.
Better exploration: completing the Nether route. We find that the hardest part within 30 days is obtaining obsidian, building a portal and entering the Nether, a route through a diamond pickaxe, an iron bucket, a lava source doused with water and a frame lit with flint and steel. Only OpenKAGE completes it (Table 1): 6 of its 30 agents obtain obsidian, on day 22.8 on average, and 4 enter the Nether, on day 23.8, whereas no agent of any baseline does either. Diamond-tier tools are reached by 24 OpenKAGE agents, against 16 for the planner-only control, 26 for Echo and 1 Voyager. Across backbones (Table 2), OpenKAGE obtains obsidian on all four and enters the Nether on three, whereas none of the 120 planner-only agents does either. Voyager’s authors note that abstract exploration goals are “challenging to execute without an appropriate curriculum” and add a dedicated curriculum module (Wang et al., 2024); OpenKAGE has none, and the acting agent sets its own goal each day from its state and accumulated knowledge. On three of the four backbones, agents following that route reach its end within 30 days with no externally assigned task, whereas Voyager does not get past iron tools in 29 of its 30 agents.
Better survival: fewer repeated mistakes. Mean deaths per agent fall on every backbone (Table 2). Two readouts locate the reduction. Deaths that repeat an earlier one (same cause, within 16 blocks of the agent’s previous death) fall from 15.1 to 7.4 per agent on the default backbone, and also on hy4-preview and Kimi-K3, and make up a smaller share of all deaths (45% under OpenKAGE against 52% for the planner-only control, 70% for Echo and 88% for Voyager, whose isolated agents often fall into the same lethal situation dozens of times; mean of per-run shares). Combat deaths from hostile mobs, arrows and explosions fall on four backbones (Figure 5; 22.2 to 10.5 per agent on the default backbone), while drowning falls clearly only on hy4-preview and rises on GLM-5.3, the backbone where the most agents obtain obsidian: obtaining obsidian requires working beside water and lava, which is very dangerous. Agents learn to handle threats they meet repeatedly, and the remaining deaths shift towards the hazards of deeper exploration. This is not bought by exploring less: mean XP per life is higher on three of the four backbones (markedly on GLM-5.3 and hy4-preview).
Figure 5. Deaths per agent over 30 days by cause (combat: hostile mobs, arrows, explosions); bar-end numbers are totals.
Shared knowledge: growing and reused across agents. On the default backbone the skill library available to each agent grows almost linearly to 132.5 skills by day 30, of which an agent writes about 44 itself; on every backbone 62 to 65% of skill calls invoke a skill written by another agent, and 94% of those succeed on the default backbone (success means the call returned without error; growth curves, failure rates and skill revisions are in Appendix § 12.§ 4). The knowledge components cost more: per game night OpenKAGE makes 21% more LLM calls than the planner-only control, processes about 4.2 times as much text, and takes about 1.6 times as much wall-clock time per complete run, the extra time cost of reflection and aggregation (Appendix § 12.7).
Ablations
All conditions run on DeepSeek-V4.1-Flash with 10 group runs each; Full and B are the OpenKAGE and planner-only cells of Table 1, and each condition is defined in Appendix § 12.§ 5. These comparisons provide evidence about component contributions, but do not establish interaction-free effects.
| Method | Deaths ↓ | Repeat ↓ | XP/life ↑ | Tool era | Obsidian | Nether |
| Voyager | 228.9 | 203.1 | 1.0 | dmd. (3.0 day, 1/30) | — | — |
| Echo | 73.6 | 53.1 | 4.2 | dmd. (15.8 day, 26/30) | — | — |
| Planner-only | 27.9 | 15.1 | 14.0 | dmd. (15.2 day, 16/30) | — | — |
| OpenKAGE | 16.2 | 7.4 | 18.2 | dmd. (13.7 day, 24/30) | 22.8 day (6/30) | 23.8 day (4/30) |
Table 1. Comparison with baselines on DeepSeek-V4.1-Flash (30 game days, 10 runs of three agents per method). Deaths, Repeat (deaths repeating an earlier one of the same agent) and XP/life are per-agent means. Tool era (dmd. = diamond), Obsidian and Nether give the mean first-attainment day over the agents that reached it, with their count out of 30; — means none. Definitions: Appendix § 12.§ 2.
Obsidian and the Nether are delicate indicators. Open-ended long-horizon exploration does not let us quantify the contribution of each component at fine granularity. Full reaches obsidian with 6 of 30 agents (in 4 of 10 runs) and the Nether with 4 (in 3 runs). Removing any one of retrieval, the memory layer or the experience layer (−R, −M, −E) leaves no agent with obsidian or the Nether in 30 days, and removing sharing (−S) cuts the numbers to two agents and one. This suggests that sharing promotes the flow of knowledge within the group: agents able to reach higher achievements pass on knowledge that lifts others too.
Direct sharing without consolidation. Raw appends records verbatim with its skill channel active (60% of skill calls), yet reaches neither deep milestone: 16 of 30 agents never get
a diamond pickaxe (6 under Full), and of the 14 that do, 8 set an obsidian goal (Full: 18/24) but only 2 obtain an iron bucket (Full: 13/24) and none obtains obsidian. Nor is missing route knowledge the whole story: two Raw agents had the complete pouring procedure and matching skills in both their shared records and retrieved blocks, followed them for days, and still failed. One possible attribution is low effective information: verbatim records keep events one by one, so a recurring failure reappears as several similar entries while the actionable rule takes up little of the retrieved block, and agents read what happened rather than what to do next. The same errors then recur and agents die or run out of time before the prerequisites are in place, whereas consolidation merges repeated failures into one rule. This fits the gap appearing at the earlier stages.
Cross-group and cross-backbone knowledge transfer
Does the value of the accumulated knowledge stores survive the group, and the backbone, that produced them? The transfer group is a fresh GLM-5.3-Flash group whose stores are initialized with the shared graph and skill libraries that a DeepSeek-V4.1-Flash OpenKAGE group accumulated in 30 days; the non-transfer group starts from empty stores. Both follow the same 30-day protocol, three runs each. GLM-5.3-Flash is a weak backbone for this world: without transferred knowledge, larger groups do not reach obsidian or the Nether within 30 days, and doubling the horizon reaches obsidian only on day 54 (Appendix § 12.6).
The two groups separate (Figure 6): deaths fall from 25.7 to 19.7 per agent, final cumulative XP rises from 237.8 to 329.1 (+38%), diamonds are reached by seven of nine transfer agents against three of nine, and obsidian by one of nine against none. In this configuration, initializing a new group with the accumulated stores improves survival and exploration over empty-store initialization.
Figure 6. Knowledge transfer (transfer solid, non-transfer dashed; three runs per group, nine-agent means, bands ±1 sd across agents). Icons in (c) mark the median first-reach night of the iron pickaxe, first armor, first diamond and obsidian; their height is arbitrary.
Related Work
Open-world learning and agent memory. Voyager combines an automatic curriculum with a growing executable skill library for Minecraft exploration (Wang et al., 2024); OpenKAGE instead places goal generation inside the acting agent’s own loop (§ 3.2); this concerns how goals are produced, not whether exploration is autonomous. Open-endedness research likewise generates the next challenge outside the learner, by co-evolving environments with their solvers (Wang et al., 2019) or by asking a foundation model which learnable tasks are interesting (Zhang et al., 2023); both concern what a single learner pursues next, whereas OpenKAGE concerns what a group keeps and shares. We use “open-ended” to mean no predefined endpoint, with progress measured by milestones and no novelty criterion. Other agents organize long-horizon behavior around injected task knowledge (Zhu et al., 2023; Wang et al., 2025), a hybrid graph-and-pool memory (Li et al., 2024), an episodic What-Where-When memory (Park et al., 2025), a knowledge-graph world model [1] or a causal graph (Yu & Lu, 2025; Tang et al., 2024). In OpenKAGE the stores start empty, and the distinction is the unit of accumulation: the memory–experience split becomes a sharing boundary, so situated records stay local while transferable knowledge is consolidated.
Multi-agent experience sharing. Multi-agent frameworks coordinate through communication and role division (Li et al., 2023; Hong et al., 2024); GEA treats the group as an evolutionary unit and pools members’ trajectories (Weng et al., 2026). Parameter-level sharing includes federated continual learning, which aggregates knowledge through parameters and leaves no inspectable record (Yang et al., 2024), and selective decentralized reuse: agents relay a few high-priority transitions [4] or retrieve and compose policy modules by task similarity (Nath et al., 2026), both with tasks given in advance. Memory systems for multi-agent LLMs are closer in form. G-Memory retrieves related past task queries with their insights and trajectories, filtered by role (Zhang et al., 2025); its hierarchy is keyed by task queries, which an open-ended setting does not provide. LLMA-Mem keeps episodic, procedural and transactive memory under local, shared or hybrid topologies on assigned tasks (Wu et al., 2026); its hybrid topology likewise keeps episodes local and shares consolidated procedures, so that design choice is not new to us. DAMCS gives each LLM agent a hierarchical knowledge graph and exchanges structured messages with chosen partners toward a fixed goal (Yang et al., 2025), without consolidating them into a group store. OpenKAGE differs in drawing the boundary by kind of knowledge rather than priority or partner, in sharing a structured graph whose applicability conditions stay with executable skills, in returning subgraphs rather than a ranked list, and in running without assigned tasks. A controlled comparison with verbatim sharing (Appendix § 12.§ 5) isolates consolidation inside an active sharing channel, and GEA, G-Memory and LLMA-Mem are compared with OpenKAGE at the level of design (Appendix § 9.10).
Retrieval-based memory. Retrieval-augmented generation retrieves external knowledge (Lewis et al., 2020), and GraphRAG and AgriGraph use graph representations [3, 1]. In agent memory the same pattern usually yields a flat ranked list (Wang et al., 2024): nearest neighbors of the query enter the context ranked by similarity, without the dependencies, preconditions and failure modes that bind them to the situation. OpenKAGE instead returns a subgraph, via vector anchoring and query-conditioned relational expansion, over knowledge consolidated across agents. Appendix § 9.10 compares systems in detail.
Conclusion
We presented OpenKAGE, a framework that drives lifelong learning and collective evolution of agents: it separates private situated memories from shareable experience, consolidates textual experience and shares executable skills across the group, and returns this knowledge to decisions through intent-aware subgraph retrieval. Across four backbones and 30-day Minecraft runs, it reached milestones that a planner-only control, Voyager and Echo did not, and reduced deaths, mostly repeated ones; its shared skills were reused across agents, and transferred knowledge helped a new group on another backbone.
Limitations and outlook. Our evidence is limited to Minecraft, one world seed and a 30-day horizon (60 days only in the scaling runs), so it speaks to open-ended lifelong learning only to a limited extent, although to our knowledge it is the longest-running study in an open-ended world to date. At 10 runs per condition the ablations do not resolve which component they depend on.
AI USE STATEMENT
Generative AI tools were used in three capacities during the preparation of this work, each subject to human oversight: (i) to aid and polish the writing of the manuscript; (ii) for retrieval and discovery, e.g., locating and surveying related work; and (iii) for research ideation and execution, including assistance with code development and experiment orchestration. All experimental design, data interpretation, and conclusions are the responsibility of the authors.
ETHICS STATEMENT
This work is conducted in the Minecraft simulation environment and involves no human subjects or real-world intervention. The agents’ knowledge-sharing mechanism involves no user data.
REPRODUCIBILITY STATEMENT
Experimental settings, prompts, interfaces, and metric definitions are documented in the main text and appendices; Appendix § 12.§ 1 tabulates the full run configuration. Model configurations, interactions, and daily environment snapshots are logged to support result verification. The framework, baselines, prompts, metric and figure scripts are available at https://github.com/zhuzhuxia5678/OpenKAGE, and the per-run records at https://github.com/zhuzhuxia5678/OpenKAGE_results. These artifacts support recomputing the reported metrics and regenerating the result figures.
Method
All prompts quoted in this appendix are given in English translation; the Chinese originals that drive the runs are released with the code.
The OpenKAGE algorithm
A run is a group of agents, each in its own world, playing game days; agents never meet in-world and share only at the knowledge layer. Each day has two parts, acting by day and reflecting at night, and every days the group consolidates. The agents run in parallel, and a barrier holds the group at the end of each night and again after each consolidation, so no agent begins a day before the group’s knowledge for the previous one is final.
Algorithm 1 OpenKAGE, one run. Stages marked barrier block until all agents have reached them.
Require: group of agents with local graphs ; shared graph ; days; window
for to do
for each agent in parallel do
inject standing memory (per-category budgets) and the top-20 skill signatures
plan a goal for the day; retrieval returns a subgraph of keyed to that goal
repeat
observe, write and execute one program over the atomic API or any agent’s shared skill, take feedback
re-planning re-triggers retrieval
until the day ends
night, stage 1: reflection writes and from the day’s trajectory
barrier: every agent has finished stage 1
night, stage 2: skill maintenance against the day’s per-skill tallies; new and revised skills enter verbatim as isolated nodes
end for
barrier: night complete {day ’s knowledge is final}
if then
consolidation merges into ; on success
end if
barrier: day begins with already updated {no lag}
end for
Two consequences of this schedule are worth stating. First, because consolidation is synchronous rather than running in the background, every agent entering day already sees the conclusions of window in the shared graph, so the knowledge feedback loop has no lag; skills reach the other agents sooner still, on the morning after they are written. Second, because the textual part of the private experience layer is cleared once per window, it holds one window’s output rather than the whole trajectory’s, which keeps its size bounded as grows. The consolidation step itself, namely what it merges, is given in Appendix § 9.7.
Knowledge graph schema
This appendix specifies the data model behind § 2.2: what a concept carries, what a facet and an edge are, how the layer and the memory category are declared, the two kinds of experience node, and which component may write each field. Each agent’s local graph and the group’s shared graph use the same model; they differ in who writes them and in which layer they carry. Concept names, facet labels, and relation names are free text in the agents’ working language (Chinese in our runs); as elsewhere in the paper we quote the identifier and give an English gloss, and the originals are released with the code.
Concepts. A concept is a stable identity for one thing the agent knows: a day, a place, a procedure, or a hazard. It is the unit at which the graph is addressed, retrieved, and consolidated (Table 4). For example, day_14 / bucket_fill_and_place is a dated, agent-bound memory concept; Figure 7 shows its episode text and coordinate frame.
| Field | Content | Written by |
slug | ASCII snake-case identifier, unique; the handle every operation addresses | R / A |
name | free text; a proper name in the memory layer, a common name in the experience layer | R / A |
summary | one-line statement of what the concept is | R / A |
layer | mem or exp, declared when the concept is created | R |
category | episodic, spatial, lesson or status; empty for experience concepts | R (memory only) |
strength | real, initialized to 1.0; monotone, and only the retrieval path writes it | Ret only |
timestamps | created_at, updated_at: game day in the local graph, window index in the shared graph | R / A, Ret |
Table 4. Concept fields. Who writes: R = the reflector (private graph), A = the aggregator (shared graph), Ret = the retrieval path of the acting agent. No other component may write any field.
Two properties of this table matter downstream. First, layer and category are declared once, at creation, by the reflector, and are not re-derived from content afterwards; the layer is a property of the concept, not of any one facet, so a concept that later acquires facets of another kind does not silently change layers. Second, updated_at advances both when the content changes and when retrieval returns the concept. Being used counts as being active, which is what makes it the ordering key for the morning injection.
Facets. A concept carries any number of facets, each a short statement of one aspect: a label kind and one to two sentences of content. At most one facet of a given kind may exist under one concept, because the pair (concept, kind) is unique. Extending what is known about an aspect therefore rewrites that facet in place instead of appending a second one. The kind is a short class-label the reflector names itself, not an entry from a fixed vocabulary; the criteria it is given (name a class, answer a question of the form “where is it” or “how is it done”, and reuse the names visible in the graph index) are stated verbatim in the phase-1 prompt of Appendix § 9.§ 5. Figure 7 shows the facet text of a textual experience record derived from the irrigation episode: “fill / pour with activateItem(), not activateBlock(); use a separate lower pit to stop flooding”.
Edges. An edge is typed and directed, , and is unique per (from, to, relation), so the same pair may be linked by several relations. The relation is free-named by the reflector under one constraint: the name must read as a predicate, i.e. “from to” must read as a sentence. This is why § 2.4 scores a relation by embedding its name together with the concept it leaves from: a vague name such as related_to is semantically distant from a specific query and therefore tends to score low. That is a property of the scores, not a rule: no check rejects a relation name, and whether an edge is traversed is decided by sampling (Appendix § 9.8), so no relation is excluded by construction. Edges are also the one place where the two layers meet: a local graph links an experience concept to the memory episodes that support it, and the aggregator is shown the names of those memory-side endpoints as labels only; its tools cannot address the memory layer (Appendix § 9.7).
Layers. The layer tag separates what is situated from what is transferable. The reflector applies a single test at creation, given verbatim in Appendix § 9.§ 5: could someone who did not live that day take this node and use it as it stands? Memory concepts never leave the agent; experience concepts are what the aggregator reads, and are cleared from the local graph once a window has been consolidated. Category is declared for memory concepts only; it is empty for experience concepts, which are selected by retrieval rather than injected. Figure 7 shows examples of both layers from the persisted runs: the memory concept day_14 / bucket_fill_and_place records “Irrigated the farm; water washed away one wheat crop. Repaired the pit and replanted it”, while the corresponding experience record states “fill / pour with activateItem(), not activateBlock(); use a separate lower pit to stop flooding” and the executable skills include fillAndPlaceWaterBucket and digStairTunnel.
Memory categories and the morning budget. The memory layer is injected each morning as a bounded slice of standing knowledge. The slice is drawn per category rather than by a single recency rank, because the four categories go stale at different rates, and a single rank lets the day records written every night crowd out everything else.
The budgets reserve capacity for spatial and status records, which are few and slow and which a similarity query is unlikely to surface: the query “where is my chest” is not similar to “what I intend to do now”, so these records get reserved capacity instead of competing with the daily flow of day records. A memory concept with no declared category is not injected at all, though it stays reachable by retrieval, and the reflector’s own view of the memory layer at night is a wider index of the most recent concepts rather than the injected slice. In 30-night runs the memory layer ends with on the order of concepts, with per-agent ranges of roughly 30–112 episodic, 7–60 spatial, 0–8 lesson and 1–2 status, so most buckets are saturated and the caps bind. Two short texts ride along with the layer and go wherever it goes: the goal the agent set for itself the previous day, and the one-sentence summary of that day’s progress produced at dawn. They are the layer’s textual surface in the planner’s opening message, and a condition without the layer carries neither Appendix § 9.§ 4.
The two experience node types. Both live in the experience layer, and both are what leaves the agent, but they are stored and shared differently because they act differently (§2.2). Textual knowledge records are ordinary concepts with : facets hold agent-independent statements, and there is no numeric consensus field. Cross-agent corroboration is written into the content itself, and a corrected belief is kept as a further facet recording what was believed, what is true, and how the change was found, rather than being overwritten silently. Executable skills are separate records, holding the intent, signature, code, flags, and count pairs specified in Appendix A.9. Each is written by its author’s reflector from a program that ran successfully that day, revised or retired only by that author, and crossed between agents as code, untouched. The executable skills in Figure 7, for example fillAndPlaceWaterBucket and digStairTunnel, illustrate this second record type.
Strength. Every concept carries one real-valued strength, initialized to 1.0 and monotone; the mechanism is as in §2.4. Only the retrieval path of the acting agent writes it, by the two gains of Table 10, and no operation in the reflector’s or the aggregator’s tool sets writes it. Strength records use, not authorship.
| Symbol | Value | Role |
| 4 | vector candidates considered for anchoring | |
| 0.80 | relative similarity gate: admit within of the best match | |
| 2 | hop cap; the agent chooses per query | |
| 0.95 | nucleus pruning of low-probability edges, after softmax | |
| 1.0 | softmax temperature over edge scores | |
| 1.0 | strength gain when the agent expands a concept | |
| 0.1 | strength gain when a query returns a concept |
Table 10. Retrieval hyperparameters, identical across all conditions. The temperature and govern only edge sampling; anchoring is deterministic given the index.
What the model deliberately does not carry. Embeddings are not fields of the graph, so retrieval can be retuned without touching the knowledge. Facets and edges carry no strength and no decay or archival flag. Usefulness is a property of what the agent reaches for, and everything the agent reaches for is a concept. And no node points back into the trajectory it came from: the day’s raw events are compressed into the graph at dawn, and the only text that survives into the next day unchanged is the one-line summary of progress.
Enforced and requested properties. The sections below mix two kinds of property: those the implementation guarantees, which the tool layer checks and on violation fails loudly, and those the prompts ask a model to produce, which are standing instructions whose observance nothing checks at run time. The first kind is stated where it applies; the second lives entirely in the prompts released with the code.
Agent–world interface
The agent’s only way to change the world is to write a short asynchronous JavaScript program, one per step, over an atomic action API exposed through the Mineflayer bot library; it never emits low-level controls. Programs are temporally extended, compositional, directly executable and, once verified, can be saved as skills (§2.1). This appendix lists the API in scope, the execution semantics of a step, and the observation returned after one.
The atomic API. Everything below is already in the scope of the generated program; nothing is imported.
One feature of this list is deliberate: there are no capability primitives such as Voyager’s mineBlock, craftItem, smeltItem or killMob. Voyager’s mineBlock, for example, scans every matching block within 32 blocks—including blocks hidden behind solid rock—and then delegates pathfinding, digging and item pickup to a single collectBlock.collect call. No composite capability is handed to our agents; they compose one in their own programs, and the skill channel is what lets that composition persist and travel to the other agents (Appendix A.10 gives the argument in full). The single exception is waitUntil, because the client’s own tick-wait is decoupled from the server clock, so a hand-written wait loop cannot move the world forward at all.
Execution semantics. One write_code call is one step. The program is evaluated as the body of an asynchronous function; world-changing calls must be awaited, because an unawaited one keeps acting on the world while the agent has already moved on to the next step. The agent declares its own budget for the step in game ticks, with a default of 500 and bounds of 100 and 3,000; a full day–night cycle is 24,000 ticks, and the budget is spent in world time, not wall-clock time. A step ends when its budget is spent, when the agent dies, or at midnight, whichever comes first. Between steps the world is frozen, so game time advances only while a program is executing (§3.1).
Observation. Every step returns the execution result together with a complete fresh observation, a text rendering of world state rather than pixels. Fields are fixed in content and order; their sensing radii differ, and each line states its own, so the agent never has to align them by guesswork.
The three spatial fields answer different questions and are not redundant: the adjacent grid is read through walls and answers whether the agent can stand, move or dig where it is; the vision field is ray-traced with real occlusion, covers only the horizontal and vertical in front of the agent, and answers what lies that way and whether it is worth walking to; the block-type set is a directionless overview of what this neighbourhood contains. Two conventions hold throughout: directions are absolute axes (, , , …) rather than left/right or compass points, so a direction read from one field can be copied into a movement call; and every field reports facts only. The rules that turn those facts into decisions (for instance the light thresholds at which hostile mobs spawn) are stated in the agent’s standing instructions, and applying them is the agent’s job.
The planner
The planner is a single ReAct episode that runs from dawn to dusk: it is given two standing messages and one opening message, and then acts through six tools until the day ends. Everything it is told is identical across agents and across conditions; the only thing that varies per agent is its persona. Prompts are given below in English translation; the originals that drive the runs are released with the code.
Standing messages. The first is the persona: the agent’s name and a short description of how it tends to explore. This is the only per-agent difference in the whole system (§ 3.1): Table 8 lists the eight personas used in this paper, three in the main groups and five more in the group-size study of Appendix § 12.6, each written from the same template and differing only in the tendencies its names. The second is the domain prompt, in four parts: who you are (three long-horizon directions, namely survive, explore, and build, of which each day’s goal is one small step), how you act (one JavaScript program per step, with an explain line, the code, and a tick budget; no infinite loops), how you reach the world (the atomic API of Appendix § 9.§ 3), and what you see (the observation of Appendix § 9.§ 3, facts only). The full text follows below.
| Agent | How it tends to explore | What it underweights |
| Alice (ESTP) | Enters the situation first and trusts what the world feeds back now over anything reasoned out in advance; improvises quickly and dislikes standing still. | The longer-run cost that a repeated short-term gamble is quietly accumulating. |
| Bob (INFP) | Goes where the thing itself feels worth doing—new terrain, an untried method—and keeps options open rather than committing to a direction early. | Structure and commitment: will hold back and under-push rather than stake on a plan it cannot yet see through. |
| Carol (ISTJ) | Checks what is already known before spending a step on it: reuses what worked verbatim, skirts what only partly matches, and treats gaps as the only places worth new effort. | Open possibility; at night tends to audit and qualify what it already recorded rather than widen it. |
| Dave (ISTP) | Works in small pieces, one thing at a time, and wants a verdict on each step before starting the next; probes cheaply first and states the state before and after. | The shape of the whole: reports one step’s detail precisely, rarely what the day added up to. |
| Erin (ISFJ) | Refuses any bet whose loss would wipe out what has been accumulated; keeps a fixed home and works out and back from it in short trips instead of carrying everything onward. | Uncertain upside; as risk rises it drops productive work early to secure safety. |
| Frank (ENTJ) | Sets a target first, works backwards to what reaching it requires, then pushes through in one pass; re-targets outright when the target proves not worth it. | Whatever cannot be scored against the plan, and the option of waiting: standing still is the one thing it treats as always wrong. |
| Greg (ENTP) | Treats any settled method as the thing most worth doubting; when stuck it changes the premise rather than retrying the same approach. | Follow-through and fine detail: abandons a half-finished line for a more promising idea. |
| Helen (INTP) | Wants the mechanism before the move: why a method works, and under what condition it stops working; derives first and probes to confirm a conjecture. | Time and momentum; will keep turning a question over rather than act on a partial answer. |
Table 8. The eight personas. An agent receives its own row as the first standing message; nothing else varies per agent. Each is written from one template, an MBTI cognitive-function stack (type in parentheses), naming what the agent is drawn to and what it underweights. Full text, and eight further personas, are released with the code.
The opening message. At dawn the previous day’s conversation is discarded, and the day opens with one user message assembled from five blocks, each skipped when its value is empty: the day number with the instruction to plan and not to stop calling tools; yesterday’s goal, the goal text the agent itself set, carried across verbatim; yesterday’s progress, one factual sentence produced at dawn (no night-time episodes, no goal-setting, because the agent decides that itself from the situation it wakes into); the memory block of Appendix § 9.§ 2, followed by a count of the shared graph’s contents, since shared experience is not injected but read by intent through retrieve; and the first observation of the day, placed last and behind a boundary marker. Apart from the graphs, these blocks are all that crosses the day boundary. If the agent stops calling tools while the day is not over, a fresh episode is started with the same standing context, its current plan, and the instruction not to stop.
Tools.
What comes back. A write_code call returns the execution feedback together with a complete fresh observation, so the agent never has to ask what the world looks like now. A createplan call, or a revision, returns the retrieved experience and the skill signatures as well: planning is what keys retrieval to an intent (§ 2.4); the signature block is ranked as in Appendix § 9.9, and the code of every skill is in scope regardless. At nightfall the framework itself issues one retrieval, with a fixed query covering shelter and defence as well as productive work, and appends it to that step’s feedback: without it the agent reads dusk purely as a signal to hide, and stops finding things to do. All of this injection is incremental: concepts and signatures already shown earlier in the day are not
| Tool | What it does |
createplan | Sets the goal for this day–night cycle and the ordered steps it decomposes into. |
updateplan | Planning with a goal triggers retrieval, whose result comes back with this call. Marks a step running, succeeded or failed with a note, or replaces the remaining steps given a reason. Revising triggers retrieval keyed to that reason. |
retrieve | Queries the graphs by intent: which layer (experience or memory), which scope (own, shared or both), and how many hops of relational expansion. |
expand | Deepens from one concept along its relations, optionally along one relation only. This is the deliberate, high-precision form of use that scores strength (Appendix A.2). |
retrieve_skills | Looks up skill signatures by intent, up to three. The code itself is already in scope, so a signature is all that is needed to call one. |
write_code | Executes one program: the only tool that changes the world. |
Table 9. The planner’s tools. Only write_code changes the world.
shown again. The day’s conversation is carried in full and discarded at dawn; no truncation threshold is applied while it runs (Appendix § 12.§ 1), and each step appends one program, one observation and one feedback block.
The domain prompt (English translation). The full system prompt that follows the persona; {placeholders} are filled per configuration. The action and observation catalogues it references are Table 6 and Table 7; sections that restate those tables are elided here.
| Group | Calls |
| Pathfinding | bot.pathfinder.goto with a goal object: GoalNear, GoalNearXZ (within a radius of a point or a column), GoalBlock, GoalXZ, GoalY (a cell, a column, a height) |
| Goals for objects | GoalGetToBlock, GoalLookAtBlock (reach a block to touch or see it), GoalPlaceBlock, GoalFollow, GoalInvert (retreat), GoalCompositeAny / GoalCompositeAll |
| Direct control | bot.setControlState for movement keys, bot.look and bot.lookAt for turning |
| Blocks | bot.findBlock, bot.findBlocks, bot.blockAt to read; bot.dig to mine one block (no tool choice, no approach, no pickup); bot.placeBlockSafe to place the held block on a face of a reference block, returning where it landed; bot.collectBlock.collect for a small batch |
| Crafting | bot.recipesFor, bot.recipesAll for the recipes of an item id; bot.craft to execute one, given the recipe, a count, and the crafting-table block where one is needed |
| Inventory, containers | bot.inventory.items(), .count(), .emptySlotCount() over 36 slots; bot.openContainer and bot.openFurnace return a window whose withdraw and deposit move items |
| Equipment, consumption | bot.equip and bot.unequip over six destinations, namely four armour slots, main hand, and off hand; bot.consume, bot.sleep, bot.toss |
| Combat | bot.nearestEntity, bot.entities; bot.pvp.attack and bot.pvp.stop for melee, bot.hawkEye.autoAttack at range |
| Self and time | bot.entity.position, bot.health, bot.food, bot.heldItem, bot.entity.onGround, bot.time |
| Data handles | mcData for item and block ids, recipes and drop tables; Vec3 for coordinates; console.log, whose output comes back with the step |
| Waiting | waitUntil for a number of ticks, or until the first of a set of events, namely hurt:N, healed, fed, no_mobs_nearby:R |
| Skills | await skillName(bot, ...); skill definitions are placed in the same scope |
Table 6. The atomic action API, in the scope of every generated program.
| Field | Radius | Content |
| Biome | own cell | biome of the block underfoot |
| Time | — | phase label (sunrise, day, noon, sunset, night, midnight) and the current tick out of 24,000 |
| Light | own cell | block light and sky light, each 0–15, reported separately: the first is what the agent can change (torches), the second is exposure to sky and does not fall at night |
| Position | — | absolute coordinates, to one decimal, since block operations are sensitive to a one-block difference |
| Vitals | — | health and food out of 20 with saturation, XP level and points, and oxygen when it is not full |
| Nearby entities | 32 blocks | per type: how many, the distance to the nearest, and the absolute-axis directions of the three nearest |
| Nearby block types | the set of block types present, deduplicated and without direction | |
| Inventory | — | items carried, and slots used out of 36 |
| Equipment | — | the six worn and held slots, empty shown as none, with remaining and maximum durability; these slots are not part of the inventory line |
| Progress | — | for each advancement tree, the deepest advancement reached in it |
| Tech | — | tier of the best finished tool carried or worn |
| Nearby chests | 16 blocks | coordinates and known contents: seen but never opened, opened and empty, or the items recorded |
| Adjacent grid | the 25 cells around the body in three layers (head, feet, below), each with an absolute direction; unknown means unloaded, not air | |
| Vision | 48 blocks | sectors by absolute axis and vertical level, each giving the block-type share with near–far distances, the fraction of rays that reach the full range, and the nearest point’s coordinates |
Table 7. Observation fields returned after each step.
# 1. Who you are and what you are here to do
You advance three long-horizon directions in this world. The goal you set
each day with createplan is the small goal for one day-night cycle; these
three are where you are headed.
Survive: keep your health, stock resources, avoid danger,
extend survival.
Explore: seek out the unknown, take risks, widen your horizons, keep
upgrading.
Build: raise a base, set up crafting tables and furnaces, make camp, make
a home.
---
# 2. How you act: one JavaScript program per step
You direct each step by writing a JavaScript program. Each step is one
write_code call with three fields:
explain a short statement of this step’s plan and why
code an executable ASYNC snippet (await directly; no
synchronous infinite loops -- they halt everything,
including time itself)
timeout_ticks the execution budget for this action, in ticks
(one day is 24000 ticks): default {default_ticks},
maximum {max_ticks}
One step does one clear thing, so progress accumulates. No infinite loops
or recursion.
### The await rule
Every action that changes the world or waits for it (dig, place, craft,
open container -- everything marked await in the table) is asynchronous
and MUST be awaited. An unawaited one becomes an orphan background task
that keeps manipulating the world while you have already moved on to the
next step. Pure reads (bot.blockAt, bot.findBlock) are synchronous; no
await.
---
# 3. How you reach the world
[The full atomic-action table is in the interface appendix. Everything is
in scope without imports: bot, mcData, Vec3, the pathfinding Goal
classes, waitUntil, and skills -- await skillName(bot, ...).]
---
# 4. What you see after each step
[Each step returns an observation with fixed fields in fixed order; the
full field table is in the interface appendix. All fields report facts
only -- whether a place is reachable or worth going to is yours to
judge.]
### The adjacent 3x3x3 grid: the 25 cells around the body
Three layers (above the head, at the body, below the feet), each cell
tagged with an absolute-axis direction -- this is what decides where you
can stand, move, or dig. unknown means the chunk is not loaded; it does
NOT mean air, and it is not walkable.
### Vision: real occlusion, not an x-ray
Rays are cast from the eyes; a ray stops at the first block -- what a
hill or a tree hides, you do not see (unlike the 25-cell grid, which
reads through walls). Sectors are keyed by absolute axis and vertical
level (level = straight ahead -- the layer you will actually walk into;
up = raised; down = lowered). Each sector gives: the block types
shares of the field of view with near–far distances (the dominant share
is that direction’s main body -- a forest, a cliff face); open N% -- the
fraction of rays that travel the full 48 blocks unobstructed (that
direction is empty); and the nearest point’s absolute coordinates --
directly usable for walking or digging. Vision covers only horizontal
+-60 degrees and vertical +-30 around the current heading: your back is
blind. Walking and digging change your heading, and with it which axes
this step could see.
The reflector
At dawn the world is frozen and the day is closed out. The reflector runs in two phases, each a separate session with its own tool set, and the group is held at a barrier between them so that no agent starts the next phase before every agent has finished the previous one. What follows is given in English translation; the originals that drive the runs are released with the code.
Phase 1: writing the graph. The reflector is told that tomorrow its context will be empty and that the graph is the only thing it carries across, so this is a compression, not a transcript, and choosing what to keep is its main judgement. It is given:
its persona, the day number, and the identifier to use for the day’s own concept;
the day’s server-authoritative facts: what new items it obtained, where each advancement tree stands, how many steps it took, its deaths grouped by cause, and the milestones it reached;
the full trajectory of the day, that is, each step’s program, the observation it acted on, and the feedback it got back;
an index of its own graph: every concept with its layer tag, the kinds of facet it carries and the relations it has, but not the content, which is read on demand;
It is then asked to write both layers: for the memory layer, the day’s concept chained to the previous day and a concept with numeric coordinates for every place reached or built; for the experience layer, whatever generalises into a sentence that holds for someone else, under a common name. The operative rules it is given, namely the layer test of Appendix § 9.§ 2, the per-category skeleton, how each field is named, and the skill-creation gate, are stated verbatim in the prompt below.
Tools. Phase 1 has one narrow tool per operation over concepts, facets, edges and skills: create, update, merge and delete a concept; search and fetch one; add, rewrite and delete a facet; and add, change or remove a relation. Nothing in this set can score a concept: strength is written only by retrieval (Appendix § 9.§ 2), and none of them revises or retires a skill, which is what the phase-2 session is for; it carries five skill tools of its own, namely create, list, search, revise and retire.
Phase 2: skill maintenance. The second session maintains the agent’s own skill library, with only the five skill tools, against what the library actually did during the day. Its brief is to act only on what is failing, to leave what works alone, and to retire what it cannot fix. The full maintenance loop, and its prompt, are given in Appendix § 9.9.
The one-line summary. A separate, tool-free call at dawn produces the Yesterday’s progress block of Appendix § 9.§ 4: one factual sentence on what advanced on the previous day’s goal. It carries no night-time episodes and no goal-setting, because the next day begins in different light and among different threats.
The phase-1 system prompt (English translation). {placeholders} are filled per day. Section 3 is the same representation as the aggregator is given (Appendix § 9.7), with the two fields only the reflector declares: layer and category; it also carries what the reflector must read off the graph index before writing. The prompt opens with the three things the reflector does (one per layer, plus skills), then what the two layers are.
You are maintaining YOUR OWN private graph. Tomorrow your context will be
emptied -- this graph is the only thing you carry across. So this is
a COMPRESSION, not a transcript: choosing what to keep is the most
important judgement you make now.
The three things you do
The memory layer -- what happened today: create the day’s concept recording the day (WITH coordinates, the day number, the outcome) and chain it to the previous day by a relation that reads as precedence; one concept per place you reached or built today, with concrete coordinates.
The experience layer -- what today generalises into: conclusions under common names that hold for someone else. What failed, killed you or blocked you today can almost always yield one (why it went this way, under what conditions not to do it again); the advancement you reached today becomes one common-name experience, so that someone who was not there can follow it. One experience for a whole day is almost always a miss -- but do not PAD it by filing "where I was today" in different words. Link the experiences to each other with manage_edge: the directions most often walked are what does it require, what does it lead to, when does it stop holding.
Skills -- the flows that ran today: generalise them into a parameterised async function and store them in the skill library (the gate is in section 4).
The memory layer and the experience layer
| memory layer | experience layer | |
| the name is | a PROPER name: "day_2", "my_camp_1" | a COMMON name: "night_movement_risk" |
| it answers | where am I, what happened, what is unfinished | how is this kind of thing done, how does it go wrong |
| person | first person, WITH provenance (day, coordinates) | de-subjectified: no "I", no day number, no coordinates |
| the test | someone who did not live that day cannot take it | someone else can take it and use it as it stands |
| who reads it | only tomorrow’s you | it WILL be aggregated into the shared graph |
Table 2 (PDF p. 23).
The first is the raw material of the second: "on day 2 I was killed by a zombie at Y=12 with no torches" is memory; "stock enough torches before entering an unlit area" is experience.
WRITE BOTH LAYERS: memory only -> what you distilled is shared with no one (the experience layer is the ONLY thing aggregated); experience only -> tomorrow’s you does not know where camp is or how far it got.
What you cannot generalise, leave in memory honestly: a single event written up as a universal law is worse than no entry at all.
Keep the raw case and the distilled conclusion as separate records -- distillation loses detail, and the raw case is what re-distillation runs on.
Four categories of the memory layer: every memory concept declares one. Tomorrow you wake with an empty context and only part of the memory is injected -- the category decides which part: different categories go stale at different rates.
episodic bound to one specific day: "day_3", that day’s blockers and findings -- stale within days
spatial durable assets with a location: camps, chests, mines, workbenches -- stale slowly (a mine empties)
lesson what an encounter left behind: deaths, misleading clues -- never stale
status the rolling self-model: current progress, backlog, equipment plan -- overwritten daily
The criterion is how the thing goes stale, not what it is about: "on day 3 I found a mine to the east" is episodic (bound to day 3); "that mine to the east" (with coordinates, existing across days) is spatial. status is ONE concept, updated in place every day with update_facet -- thirty days of "current state" concepts means there is no current state.
The skeleton of the memory layer:
A timeline: one concept per day, chained by a relation that reads as precedence; the day’s events hang on the day’s concept.
Anything with a location (camp, chest, mine) carries CONCRETE COORDINATES as numbers, "(112, 68, -340)" -- "to the east" is as good as nothing -- attached by a relation that reads as location or
containment. Coordinates are the only information that never goes stale across days (within one trajectory the world is not regenerated), and the anchor by which "what I was doing yesterday" continues.
Knowledge representation: the graph structure
Your private graph is made of three things, and these fields are all you can write:
| What | Fields | You decide |
| Concept | slug / name / summary / layer / category | all of them |
| facet | kind / content | kind; content is the text |
| edge | from --relation--> to | relation |
Table 1 (PDF p. 24).
slug: ASCII snake-case, unique in the graph, the only handle you have for get_concept / manage_edge later (a-z / 0-9 / underscore only).
name: the concept’s name, in Chinese. Which kind of name depends on the layer, as section 2 gives it (proper names in memory, common names in experience).
summary: one sentence saying what the concept is.
layer: memory or experience, declared when you create the concept, criterion in section 2. The layer is a property of the concept, so the two kinds of thing do not go into one concept.
category: required for memory concepts, one of the four, criterion in section 2. Not used for experience concepts.
kind: the short label (4-8 characters) naming what class of content this is, answering questions like "where is it" or "how is it done"; it is a label, not the content (the content goes in ‘content‘). One facet per kind per concept and at most six facets under one concept, so a kind has to be able to summarise.
content: the text of the facet, at most 400 characters (the tool refuses a longer one). Each facet is embedded as a vector of its own, and what exceeds the embedder’s window is not retrieved, with no error: long does not mean better remembered, it means the second half is invisible. On hitting the cap, compress (keep coordinates, numbers and conditions, cut throat-clearing) or split (into another kind, or into a new concept).
relation: the predicate of the outgoing edge -- substitute both ends and read it aloud: "from <relation> to" must read as a sentence (occurred_at reads; location does not -- a noun cannot be read aloud, so the direction can only be guessed).
You are also given an INDEX of the graph -- every concept with its layer, the kinds of facet it carries and the relations it has; the content is read on demand with get_concept. Read it before writing:
How to read a relation: "rel -> x" is THIS concept rel "x"; "rel <- x" is x rel this concept.
Recognising "I have already recorded this": the test is whether the QUESTION this sentence answers coincides with the question some existing entry answers, not whether the names look alike. Where they coincide, fold it in with update_facet, which is a whole-text rewrite.
Places are recognised by coordinate: the identity of a camp, chest or mine is its position, not its name (a name carrying the day number never collides), so compare by coordinate and extend the entry you find rather than creating one per day.
The memory layer may be listed only in part. When it is, the index opens with a line saying how many are listed and how many there are, and the exception applies: search_concepts before creating a memory concept, because older ones were dropped and not seeing them does not mean they were never recorded. The experience layer is not subject to this: what is not listed there is genuinely absent.
Names are Chinese throughout, except slug, which is the database key. Reuse the names you have already used: each day is an independent session that cannot see the others, and the only place the old names are visible is the graph index above, which lists the facet kinds and the relation names of every concept -- scan it first. One category carrying a different name every day is a category that does not exist.
Skills (your own higher-level functions) -- the other output, parallel to textual experience
Everything above is TEXTUAL experience (create_concept / add_facet): it records understanding but does not execute. The other kind of output is skills: your own higher-level functions. The raw material when you write code during the day is of two kinds: the low-level actions and the skills that already exist, its own and other agents’. The shape: a PARAMETERISED async function whose first argument is bot. A low-level action is one atomic operation; a skill is a reusable unit that arranges several low-level actions and/or other skills -- packed into one parameterised call that tomorrow, and the other agents, can run with await skillX(bot, ...). What it stores, and what the signature looks like, is decided by the flow that actually ran that day. A skill must pass the generalisation gate before anything else:
Signature level: a parameterised function, not a transcript of one run. Hard-coded coordinates, item names or counts welded into the body make it a memory, not a skill -- change the input and it cannot run. The test: can it still run with different arguments? If not, do not store it as a skill.
Applicability level: it does not depend on one world state. Preconditions the skill needs (furnace placed, pickaxe in hand) go into preconditions; do not assume they hold.
Red lines (on top of the gate): store only code that succeeded and achieved its intent today; the code must contain an async function whose name matches the signature (validated by the tool), first argument bot; write the intent concretely -- retrieval matches on it, "when smelting iron ore" is far more retrievable than "mining"; the code you store comes from the steps that ran today -- or is a synthesis of several of them (each step of the trajectory is marked "> generated code: ...") -- one step, or several steps such as "mine the ore", "return to the furnace", "smelt" and "collect the ingots" gathered into one complete flow.
Finally: when all tool calls are done, call no more tools; output a one-sentence summary of what you wrote (which concepts and skills you created), and stop.
The two sharing channels
{} separates the experience layer into two channels with different integrity requirements: textual knowledge records are rewritten by the aggregator, executable skills must arrive untouched. Figure 8 shows both on data from one persisted run: a consolidated concept assembled from several agents’ wordings on the left, and one author’s skill propagating verbatim into every agent’s execution environment on the right.
Figure 8. The two channels of knowledge sharing. Left: textual experience from different agents consolidated into one shared graph. Right: skills travel verbatim; Carol’s staircaseClimbToSurface (day 2) was used by all three agents from day 3, with 114 successes and 81 cross-agent calls by day 30.
The aggregator
Every days, once every reflector has finished, the aggregator reads what the agents’ experience layers hold and updates the shared graph (§ 2.3). This subsection concerns the textual records; skills are not rewritten here but enter the shared graph verbatim as isolated nodes (Appendix § 9.9). Two guarantees of different kinds apply. What is enforced is access: the aggregator is given the experience layers only, and its tools take no argument that addresses the memory layer, so no memory-layer content can be copied into the shared graph. What is requested is content: reflectors are instructed to phrase experience records without agent-specific coordinates and dates (Appendix § 9.§ 5). The access restriction by itself does not guarantee that such details are absent from what the reflectors wrote, and we do not check that they are, so we make no claim about leakage beyond the access boundary. The one thing that does appear from the memory side is the name of a memory concept an experience is linked to, shown as a private anchor: readable, not retrievable, never writable into the shared graph. The local textual-experience buffers are cleared once the window’s contribution has been merged, so a private experience layer spans one window of reflection, while private memory and skill libraries are kept and the shared graph keeps growing.
What the aggregator is given. One block per agent: its experience concepts, each with its summary, its facets under their labels, and its relations, with the direction of every relation spelled out. Then a pre-screen: for each candidate, up to three concepts already in the shared graph whose similarity exceeds a threshold, offered explicitly as a hint and not a verdict. Then the labels and relation names the shared graph already uses, with counts, but not a list of what the graph contains: each window is an independent session, and whether something is already there is something the aggregator has to look up; the label list answers a different question, what this graph calls this kind of thing. The aggregator is told to work in order: read all submissions and group them first, then search the shared graph and read what is already there before writing, then write.
The aggregator’s system prompt (English translation). The prompt is short by design: it defines the role and the four duties of § 2.3, states what the input looks like, and gives the representation, that is, what a concept, a facet and an edge are and what each field may hold (§ 3). Everything that is a property of an operation, what a call does and what it refuses, is left to the tool descriptions, which are in the context as well and are not repeated here. One sentence of section 2 describes each exploration as running in a freshly regenerated world; in the reported runs all worlds are generated from the same seed, so natural terrain coordinates coincide while built structures and dates do not. The instruction serves to keep agent-specific coordinates and dates out of the shared graph, and is a requested property, not a checked one.
You are the experience-merging agent: several agents have each
finished a stretch of exploration and each distilled some experience;
you fuse them into a shared experience graph for everyone to reuse,
reading and writing that graph directly with tools.
## 1. The four things you do
1. Merge like with like: several agents distilled the same thing in
different worlds -> store it as ONE facet: keep the clearest,
most parameterised version and fold the others’ details in.
2. Weight by consistency: when several agents INDEPENDENTLY reached
the same experience, update_facet synthesises a more precise one,
and "confirmed independently by several sources" goes into the
facet text (independent reproduction is the core credibility
signal, and it must show in the content). A claim made by one
agent only, uncorroborated, is still admitted and stored -- give
future windows the chance to confirm it.
3. Resolve conflicts: when two experiences contradict, do not
force-merge by picking one. First ask whether they have different
applicability conditions -- that is usually the truth (A holds by
day, B fails at night). If so, synthesise one statement recording
when it holds and when it fails (in the text, plus an edge in the
right direction). If one side is simply wrong, correct the
conclusion.
4. Align with what the shared graph already holds: it may already
carry priors (textbook seeds) or experience from earlier windows.
Where a new item matches an existing concept, fold it in; do not
create duplicates.
## 2. What the input you are given looks like
Each agent’s private graph has two layers: the memory layer (where
camp is, what happened on which day) is not given to you -- each
stretch of exploration runs in a freshly regenerated world, so
coordinates and dates mean nothing to anyone else; what you get is
the experience layer: what it distilled and believes holds for
others, with the facet text given in full. So you do not need to
"extract rules from episodes" -- the agents have done that; what you
do is turn N independently distilled experiences into one trustworthy
body of public knowledge.
Two properties of this input:
- The agents’ slugs are not resolvable in your hands (get_concept
always returns "not found"): your tools are bound to the shared
graph only, and the agents’ experience exists only as the text in
the user message.
- A peer marked [memory] is the NAME of a memory-layer concept (e.g.
verified_by <- day_1_death [memory]): only the name is shown, and
it shows what supports this experience or what blocked it. It does
not enter the shared graph -- no concept for it, no endpoint of a
manage_edge call, and such names are not copied into facet text.
## 3. Knowledge representation: the graph structure
The shared graph is made of three things, and these fields are all you
can write:
| What | Fields | You decide |
|-----------------|---------------------------|-------------------|
| Concept | slug / name / summary | all three |
| facet | kind / content | kind; content is the text |
| edge | from --relation--> to | relation |
- slug: ASCII snake-case, unique in the graph, the only handle you
have for get_concept / manage_edge later (a-z / 0-9 / underscore
only).
- name: the concept’s name, in Chinese. The shared graph holds common
names only: a coordinate, "day N" or "my" in a name means an
individual case leaked in -- rewrite it as a common name.
- summary: one sentence saying what the concept is.
- kind: the short label (4-8 characters) naming what class of content
this is, answering questions like "how is it done" or "when does it
fail"; it is a label, not the content (the content goes in
‘content‘). One facet per kind per concept and at most six facets
under one concept, so a kind has to be able to summarise.
- content: the text of the facet, at most 400 characters (the tool
refuses a longer one). Each facet is embedded as a vector of its
own, and what exceeds the embedder’s window is not retrieved, with
no error: long does not mean better remembered, it means the second
half is invisible. On hitting the cap, compress (keep numbers and
conditions, cut throat-clearing) or split (into another kind, or
into a new concept).
- relation: the predicate of the outgoing edge -- substitute both
endpoints and read it aloud: "from <relation> to" must read as a
sentence (requires is fine; precondition is not -- a noun does not
read as a sentence and the direction is always a noun’s guess; nominal
relations submitted by agents are rewritten into predicates when
merging).
Finally: when all tool calls are done, call no more tools; output a
one-sentence summary of which experiences you merged, and stop.
Retrieval: implementation and hyperparameters
This appendix completes §2.4 with the implementation and the hyperparameter values. All embedding goes through one asymmetric instruction-tuned encoder (KaLM, 896-d) (Zhao et al., 2025), over two indices keyed by slug, one for concepts and one for skills. A concept is added as several shards—one identity shard over its name and summary and one shard per facet—and a query scores a concept by fusing its shards back into one cosine-scale score, so that a facet can bring back the concept it belongs to and a short name cannot outvote a well-supported one. Anchoring admits a concept by the relative gate of §2.4 alone, with no absolute floor: cosine values are not comparable across encoders or corpora, whereas the relative gate is portable. On expansion, query–relation similarities are -standardized within each entry’s candidates before entering Eq. equation 1, which restores their spread without changing the ranking: every relation text shares the entry name as a prefix, so the raw similarities sit in a band in which softmax would be nearly uniform. The candidate set is the relation types actually present on the current frontier. Recall returns every facet of every node reached, which is bounded by the (concept, kind) uniqueness of Appendix § 9.§ 2, and every injected block is deduplicated against the conversation so far, so that a repeated injection returns only the increment. Retrieval defaults to the experience layer, since the memory layer is already injected each morning.
Table 10 lists the values used in every run; they are identical across conditions.
Skill lifecycle and the verbatim channel
This appendix completes § 2.3 on the skill side: the record a skill carries, how it is created and maintained, and how it crosses agent boundaries without ever being rewritten. The design question is the mirror image of the textual channel’s: there, knowledge is prose and needs an LLM to merge it; here, knowledge is executable code, and what the world reports back is unambiguous, namely whether a call resolved or threw, so the machinery is measurement and bookkeeping, and the only LLM judgement needed is “which skill is failing and how do I fix mine”. What that measurement records is execution completion, not semantic correctness: a call that resolves has run, which is a weaker claim than having achieved what the caller intended, and no stage of the pipeline checks the latter.
The record. A skill is one row in its author’s library: an intent (the natural-language condition under which it should be used, which is the text the skill index embeds, so retrieval matches on when to use it, not on the code), a signature (what the context shows: the call form, which must begin with the function name defined in the code, since the acting agent calls by signature and a mismatch would make the skill unreachable, which the creation tool rejects), the js_code itself, optional preconditions, and a verified flag. Beside these, the two count pairs and the revision count of Appendix A.2: the current-version pair is the evaluation window, the all-time pair the skill’s lifetime reliability. One number answers “did my fix work”, the other “do I trust this slot at all”.
Creation. Skills are written from programs that executed successfully that day and whose outcome the reflector reads as having achieved its intent; the creation prompt states this threshold and the reflector applies it, and no independent test re-checks it. This includes skills composed from several successful fragments of a day, in which case the composed function is not separately executed before it is registered. Skills are written by the phase-1 reflector in the first place, and by the phase-2 maintenance session when it adds one. A name collision is rejected outright: the JS function name and the slug are unique across the whole group. A near-duplicate intent, by contrast, is only reported back to the author as an advisory list, since whether two intents name the same job is a judgement the author makes and not a fact the tool can settle.
Measurement: the verbatim channel. The code of every verified skill is injected wholesale into the execution environment, in the same scope as the atomic API and available to every write_code step at zero context cost, while what enters the context is only signatures: a base block of the top-20 by cumulative success, supplemented by signatures retrieved for the current goal. Listing all signatures instead fills the context with skills unrelated to the current goal. Use is measured by the world, not inferred from text: each injected skill is wrapped so that a call either resolves (recorded as an execution completion) or throws (recorded as a failure, with the error message kept). The counts are routed back each night, deterministically, to the author’s library, so the record a maintainer sees is the skill’s true usage across the whole group, and a user’s failing calls adjust the author’s record, not the user’s.
Maintenance and retirement. The phase-2 session (Appendix § 9.§ 5) reads, for each of its own skills: both count pairs, the revision count, and up to ten deduplicated error messages from the current window. Its brief is to act only on what is failing, with the fix driven by the error pattern; the prompt below states it in full. Revising the code resets the evaluation window while the lifetime totals keep accumulating. This is what makes maintenance a feedback loop rather than guesswork; editing only the intent or preconditions does not reset the window, as that is documentation, not code. A skill that cannot be fixed is retired, that is, demoted out of the verified set so that it is no longer injected or retrieved. Retirement is reversible by rewriting. A skill nobody ever calls is read as a retrieval failure of its intent, and is fixed by making the intent more specific (“when smelting iron ore” matches; “mining” does not). The author may revise or retire only its own skills, and the barrier structure of Appendix § 9.§ 1 ensures that no agent starts a day calling a skill that was retired overnight.
Propagation. In the shared graph every verified skill is an isolated node that carries its author’s code verbatim. We implement these nodes as a read-only registry over the per-agent libraries: retrieval fans out to every library, merges by similarity with each hit tagged by author and counts, and the code is neither duplicated nor rewritten in transit. The code that runs is the author’s code, unmodified, and its revision history lives in exactly one place. The contrast with the textual channel (§ 2.3) is what the pair is for: prose has to be interpreted to be merged, so it goes through semantic consolidation, whereas code can be reused as it stands, so what the group accumulates about it is measurement rather than an opinion.
The skill-maintenance prompt (English translation). The phase-2 prompt, abridged to its operative rules.
You are the maintainer of your own skill library. Each dawn, the skills
you wrote were called by many users during the past day; now you look at
how they performed, and whether to improve or retire them.
You will see all of your own skills, one line each: cumulative
successes/failures of the current code version since its last revision;
lifetime successes/failures over all versions, never reset; how many
times the code has been revised; and real error samples from this
window, deduplicated, at most ten per skill.
Judge each skill; act on the ones with problems. A skill with only
failures, or a high failure rate, has a bug, not bad luck: rewrite it
with update_skill, reading the errors---timeouts: split the work or
request a longer budget; missing inputs: check the inventory first;
pathfinding failures: aim at a looser target; wrong blocks: re-read the
world. One you cannot fix, demote for now: a retired skill stops being
injected, and stopping the loss beats letting it burn your step budget
again tomorrow. Skills that work are left alone. A skill nobody calls
means its intent is too broad or too narrow to be retrieved---that too
is fixed by rewriting.
Touch only your own skills. Revising code resets the counters: that is
your clean evaluation window, and tomorrow’s counts tell you whether the
fix worked. Do not let a bad skill linger---it is injected every day and
wastes your budget until you fix it or retire it.
When you are done calling tools, output a one-sentence summary of what
you maintained, changed, or retired, and why.
Relation to prior systems
§4 positions OpenKAGE against prior work argument by argument; this appendix compresses the same comparison into a single view. Table 11 collects related agent-memory and experience-sharing systems along the axes that the mechanism sections of this paper isolate: who accumulates, what the artifact of accumulation is, whether situated and transferable knowledge are separated, whether what is shared gets consolidated, whether an accumulated store is transferred to a new group, and how memory is given back at decision time. The rows are not validated under one protocol: these systems were evaluated in different environments, text games for AriGraph, coding benchmarks for GEA, task-given embodied, game and question-answering benchmarks for G-Memory, multi-agent task suites for LLMA-Mem, task-given decentralized control and cooperative planning for SEPS, Policy retrieval and DAMCS, and Minecraft for the remaining rows, so the table compares designs rather than reported numbers.
| System | Unit | Artifact | Situated / transferable split | Shared & consolidated | Store moved to a new group | Memory → context |
| Voyager | 1 | personal skill library (code) | — (skills only) | — | — (one agent) | embedding top- over skill descriptions |
| GITM / JARVIS-1 | 1 | structured external knowledge + text memory | — | — | n.e. | retrieval over knowledge base |
| Optimus-1 | 1 | hybrid graph + experience pool | — | — | n.e. | graph query for planning |
| MrSteve | 1 | What-Where-When episodic trace | episodic only | — | n.e. | spatiotemporal retrieval |
| AriGraph | 1 | KG world model, episodic + semantic | ✓ (two layers, one agent) | — | n.e. | local subgraph exploration |
| ADAM | 1 | causal graph | — | — | n.e. | graph-guided reasoning |
| MARS | 1 | induced rule set | — | — | n.e. | rules in prompt |
| GEA | group | pooled evolutionary traces | — | pooled, not consolidated | n.a. | reflector reads the pool |
| G-Memory | group | insight, query and interaction graphs | — (levels of abstraction) | team store; insights summarized per task | n.e. | query-graph retrieval, role-filtered |
| LLMA-Mem | group | episodic, procedural and transactive stores | episodes local, procedures shared (hybrid topology) | procedures consolidated every tasks | n.e. | relevance–importance top- |
| SEPS | group (decentralized RL) | few high-priority transitions relayed between agents | — | selected, not consolidated | n.e. | relayed transitions enter each learner’s training data |
| Policy retrieval | group | policy modules (network parameters) | — | retrieved and composed, not consolidated | n.e. | module chosen by task similarity |
| DAMCS | group | per-agent hierarchical KG; structured messages | — | messages exchanged, no group store | n.e. | partner’s message in prompt |
| OpenKAGE | group | two-layer graphs + skills; shared consolidated graph | ✓ (memory stays private) | ✓ (semantic aggregation) | ✓ (§3.4) | intent-aware subgraph retrieval |
Table 11. Related agent-memory and experience-sharing systems. “Unit” is who accumulates; “artifact” is what accumulation produces; “memory → context” is how stored knowledge reaches the acting agent. Rows are compared on design, not on reported scores.
Three rows deserve a sentence beyond the table, because the resemblance is closest and the difference easiest to miss.
AriGraph. The nearest single-agent ancestor of our graph, evaluated on text games [1]: an agent grows a knowledge-graph world model with episodic and semantic layers, explores it locally when deciding, and revises it from interaction. OpenKAGE adopts the graph memory and the two-way split, and differs in what the split is for. In AriGraph both layers serve one agent’s understanding; in OpenKAGE the split is the sharing boundary. The semantic layer is what may leave the agent, and the episodic layer never does. A second mechanism (aggregation, Appendix § 9.7) exists precisely to reconcile agents’ semantic layers into one graph. Retrieval also differs in kind: AriGraph’s agent walks its own graph interactively, whereas our retrieval is intent-keyed, scored, and sampled, and runs over a graph the acting agent did not write.
Voyager. The source of our action space and of the skill artifact, and the row our skill channel most resembles. The difference that matters most is where goals come from. Voyager organizes exploration around tasks proposed by a dedicated automatic curriculum module; OpenKAGE integrates goal generation into the acting agent’s ongoing interaction loop, in which the agent selects and revises its own goals using its current state and its accumulated knowledge, with no separate curriculum module. The distinction concerns how goals are generated and how they govern interaction, not whether human intervention is required: Voyager’s curriculum is automatic, and the system is evaluated on open-ended exploration, tech-tree mastery and map coverage. Taking the group as given, three further differences follow. Skills are shared through a registry rather than living in one library, so a skill’s record accumulates every agent’s calls, not just its author’s; maintenance is driven by that cross-agent record (Appendix § 9.9); and skills are the second channel, alongside the consolidated textual graph, which has no analogue in Voyager. The ablations of Appendix § 12.§ 5 do not separate the two channels, since each removal that affects sharing (, ) takes both away. The evaluated action interfaces also differ from Voyager’s original design (Wang et al., 2024). Its appendix lists expert-written control primitives under “Control primitive APIs implemented by us” separately from “Control primitive APIs provided by Mineflayer”; the list includes exploreUntil, mineBlock, craftItem, smeltItem, killMob and others, for example, mineBlock, which explores, mines and collects a specified number of blocks within a 32-block distance. These routines enter the prompt as expert-written programs. In Voyager’s own baseline comparisons (Table A.3), the listed differences are the skill library, automatic curriculum and self-verification. We take the essence of learning to be the induction of generalizable skills from many trajectories of interaction; the upper bound of learning is such a set of generalizable skills. A primitive packages resource search, navigation, mining and collection into one long-horizon routine written in advance. Adding it to the agent’s initial capabilities raises its lower bound of competence and shortens the interval between that lower bound and what remains acquirable; starting from atomic actions preserves this interval, with the upper bound unchanged. Our protocol therefore removes these primitives to measure what can be acquired from atomic actions. Our adaptation keeps the automatic curriculum, iterative code generation with execution feedback, self-verification and per-agent skill library, and starts every method from the same atomic API. Under this bare API, Voyager’s hard-coded first task can fail repeatedly; Appendix § 12.§ 3 reports this as a concrete limitation of our adaptation. These results characterize the adapted implementations under our interface. The original end-to-end system lies outside this comparison. The comparison remains a comparison of mechanisms: Voyager and Echo keep their respective mechanisms while the supplied action capabilities are held fixed.
GEA. The nearest group-level system, evaluated on coding benchmarks (Weng et al., 2026): the group is an evolutionary unit whose members’ traces are pooled and read back by a reflector. OpenKAGE also lets the group read what every member produced, but the shared artifact is a graph whose records are consolidated rather than a set of parallel traces, and skills travel on a separate channel. The two also differ in what they report as transfer, as the note under Table 11 states. We do not compare numbers with GEA: its evaluation protocol and ours differ in environment, control interface and budget (Appendix § 12.§ 3).
✓ = demonstrated for the object named in the cell; — = not applicable to the system as designed; n.e. = not evaluated in the published description; n.a. = a transfer result is reported for a different object, so the column does not apply. GEA reports transfer of the evolved framework across coding models (Weng et al., 2026); our transfer experiment moves an accumulated knowledge store, namely the shared graph and the skill library, into a freshly initialized group, which is a different object and is not comparable with that result.
Experiments
Reproducibility configuration
Table 12 lists the settings that determine how a run behaves and that a reader needs in order to rebuild one. Values are identical in every reported condition unless a row says otherwise, and the configuration file released with the code carries every one of them. Parameters that are already tabulated elsewhere are not repeated here: retrieval hyperparameters in Table 10 (Appendix § 9.8), memory injection budgets in Table 5 (Appendix § 9.§ 2), the action API and observation fields in Appendix § 9.§ 3, and the personas in Table 8 (Appendix § 9.§ 4).
| Category | Holds | Goes stale | Budget |
| episodic | what is bound to a specific day: the day record, that day’s blockers and findings | within a few days | 18 |
| spatial | durable assets with a location: camps, chests, mines, workbenches | slowly, when exhausted | 10 |
| lesson | what an encounter left behind: deaths, misleading clues | not with time | 4 |
| status | the rolling self-model: current progress, backlog, equipment plan | overwritten daily | 3 |
Table 5. The four memory categories and their injection budgets. A bucket takes the concepts of that category in decreasing order of updated_at; budgets are caps, not targets, and are not redistributed across buckets.
Two protocol choices are not configuration values and are stated here because they affect how the numbers should be read. First, comparisons are made within a backbone: OpenKAGE is paired with the planner-only control on the same backbone, and absolute values are not compared across backbones, which differ in survival by more than the effect we measure. Second, the 30-day horizon is an evaluation budget, not a stopping criterion of the framework: agents keep proposing goals, accumulating experience and maintaining their knowledge with no predefined terminal task, and nothing in the loop asks them to stop at day 30. The transfer experiment of §3.4 uses GLM-5.3-Flash, a smaller model in the same family as the GLM-5.3 backbone, as its target backbone; its source stores are the shared graph and skill library of one completed DeepSeek-V4.1-Flash run at day 30, the non-transfer control is initialized from empty stores, and both then follow the identical 30-day protocol, three runs per group.
Sources of randomness. The runs of a cell repeat one configuration; they are not different random seeds. Fixed in every run: the world seed, the natural spawn point of that seed (so the framework’s spawn-point generator is never drawn), difficulty, personas, prompts and all hyperparameters. Not fixed: (i) LLM sampling, whose temperatures are in Table 12 and which exposes no controllable sampling seed; (ii) the edge sampling of relational expansion (Appendix § 9.8), which draws from an unseeded generator, whereas anchoring is deterministic given the index; and (iii) game dynamics, since mob spawns, combat outcomes and the timing of asynchronous programs differ between runs on the same seed. A run’s number records launch order only and enters no random generator. The spread across the runs of a cell therefore combines all three sources; each cell reports ten runs.
| Group | Value |
| Backbone | DeepSeek-V4.1-Flash (DS-V4.1F, default; also the backbone of the ablations and of both external baselines), GLM-5.3, hy4-preview and Kimi-K3; transfer target GLM-5.3-Flash; one backbone serves all three roles of a run |
| Temperature | 0.3 planner, 0.7 reflector, 0.7 aggregator |
| Top- | not set |
| Reasoning | low for all three roles |
| Output cap | 131,072 tokens per planner step, 65,536 per reflector and aggregator step, 8,192 for the night note |
| Step cap | 299 tool calls per day, 99 per reflector session, 99 per aggregation |
| Context | no truncation threshold: a day’s conversation is carried in full and discarded at dawn |
| Encoder | KaLM, asymmetric instruction-tuned, 896-d ((Zhao et al., 2025)), over two indices, one for concepts and one for skills |
| Query / document | an instruction prefix is prepended to queries only, never to indexed text |
| Truncation | 512-token encoder window; shards cut at 512 characters; facet content above 400 characters is rejected by the tool, not truncated |
| Game | Minecraft Java Edition 1.21.11 (Fabric server), Mineflayer 4.37.1 client |
| World | seed 7 for every reported run, natural spawn point of that seed, difficulty hard, keepInventory on, one day–night cycle = 24,000 ticks, game time frozen during deliberation and reflection, game clock at 2.5× |
| Agents | (Alice, Bob, Carol), each in a separate server instance generated from the same seed; and add the next personas in a fixed order |
| Horizon | 30 nights (60 for the time-horizon runs of Appendix § 12.6); aggregation every nights, i.e. 15 windows |
Table 12. Reproducibility configuration. Values are identical in every reported condition unless a row says otherwise; the configuration file released with the code carries every value, and each run records the configuration it used in its own summary.
Metric definitions
All metrics come from the structured snapshots recorded at the end of each day. Deaths is cumulative per agent, averaged over the agents of a cell. XP/life is final-day cumulative XP divided by deaths +1, computed per agent and then averaged; since XP is not lost on death, it measures what an agent gains per life. Tool era is the highest technology tier reached in the agent’s equipment, iron or diamond in our runs, and read from the tool tier itself rather than from obtaining obsidian, which is a milestone with its own column. Each Tool era entry carries that tier, the mean day on which the agents that reached it first did so, and their count out of all agents of the cell. Obsidian is the day of first obtainment and Nether the day of first entry, each averaged over the agents that reached it and reported with that count in parentheses. Counts are out of all agents of a cell (three per run, 30 per cell). Repeat counts an agent’s deaths that repeat one of its own earlier deaths: same recorded cause, within 16 blocks of the earlier death’s position; it is a per-agent mean like Deaths. Weakest XP/life takes, in each run, the lowest XP/life among its three agents and averages that over the runs of a condition. Others’ skills is the share of all skill calls in a condition that invoke a skill whose author is another agent of the same group, as recorded in the skill registry; it is zero by construction wherever sharing is removed. Lower is better for Deaths, repeated deaths and attainment days; higher is better for XP/life, the tool tier and the counts in parentheses. All values are averages over the ten sampled runs of a cell; because the agents of a run share one graph, the run is the sampling unit.
Baselines
The same-backbone baseline. The baseline is OpenKAGE with the knowledge machinery removed and nothing else changed: same backbone, prompts, tool set, night count, group size, world seed, and day–night protocol. The baseline agent keeps the planner of § 2.1. It still sets the day’s goal and ordered steps itself, still acts by writing one short program per step over the same atomic API, and still reasons over the observations and feedback that come back. What it loses is persistence. No local graph is written, no shared graph is consolidated, no skill is registered or retrieved, and no memory slice is injected in the morning; because in OpenKAGE the reflector is the process that maintains an agent’s graph and emits the one line that crosses the day boundary, removing the graphs also removes the nightly reflection, so no text at all is carried from one day to the next. Retrieval has nothing to retrieve, and the planner meets each day with the model, the observations, and nothing else. The residue is exactly the standard single-agent LLM-agent stack (Yao et al., 2023; Shinn et al., 2023; Significant Gravitas, 2023), in the same family as the planner-only control of Wang et al. (2024); we do not claim the two match item by item in configuration. Relative to it, OpenKAGE adds persistent memory, nightly reflection, the skill channel, intent-aware retrieval and group-level consolidation. The gap between the two rows of a backbone is therefore the combined effect of that knowledge stack under a matched agent–world interface: it is not an estimate of what sharing alone contributes, and it does not establish superiority over other memory-equipped agents.
External baselines. Voyager (Wang et al., 2024) and Echo (Li et al., 2026) are re-implemented on the same server, world seed, spawn point, difficulty, day–night protocol and 30-day horizon, with three isolated agents per group that share nothing, and with DeepSeek-V4.1-Flash as the single backbone of every module. Both act through the same bare Mineflayer API as OpenKAGE instead of their original action layers, and both receive the long-term objective of our protocol (survive, explore, build) as their overall goal, so that what differs is the mechanism that turns that goal into tasks and experience. Tasks continue across day boundaries, since neither system has a day–night notion.
Voyager. Automatic curriculum, iterative code generation with execution feedback (up to four rounds per task), self-verification, and a per-agent skill library, with the original temperatures and warm-up schedule. The optional wiki question-answering context is omitted. Because the hard-coded first task can fail repeatedly under the bare API, the curriculum takes over after five consecutive failures of it.
Echo. The released code does not include the runtime it depends on, so we port its mechanisms rather than run the original system. Successful tasks are stored as five-dimensional structured experience (attribute, structure, function, procedure, interaction); the most recent success serves as the anchor, the top-3 other experiences are retrieved by the official equal-weight five-dimension similarity, and in-context analogical learning induces the next task. Code generation and self-verification use the same executor as Voyager. The visual dimensions are written from text observations, since the agents receive no images. Two guards are ours: a seed task is skipped after three failures, and an induced task must advance beyond its anchor, because without this rule agents fell into loops of same-tier material substitutions whose value never rose.
Scope of the comparison. The planner-only control measures the combined effect of the knowledge stack under our protocol. Voyager and Echo are adapted to the same low-level action interface, which fixes the action capabilities supplied in advance. Voyager’s expert-written control primitives are listed separately from Mineflayer’s API in its own appendix; our protocol studies the acquisition of such composite capabilities. This design addresses acquisition from a common interface and keeps every method on the same atomic API. Under this bare API, Voyager’s hard-coded first task can fail repeatedly; Appendix § 12.§ 3 reports this as a concrete limitation of our adaptation. The external comparisons characterize the adapted implementations under our interface. Voyager keeps its automatic curriculum, iterative code generation with execution feedback, self-verification and per-agent skill library; Echo keeps its structured experience and analogy-induced tasks. The comparison therefore remains a comparison of mechanisms. The no-sharing condition −S is an internal control that retains each agent’s private graph, skills, and reflection while removing both sharing channels. Table 11 (Appendix § 9.10) places the prior systems along the axes the mechanism sections isolate.
Full main results
Tables 1 and 2 pool the runs of each cell; Table 13 lists those runs individually, numbered in launch order. All runs use world seed 7 and the natural spawn point of that seed; the rows of a cell differ only through the uncontrolled randomness listed in Appendix § 12.§ 1, so the spread across them is that cell’s run-to-run spread.
| Backbone | Run | Deaths ↓ | XP/life ↑ | Tool era | Obsidian | Nether |
| DS-V4.1F | Voyager-1 | 325.0 | 0.7 | iron (2.3 day, 3/3) | — | — |
| Voyager-2 | 412.0 | 0.5 | iron (2.5 day, 2/3) | — | — | |
| Voyager-3 | 167.7 | 1.7 | dmd. (3.0 day, 1/3) | — | — | |
| Voyager-4 | 280.7 | 0.6 | iron (2.3 day, 3/3) | — | — | |
| Voyager-5 | 205.3 | 0.9 | iron (2.3 day, 3/3) | — | — | |
| Voyager-6 | 208.3 | 1.1 | iron (3.7 day, 3/3) | — | — | |
| Voyager-7 | 213.7 | 0.8 | iron (2.0 day, 3/3) | — | — | |
| Voyager-8 | 162.0 | 0.8 | iron (2.0 day, 2/3) | — | — | |
| Voyager-9 | 121.7 | 1.7 | iron (1.7 day, 3/3) | — | — | |
| Voyager-10 | 193.0 | 1.3 | iron (2.3 day, 3/3) | — | — | |
| Echo-1 | 87.0 | 3.4 | dmd. (10.7 day, 3/3) | — | — | |
| Echo-2 | 79.7 | 2.4 | dmd. (25.5 day, 2/3) | — | — | |
| Echo-3 | 105.0 | 2.5 | dmd. (17.0 day, 3/3) | — | — | |
| Echo-4 | 88.0 | 4.8 | dmd. (12.7 day, 3/3) | — | — | |
| Echo-5 | 35.0 | 8.9 | dmd. (24.0 day, 3/3) | — | — | |
| Echo-6 | 46.3 | 4.7 | dmd. (4.0 day, 1/3) | — | — | |
| Echo-7 | 78.3 | 3.5 | dmd. (15.3 day, 3/3) | — | — | |
| Echo-8 | 83.7 | 3.7 | dmd. (18.7 day, 3/3) | — | — | |
| Echo-9 | 74.3 | 3.2 | dmd. (9.5 day, 2/3) | — | — | |
| Echo-10 | 57.7 | 5.1 | dmd. (14.3 day, 3/3) | — | — | |
| Planner-only-1 | 20.7 | 22.8 | dmd. (15.5 day, 2/3) | — | — | |
| Planner-only-2 | 21.7 | 16.6 | dmd. (10.0 day, 2/3) | — | — | |
| Planner-only-3 | 28.7 | 12.9 | dmd. (19.0 day, 2/3) | — | — | |
| Planner-only-4 | 28.3 | 15.3 | dmd. (13.3 day, 3/3) | — | — | |
| Planner-only-5 | 41.3 | 7.8 | dmd. (26.0 day, 1/3) | — | — | |
| Planner-only-6 | 19.0 | 16.1 | dmd. (14.0 day, 2/3) | — | — | |
| Planner-only-7 | 28.0 | 10.9 | dmd. (8.0 day, 1/3) | — | — | |
| Planner-only-8 | 26.7 | 14.8 | dmd. (15.0 day, 2/3) | — | — | |
| Planner-only-9 | 39.7 | 11.4 | dmd. (22.0 day, 1/3) | — | — | |
| Backbone | Run | Deaths ↓ | XP/life ↑ | Tool era | Obsidian | Nether |
| Planner-only-10 | 27.0 | 11.4 | iron (2.7 day, 3/3) | — | — | |
| OpenKAGE-1 | 26.0 | 15.4 | dmd. (8.0 day, 3/3) | 17.0 day (1/3; Carol) | 23.0 day (1/3; Carol) | |
| OpenKAGE-2 | 19.7 | 10.9 | dmd. (11.0 day, 3/3) | — | — | |
| OpenKAGE-3 | 17.7 | 7.8 | dmd. (20.0 day, 2/3) | — | — | |
| OpenKAGE-4 | 13.0 | 24.0 | dmd. (16.7 day, 3/3) | 27.5 day (2/3; Alice, Carol) | — | |
| OpenKAGE-5 | 10.7 | 13.0 | dmd. (8.0 day, 1/3) | — | — | |
| OpenKAGE-6 | 9.7 | 27.7 | dmd. (16.0 day, 3/3) | 20.0 day (1/3; Bob) | 23.0 day (1/3; Bob) | |
| OpenKAGE-7 | 17.7 | 10.6 | dmd. (12.7 day, 3/3) | 22.5 day (2/3; Alice, Carol) | 24.5 day (2/3; Alice, Carol) | |
| OpenKAGE-8 | 12.0 | 27.8 | dmd. (9.0 day, 1/3) | — | — | |
| OpenKAGE-9 | 25.7 | 6.1 | dmd. (17.5 day, 2/3) | — | — | |
| OpenKAGE-10 | 10.0 | 38.8 | dmd. (14.3 day, 3/3) | — | — | |
| GLM-5.3 | Planner-only-1 | 30.7 | 16.0 | dmd. (7.7 day, 3/3) | — | — |
| Planner-only-2 | 42.0 | 6.7 | dmd. (7.5 day, 2/3) | — | — | |
| Planner-only-3 | 42.3 | 5.2 | dmd. (15.5 day, 2/3) | — | — | |
| Planner-only-4 | 41.7 | 4.5 | dmd. (28.5 day, 2/3) | — | — | |
| Planner-only-5 | 17.7 | 15.1 | dmd. (13.0 day, 3/3) | — | — | |
| Planner-only-6 | 34.3 | 7.2 | dmd. (12.0 day, 1/3) | — | — | |
| Planner-only-7 | 37.3 | 6.5 | dmd. (19.0 day, 1/3) | — | — | |
| Planner-only-8 | 29.7 | 6.0 | dmd. (19.0 day, 1/3) | — | — | |
| Planner-only-9 | 27.3 | 8.1 | dmd. (19.7 day, 3/3) | — | — | |
| Planner-only-10 | 31.0 | 6.1 | dmd. (15.0 day, 3/3) | — | — | |
| OpenKAGE-1 | 30.7 | 22.5 | dmd. (12.7 day, 3/3) | 24.5 day (2/3; Alice, Carol) | — | |
| OpenKAGE-2 | 50.7 | 4.8 | dmd. (12.0 day, 3/3) | 23.5 day (2/3; Bob, Carol) | — | |
| OpenKAGE-3 | 21.7 | 23.7 | dmd. (12.0 day, 3/3) | — | — | |
| OpenKAGE-4 | 53.0 | 9.9 | dmd. (14.3 day, 3/3) | 24.0 day (2/3; Alice, Bob) | 28.0 day (1/3; Alice) | |
| OpenKAGE-5 | 51.7 | 24.3 | dmd. (14.3 day, 3/3) | — | — | |
| OpenKAGE-6 | 25.0 | 9.9 | dmd. (14.5 day, 2/3) | 25.0 day (2/3; Alice, Bob) | — | |
| OpenKAGE-7 | 9.7 | 62.5 | dmd. (15.3 day, 3/3) | 29.0 day (1/3; Alice) | — | |
| OpenKAGE-8 | 17.3 | 24.0 | dmd. (16.5 day, 2/3) | — | — | |
| OpenKAGE-9 | 14.3 | 33.8 | dmd. (14.3 day, 3/3) | — | — | |
| OpenKAGE-10 | 12.0 | 25.4 | dmd. (12.7 day, 3/3) | 16.0 day (1/3; Bob) | 26.0 day (1/3; Bob) | |
| hy4-preview | Planner-only-1 | 37.7 | 9.7 | dmd. (15.0 day, 3/3) | — | — |
| Planner-only-2 | 45.0 | 9.0 | dmd. (18.0 day, 3/3) | — | — | |
| Planner-only-3 | 65.0 | 5.0 | dmd. (19.3 day, 3/3) | — | — | |
| Planner-only-4 | 66.7 | 5.9 | dmd. (16.0 day, 3/3) | — | — | |
| Planner-only-5 | 37.7 | 7.9 | dmd. (14.3 day, 3/3) | — | — | |
| Planner-only-6 | 61.0 | 5.2 | dmd. (9.3 day, 3/3) | — | — | |
| Planner-only-7 | 35.7 | 11.8 | dmd. (9.3 day, 3/3) | — | — | |
| Planner-only-8 | 46.3 | 10.4 | dmd. (21.7 day, 3/3) | — | — | |
| Planner-only-9 | 47.0 | 6.6 | dmd. (23.0 day, 3/3) | — | — | |
| Planner-only-10 | 28.0 | 10.9 | dmd. (18.0 day, 2/3) | — | — | |
| OpenKAGE-1 | 18.7 | 17.1 | dmd. (25.0 day, 3/3) | — | — | |
| OpenKAGE-2 | 5.3 | 78.0 | iron (3.0 day, 3/3) | — | — | |
| OpenKAGE-3 | 15.7 | 65.8 | dmd. (13.0 day, 2/3) | — | — | |
| OpenKAGE-4 | 15.3 | 12.2 | dmd. (12.0 day, 2/3) | 28.0 day (1/3; Carol) | 29.0 day (1/3; Carol) | |
| OpenKAGE-5 | 16.0 | 8.9 | iron (4.7 day, 3/3) | — | — | |
| OpenKAGE-6 | 20.3 | 15.1 | dmd. (17.0 day, 1/3) | — | — | |
| OpenKAGE-7 | 9.7 | 42.2 | dmd. (19.5 day, 2/3) | — | — | |
| OpenKAGE-8 | 18.0 | 12.9 | dmd. (25.0 day, 2/3) | — | — | |
| OpenKAGE-9 | 23.0 | 25.9 | dmd. (13.0 day, 1/3) | — | — | |
| OpenKAGE-10 | 14.3 | 45.4 | iron (3.0 day, 3/3) | — | — | |
| Kimi-K3 | Planner-only-1 | 49.3 | 6.1 | dmd. (24.5 day, 2/3) | — | — |
| Planner-only-2 | 77.3 | 4.0 | dmd. (22.5 day, 2/3) | — | — | |
| Planner-only-3 | 71.7 | 10.2 | dmd. (26.0 day, 1/3) | — | — | |
| Planner-only-4 | 93.7 | 7.5 | dmd. (15.5 day, 2/3) | — | — | |
| Planner-only-5 | 53.3 | 8.5 | dmd. (30.0 day, 1/3) | — | — | |
| Planner-only-6 | 54.7 | 7.0 | dmd. (11.5 day, 2/3) | — | — | |
| Planner-only-7 | 101.7 | 4.5 | dmd. (24.0 day, 1/3) | — | — | |
| Planner-only-8 | 41.0 | 7.7 | dmd. (19.0 day, 2/3) | — | — | |
| Planner-only-9 | 39.7 | 7.8 | dmd. (30.0 day, 2/3) | — | — | |
| Planner-only-10 | 71.3 | 6.7 | iron (2.7 day, 3/3) | — | — | |
| OpenKAGE-1 | 41.7 | 5.3 | dmd. (20.0 day, 1/3) | — | — | |
| OpenKAGE-2 | 39.0 | 4.6 | dmd. (12.0 day, 1/3) | — | — | |
| OpenKAGE-3 | 41.3 | 6.2 | dmd. (15.0 day, 1/3) | 20.0 day (1/3; Alice) | — | |
| OpenKAGE-4 | 32.3 | 4.7 | iron (2.0 day, 3/3) | — | — | |
| OpenKAGE-5 | 59.0 | 5.4 | iron (3.7 day, 3/3) | — | — | |
| OpenKAGE-6 | 24.7 | 16.1 | dmd. (20.5 day, 2/3) | — | — | |
| OpenKAGE-7 | 56.7 | 7.3 | dmd. (18.5 day, 2/3) | 24.0 day (1/3; Alice) | — | |
| OpenKAGE-8 | 27.7 | 7.5 | dmd. (22.0 day, 1/3) | — | — | |
| OpenKAGE-9 | 33.3 | 4.5 | dmd. (27.0 day, 1/3) | — | — | |
| OpenKAGE-10 | 64.0 | 3.7 | dmd. (17.0 day, 1/3) | — | — |
Table 13. Per-run values behind Tables 1 and 2: one row per run of three agents (ten per cell, in launch order; seed 7), with metrics as in Table 1 computed over the run’s agents; Tool era gives the highest tier reached in the run. A dash means no agent reached the milestone within 30 game days. Names following a milestone count are the personas of Table 8.
Run-level distributions. Figure 9 shows every run behind Table 2 rather than the cell means. The separation in deaths is not driven by a few runs: on hy4-preview and DS-V4.1F all ten OpenKAGE runs die less than the median planner-only run, and on Kimi-K3 nine of ten do. GLM-5.3 is the exception: seven of its OpenKAGE runs lie below the planner-only median, but three runs with more than 50 deaths per agent pull its mean up, which is why its mean difference in deaths is small. XP per life shows the reverse picture on GLM-5.3, where OpenKAGE runs spread upwards and the control’s stay low.
| Backbone | Method | Deaths ↓ | Repeat ↓ | XP/life ↑ | Tool era | Obsidian | Nether |
| DS-V4.1F | Planner-only | 27.9 | 15.1 | 14.0 | dmd. (15.2 day, 16/30) | — | — |
| DS-V4.1F | OpenKAGE | 16.2 | 7.4 | 18.2 | dmd. (13.7 day, 24/30) | 22.8 day (6/30) | 23.8 day (4/30) |
| GLM-5.3 | Planner-only | 33.4 | 17.4 | 8.1 | dmd. (15.2 day, 21/30) | — | — |
| GLM-5.3 | OpenKAGE | 28.6 | 16.9 | 24.1 | dmd. (13.8 day, 28/30) | 23.9 day (10/30) | 27.0 day (2/30) |
| hy4-preview | Planner-only | 47.0 | 28.8 | 8.2 | dmd. (16.3 day, 29/30) | — | — |
| hy4-preview | OpenKAGE | 15.6 | 8.3 | 32.4 | dmd. (18.8 day, 13/30) | 28.0 day (1/30) | 29.0 day (1/30) |
| Kimi-K3 | Planner-only | 64.9 | 48.7 | 7.0 | dmd. (21.7 day, 15/30) | — | — |
| Kimi-K3 | OpenKAGE | 42.1 | 27.0 | 6.5 | dmd. (19.1 day, 10/30) | 22.0 day (2/30) | — |
Table 2. OpenKAGE and its planner-only control across backbones (30 game days, 10 runs of three agents per cell). All metrics and conventions are as in Table 1; — means none attained.
Figure 9. Run-level values behind Table 2: one dot per run (per-agent mean over its three agents), with the cell mean as a horizontal bar. (a) Deaths. (b) XP per life. (c) Milestones unlocked.
Deaths over time. Figure 10 plots deaths per agent per day for OpenKAGE and its planner-only control on each backbone. OpenKAGE dies less on most days, 21 to 29 of the 30 depending on the backbone (on the smoothed curves of Figure 10). On hy4-preview and Kimi-K3 its daily rate also falls over the 30 days, while the control’s stays level or rises; on hy4-preview the change from the first to the last ten days differs between the two ( vs. deaths per agent). On DS-V4.1F both curves are roughly flat, and on GLM-5.3 the rate of OpenKAGE rises over the horizon while staying below the control’s, so on these two backbones the reduction is a lower level rather than a steeper decline.
Figure 10. Deaths per agent per day (three-day moving average) for OpenKAGE and its planner-only control on each backbone: mean over 10 runs of three agents, with a band of ±1 standard error across runs. Each panel has its own vertical scale.
Growth and reuse of the skill library. On the default backbone, the skill library available to each agent grows almost linearly over the 30 days, from 47.8 skills on day 10 to 90.3 on day 20 and 132.5 on day 30 (Figure 11a). Each agent writes about 44 of these skills itself, close to an agent that shares nothing (40.3 under ), so the shaded gap in Figure 11a, roughly two thirds of the library, comes from teammates. On every backbone, 62 to 65% of all skill calls invoke a skill written by another agent of the group. How large the library grows depends on the backbone, from about 35 to 40 skills per agent on GLM-5.3 and Kimi-K3 to about 130 to 140 on DS-V4.1F and hy4-preview, in line with the backbones’ differences in milestone attainment. On DS-V4.1F, the ten groups called 462 distinct skills, and 358 of these were called at least once by an agent other than their author.

Figure 11. Growth and reuse of the shared skill library (10 runs of three agents per curve). (a) Skills available to an agent on DeepSeek-V4.1-Flash: under Full the whole group library, of which the agent wrote only the self-written part and the shaded gap comes from teammates; under −S only the skills it wrote. (b) Share of skill calls that raised an error, for own and teammates’ skills on each backbone (bars pool ten runs, dots are single runs). (c) DS-V4.1F: each thin line is one of the 151 revisions after which the skill was called again, joining its failure share before and after; the thick line pools all.
A call counts as failed when the skill raised an error. The failure rate differs between backbones, from about 1.5% of calls on hy4-preview to 14% on GLM-5.3, but on none of them does it differ by more than about one and a half percentage points between an agent’s own skills and its teammates’ Figure 11b; on DS-V4.1F it is 5.6% of 3,526 calls for teammates’ skills against 6.9% of 2,206 for the agent’s own. A skill written by one agent therefore fails about as often in the hands of another as in its author’s. These rates measure execution errors only; a call that returned without error need not have reached its goal.
Revision of skills after failed calls. Skills are not written once and left. Each night the author of a skill sees its accumulated successes and failures, with samples of the error messages, and may rewrite its code or take it out of circulation. On DS-V4.1F, authors revised the code of 160 skills in 232 revisions (one revision for 117 skills, two for 26, three to nine for the other 17) and took skills out of circulation 50 times. In 225 of the 232 revisions the skill had at least one failed call since it was written or last revised. For the 151 of these revisions after which the skill was called again, the failure rate of its calls fell from 31.3% of 706 calls before the revision to 7.3% of 1,624 calls after it (Figure 11c). Across the 151 revisions the failure rate fell for 109, was unchanged for 13 and rose for 29, and was zero after the revision for 81. This is not a causal estimate: skills enter the comparison because they failed, so part of the fall is regression to the mean, and the windows are counted by day, not by call. The rate after revision remains above the 6.1% failure rate of all calls. Revisions do not always succeed, and a revision can trade one error for another; of the 29 rises, 23 rest on three or fewer calls after the revision. Table 14 lists four revisions with the error that triggered each.
| Skill | Error before | Change | Before | After |
build_box_hut_with_door | doorCell is not iterable | Reads the door cell as an array and guards a missing door | 1/1 | 1/0 |
seal_side_shelter_and_torch | origin is not iterable | Normalises the origin argument to an array before use | 0/2 | 3/0 |
place_block_clear_of_self | no support block below target | Checks the block below the target and returns early when absent | 3/1 | 14/0 |
dig_and_seal_pit | timeout after 5100 ms | Replaces tick waits with a timed sleep | 2/1 | 1/0 |
Table 14. Examples of skill revisions triggered by failed calls (DS-V4.1F). Calls are counted as successes/failures before the revision (since the skill was written or last revised) and after it. One example per distinct error message is taken in run order, among revisions after which the skill did not fail again.
Ablation conditions
What each condition of § 3.3 leaves intact matters for reading the gaps, so it is stated per condition.
Raw. Direct sharing (no consolidation). No component is removed: private graphs, subgraph retrieval, the memory layer, the shared graph and cross-agent skill reuse all stay as in Full. Only the aggregation step changes: at each window the three agents’ experience-layer concepts, facets and edges are appended to the shared graph verbatim, with window–arm prefixes on slugs, no merging or selection, and no edges crossing into the memory layer; the aggregation agent is not called. Retrieval budgets, skill sharing and layer clearing are unchanged; its comparison with Full is reported below.
−S. No sharing (individual memory). Private graphs and subgraph retrieval stay; both sharing channels go: no aggregation (the shared graph stays empty, retrieval sees only the agent’s own graph) and no cross-agent skill reuse (skills are read from the author’s library only).
−R. Flat retrieval (RAG-style). The full knowledge pipeline stays, including writing, aggregation, sharing, skill retrieval and the vector anchoring step with the same relative gate. Retrieval then stops at the anchors: it returns their facets as a flat list, with no relational expansion, no edge structure in the result, and the agent’s expand tool is removed. The condition applies to both the private and the shared graph. The three removals are bundled, so the comparison with Full does not separate multi-hop expansion from seeing the edges, and −R also reads less retrieved text when the plan is set (Appendix § 12.7). On the default backbone the agents of Full rarely call retrieve themselves (67 calls in 10 runs, 57 of them at one hop) and never call expand, so the difference arises mostly in the retrieval that setting a plan triggers. Only retrieval varies, though the knowledge agents subsequently act on may diverge as they take different actions.
−M. No memory layer. The experience layer, aggregation, the shared graph, and skills all keep operating; reflection no longer writes memory concepts and the morning injection disappears. Unlike the others, this one varies which layer stores knowledge, not what is stored.
−E. No experience layer. Reflection writes only to the memory layer: no textual experience record is written and the skill channel is off, so no skill is created, maintained, injected or reused across agents. The aggregator receives nothing, the shared graph stays empty, and experience retrieval returns nothing.
B. No graph (bare model). Removes every graph, private and shared: no memory, no aggregation, and no skills. This is the no-graph control of the main experiment, here also the floor of the suite.
Two caveats follow from the design itself. First, −S and −E both leave the shared graph empty; they differ in whether the agent’s private experience is still written. It is under −S but not under −E, so their gaps overlap by construction and must not be read as additive independent contributions. Second, the run-to-run spread within a condition is wide (Table 15), so small differences in Deaths and XP/life between conditions are read as lying within that spread.
| Run | Deaths ↓ | XP/life ↑ | Tool era | Obsidian | Nether |
| Raw-1 | 17.3 | 35.2 | dmd. (16.5 day, 2/3) | — | — |
| Raw-2 | 8.0 | 29.1 | dmd. (22.0 day, 1/3) | — | — |
| Raw-3 | 10.7 | 35.6 | dmd. (9.0 day, 2/3) | — | — |
| Raw-4 | 32.0 | 16.5 | dmd. (11.0 day, 3/3) | — | — |
| Raw-5 | 15.7 | 9.6 | dmd. (15.5 day, 3/3) | — | — |
| Raw-6 | 16.3 | 19.5 | dmd. (9.0 day, 2/3) | — | — |
| Raw-7 | 7.3 | 29.3 | iron (2.3 day, 3/3) | — | — |
| Raw-8 | 13.3 | 12.8 | iron (2.3 day, 3/3) | — | — |
| Raw-9 | 39.0 | 19.6 | dmd. (13.5 day, 2/3) | — | — |
| Raw-10 | 16.7 | 8.3 | iron (2.7 day, 3/3) | — | — |
| −S-1 | 27.0 | 15.1 | dmd. (9.0 day, 2/3) | — | — |
| −S-2 | 20.7 | 16.1 | dmd. (18.3 day, 2/3) | 14.0 day (1/3; Carol) | 21.0 day (1/3; Carol) |
| −S-3 | 13.7 | 14.5 | dmd. (8.0 day, 2/3) | — | — |
| Run | Deaths ↓ | XP/life ↑ | Tool era | Obsidian | Nether |
| −S-4 | 18.7 | 10.8 | dmd. (9.0 day, 3/3) | — | — |
| −S-5 | 15.7 | 8.4 | dmd. (16.0 day, 2/3) | — | — |
| −S-6 | 24.7 | 6.3 | dmd. (17.5 day, 2/3) | — | — |
| −S-7 | 14.7 | 21.5 | dmd. (13.0 day, 3/3) | 29.0 day (1/3; Bob) | — |
| −S-8 | 13.7 | 15.9 | dmd. (14.3 day, 3/3) | — | — |
| −S-9 | 10.7 | 46.7 | dmd. (14.0 day, 1/3) | — | — |
| −S-10 | 14.7 | 6.3 | iron (5.0 day, 3/3) | — | — |
| −R-1 | 19.7 | 8.3 | dmd. (17.0 day, 1/3) | — | — |
| −R-2 | 17.0 | 14.1 | dmd. (16.0 day, 2/3) | — | — |
| −R-3 | 22.0 | 7.9 | dmd. (10.0 day, 2/3) | — | — |
| −R-4 | 12.7 | 19.1 | dmd. (7.0 day, 2/3) | — | — |
| −R-5 | 15.7 | 9.0 | dmd. (17.0 day, 1/3) | — | — |
| −R-6 | 17.0 | 7.2 | iron (4.3 day, 3/3) | — | — |
| −R-7 | 13.7 | 12.1 | iron (4.0 day, 3/3) | — | — |
| −R-8 | 8.3 | 28.7 | dmd. (20.0 day, 2/3) | — | — |
| −R-9 | 19.7 | 7.5 | iron (4.7 day, 3/3) | — | — |
| −R-10 | 10.7 | 18.6 | dmd. (10.0 day, 2/3) | — | — |
| −M-1 | 8.3 | 33.4 | dmd. (12.5 day, 2/3) | — | — |
| −M-2 | 5.0 | 103.1 | dmd. (21.7 day, 3/3) | — | — |
| −M-3 | 6.3 | 58.8 | dmd. (22.0 day, 1/3) | — | — |
| −M-4 | 16.0 | 11.5 | iron (2.7 day, 3/3) | — | — |
| −M-5 | 17.3 | 16.5 | dmd. (21.0 day, 2/3) | — | — |
| −M-6 | 13.3 | 19.1 | dmd. (20.5 day, 2/3) | — | — |
| −M-7 | 9.3 | 18.8 | dmd. (13.0 day, 1/3) | — | — |
| −M-8 | 14.0 | 28.5 | dmd. (18.5 day, 2/3) | — | — |
| −M-9 | 8.7 | 57.6 | dmd. (14.7 day, 3/3) | — | — |
| −M-10 | 17.7 | 30.1 | dmd. (17.3 day, 3/3) | — | — |
| −E-1 | 6.3 | 37.6 | dmd. (4.0 day, 1/3) | — | — |
| −E-2 | 8.7 | 14.1 | dmd. (29.0 day, 1/3) | — | — |
| −E-3 | 16.7 | 44.0 | dmd. (12.5 day, 2/3) | — | — |
| −E-4 | 18.7 | 26.6 | dmd. (16.5 day, 2/3) | — | — |
| −E-5 | 16.7 | 15.9 | dmd. (12.5 day, 2/3) | — | — |
| −E-6 | 26.3 | 6.6 | dmd. (18.0 day, 1/3) | — | — |
| −E-7 | 15.7 | 15.6 | dmd. (8.0 day, 1/3) | — | — |
| −E-8 | 13.7 | 25.9 | dmd. (14.7 day, 3/3) | — | — |
| −E-9 | 10.7 | 12.8 | dmd. (17.0 day, 1/3) | — | — |
| −E-10 | 11.3 | 17.9 | dmd. (7.0 day, 1/3) | — | — |
Table 15. Per-run values of the ablated conditions (DeepSeek-V4.1-Flash, 30 game days, world seed 7), one row per run of three agents (including the Raw condition), in launch order and in the conventions of Table 13; missing entries name the agents as in Table 13 (personal in Table 8).
Table 15 lists the ten runs of each ablation condition, including Raw, in the conventions of Table 1. Full and B are the DS-V4.1F OpenKAGE and planner-only rows of Table 13.
Raw: consolidation versus direct sharing. Full and Raw share the horizon, group size, world seed and hyperparameters, and the same records reach the shared graph in both; only their organisation differs. Table 3 summarizes both cells (ten runs each) and Table 15 lists the Raw runs.
| Condition | Deaths ↓ | Repeat ↓ | XP/life ↑ | Tool era | Obsidian | Nether |
| Full | 16.2 | 7.4 | 18.2 | dmd. (13.7 day, 24/30) | 22.8 day (6/30) | 23.8 day (4/30) |
| Raw | 17.6 | 10.8 | 21.6 | dmd. (13.0 day, 14/30) | — | — |
| −S | 17.4 | 8.1 | 16.1 | dmd. (13.3 day, 21/30) | 21.5 day (2/30) | 21.0 day (1/30) |
| −R | 15.6 | 7.4 | 13.3 | dmd. (13.3 day, 12/30) | — | — |
| −M | 11.6 | 4.1 | 37.7 | dmd. (17.9 day, 19/30) | — | — |
| −E | 14.5 | 7.4 | 21.7 | dmd. (14.0 day, 15/30) | — | — |
| B | 27.9 | 15.1 | 14.0 | dmd. (15.2 day, 16/30) | — | — |
Table 3. Ablation results (DeepSeek-V4.1-Flash, 30 game days, 10 runs per condition; metrics as in Table 1). Conditions are named by what they remove: −S sharing, −R subgraph retrieval, −M the memory layer, −E the experience layer, B all graphs; Raw keeps every component but shares experience records verbatim (Appendix § 12.§ 5).
The mean differences are small at this sample size: repeated deaths are 7.4 vs. 10.8, the weakest agent’s XP/life 7.9 vs. 5.9, mean deaths 16.2 vs. 17.6 and mean XP/life 18.2 vs. 21.6; obsidian is 6/30 vs. 0/30 and the Nether 4/30 vs. 0/30. All three agents of a group obtain a diamond pickaxe in 6 of 10 Full runs and 1 of 10 Raw runs. With 10 runs per condition, the means of Raw and Full lie within each other’s run-to-run spread, and the deep-milestone counts are small for both. The sharing channel is used almost equally in both conditions (62% vs. 60% of skill calls invoke another agent’s skill, 94% and 95% success), so the comparison varies how the shared records are organised while the sharing channel is active. The link from the structure of the shared graph to behaviour is descriptive here.
Scaling: long-horizon accumulation and group size
Sections 3.2–3.4 show that OpenKAGE reaches milestones the baseline does not reach, and that knowledge accumulates transfers to a fresh group on another backbone. Two questions remain. Does per-agent progress grow when the group grows? Does progress keep accumulating once the horizon is doubled? The following runs examine both axes, group size and time horizon; they are supplementary: each curve is one run, so they support observations rather than conclusions.
Similar endpoints across evaluated group sizes. Groups of , 5 and 8 agents running 30 game days each reach comparable endpoints; the gaps between them are smaller than the spread across the agents of any one group (Figure 12(a)). With one run per group size, this shows no group-size effect within the observed spread, not that none exists.
Figure 12. Scaling in group size and time horizon (GLM-5.3-Flash). Mean milestones per agent, bands ±1 sd across agents; each curve is a single run. (a) , 5, 8 agents, 30 game days. (b) OpenKAGE and the baseline over 60 game days at .
Time scale: a longer horizon reaches the next milestone. At , extending the protocol from 30 to 60 game days lets OpenKAGE reach obsidian on day 54 (1 of 3 agents). The baseline, given the same 60 days, stalls at a bottleneck from day 40 on, and no agent reaches obsidian (Figure 12(b)).
GLM-5.3-Flash is a weak backbone: deep milestones stay out of reach. The target backbone of the transfer experiment (§ 3.4) is a small model, and its own ceiling bounds what that experiment can show. The scaling runs above, all on GLM-5.3-Flash and starting from empty stores, give that ceiling. Enlarging the group to or agents does not carry any of them to obsidian or the Nether within 30 game days (Figure 12(a)); even doubling the horizon to 60 game days yields obsidian for only 1 of 3 agents, on day 54, and no agent enters the Nether (Figure 12(b)). In the transfer experiment, by contrast, one of nine agents obtains obsidian within 30 days. Thus on this weak backbone the accumulated knowledge reaches, within 30 days, a milestone that groups starting from empty stores do not reach with more agents or with the same 30-day horizon.
Inference cost
Game time is paused during deliberation, so a fixed number of game days does not fix the inference budget. Table 16 counts what each condition spends per game night, and Table 17 splits OpenKAGE’s share by component and reports the wall-clock hours of a complete run for each condition.
| Backbone | Method | LLM calls | Steps / agent |
| DS-V4.1F | Voyager | 439 | 66.8 |
| Echo | 336 | 56.7 | |
| Planner-only | 136 | 39.3 | |
| OpenKAGE | 164 | 32.5 | |
| Raw | 179 | 36.6 | |
| −S | 150 | 30.1 | |
| −R | 172 | 32.3 | |
| −M | 183 | 37.9 | |
| −E | 175 | 41.8 | |
| GLM-5.3 | Planner-only | 87 | 27.3 |
| OpenKAGE | 136 | 31.4 | |
| hy4-preview | Planner-only | 160 | 46.9 |
| OpenKAGE | 219 | 40.3 | |
| Kimi-K3 | Planner-only | 115 | 42.2 |
| OpenKAGE | 127 | 35.8 |
Table 16. Inference cost per game night (30 game days, ten runs of each cell). Calls are LLM calls of the whole group of three agents; steps are executed environment steps per agent.
| Component | Planner-only Calls | Planner-only Text (k) | OpenKAGE Calls | OpenKAGE Text (k) |
| Planning and execution | 136.0 | 98 | 110.1 | 155 |
| Reflection | — | — | 46.4 | 221 |
| Aggregation | — | — | 7.5 | 38 |
| Total | 136 | 98 | 164 | 414 |
| Wall-clock hours per run | 7.6 | 12.1 |
Table 17. Inference cost on DS-V4.1F (ten runs per condition, three agents): calls and saved text volume per game night by component, and mean wall-clock hours of a complete 30-night run. Text volume is saved message characters divided by 1.7, an estimate of tokens; each message is counted once, so it is not billed tokens, which also include re-sent history. The runs carry no token log.
On the default backbone OpenKAGE makes 21% more LLM calls than the planner-only control (164 vs. 136 per night), while executing slightly fewer environment steps per agent (32 vs. 39). The two external baselines make more calls than OpenKAGE (336 and 439) and take more steps per agent (57 and 67). Reflection and aggregation account for 53 of OpenKAGE’s 164 calls per night (32%); on the other backbones the extra calls over the planner-only control range from 12 to 59 per night. All cells are counted in the same way.
By this measure OpenKAGE processes about 4.2 times as much text per night as the planner-only control (per-run range 389–449k vs. 91–107k): 62% of it is reflection and aggregation, which read each agent’s day, and planning itself carries 1.6 times the text because retrieved knowledge and the morning injection enter the prompts, even though it makes fewer calls. The extra cost of the knowledge components is therefore larger in text than in calls, and we make no claim about computational efficiency; the results establish progress and survival within a fixed game horizon.
Full and −R are not at equal retrieval budget (ten runs and all three agents per condition, mean over the 30 days; ranges are across runs). The user prompt that opens a day has 13,295 characters under Full (11,416–15,722) and 14,800 under −R (12,495–17,435). It carries the agent’s memory layer, injected each morning and untouched by −R, so its length reflects how much the agents of each run wrote, not the retrieval mechanism. The block of experience and skills returned when the agent sets its plan is longer under Full (14,788 characters, 13,284–16,124) than under −R (11,901, 10,795–14,568), about 24% more retrieved text at that point. Over a whole run Full processes about 6% more text than −R (414k vs. 390k per night) with a similar number of LLM calls (164 vs. 172), so the difference in retrieval is real but small next to the text spent on reflection and aggregation, which both conditions keep. The other ablations, which remove memory, experience or sharing, change what is written and read, so their costs in Table 16 describe different amounts of work, not the same work done more cheaply.
References
- [1]Petr Anokhin, Nikita Semenov, Artyom Sorokin, Dmitry Evseev, Andrey Kravchenko, Mikhail Burtsev, and Evgeny Burnaev. AriGraph: Learning knowledge graph world models with episodic memory for LLM agents. In Proceedings of the Thirty-Fourth International Joint Conference on Artificial Intelligence (IJCAI), pp. 12–20, 2025. URL https://arxiv.org/abs/2407.04363.
- [2]Bowen Baker, Ilge Akkaya, Peter Zhokhov, Joost Huizinga, Jie Tang, Adrien Ecoffet, Brandon Houghton, Raul Sampedro, and Jeff Clune. Video pretraining (VPT): Learning to act by watching unlabeled online videos. In Advances in Neural Information Processing Systems (NeurIPS), 2022. URL https://arxiv.org/abs/2206.11795.
- [3]Darren Edge, Ha Trinh, Newman Cheng, Joshua Bradley, Alex Chao, Apurva Mody, Steven Truitt, and Jonathan Larson. From local to global: A graph RAG approach to query-focused summarization. arXiv preprint arXiv:2404.16130, 2024. URL https://arxiv.org/abs/2404.16130.
- [4]Matthias Gerstgrasser, Tom Danino, and Sarah Keren. Selectively sharing experiences improves multi-agent reinforcement learning. In Advances in Neural Information Processing Systems, volume 36, 2023. URL https://arxiv.org/abs/2311.00865.
- [5]Danijar Hafner, Jurgis Pasukonis, Jimmy Ba, and Timothy Lillicrap. Mastering diverse domains through world models. arXiv preprint arXiv:2301.04104, 2023. URL https://arxiv.org/abs/2301.04104.
- [6]Sirui Hong, Mingchen Zhuge, Jiaq i Chen, Xiawu Zheng, Yuheng Cheng, Ceyao Zhang, Jinlin Wang, Zili Wang, Steven Ka Shing Yau, Zijian Lin, Liyang Zhou, Chenyu Ran, Lingfeng Xiao, Chenglin Wu, and Jürgen Schmidhuber. MetaGPT: Meta programming for a multi-agent collaborative framework. In International Conference on Learning Representations (ICLR), pp. 23247–23275, 2024. URL https://arxiv.org/abs/2308.00352.
- [7]Dharshan Kumaran, Demis Hassabis, and James L. McClelland. What learning systems do intelligent agents need? complementary learning systems theory updated. Trends in Cognitive Sciences, 20(7):512–534, 2016.DOI










