{"id":"6eaeec59-e9f3-460f-846a-f85d31164ead","arxiv_id":"2605.17721","paper_version":1,"verdict":"UNVERDICTED","confidence":"LOW","novelty_score":7.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"EXG is an experience graph framework for self-evolving LLM agents that supports online real-time growth and offline reuse to enhance solution quality and efficiency on code generation and reasoning benchmarks.","lead":"The paper introduces EXG, a framework that organizes agent experiences into a relational graph to enable self-evolving LLM agents to reuse successes and failures across tasks. This structured approach could improve how agents learn and perform over time in deployment settings.","discovery_kind":"new_method","skeptic_critique":{"model":"grok-4.3","headline":"No significant objection identified","rationale":"Reader correctly flagged the graph-capture-and-reuse assumption as the key uncertainty but could only review the abstract. Full text supplies the missing implementation and experimental grounding, reducing the risk that the assumption is merely asserted. No internal inconsistency or unsupported leap appears in the argument; the empirical trade-off results provide independent support for the headline claim. Verdict therefore stays UNVERDICTED pending deeper reproducibility checks rather than shifting to REJECT or ACCEPT.","tokens_in":1753,"tokens_out":344,"duration_ms":27867,"concrete_test":"Re-run the online evaluation protocol from §4.2 on the same benchmarks while logging per-step graph update latency and retrieval cost; if average overhead exceeds 15% of baseline agent runtime or if cross-task hit rate remains below 40% on held-out task pairs, the immediate-reuse advantage weakens.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim—that structuring accumulated successes and failures into a relational experience graph enables scalable, immediate cross-task reuse in both online and offline settings—rests on the premise that graph construction, edge formation, and retrieval can be performed efficiently enough to outperform ad-hoc reflection and flat memory. With the full manuscript available, the described architecture (node/edge definitions for experience fragments, real-time update rules during execution, and plug-and-play integration) appears internally consistent and directly addresses the fragmentation concern raised in the abstract. Experiments on code generation and reasoning benchmarks report favorable performance-efficiency trade-offs, and the design choices (online growth plus consolidated offline reuse) are presented with sufficient implementation detail to make the claim testable rather than purely aspirational.","agreement_with_reader":"partial"},"referee_report":{"model":"grok-4.3","summary":"The manuscript introduces EXG, an experience graph framework for self-evolving LLM-based agents. It organizes accumulated successes and failures into a structured relational graph that supports online real-time growth during execution for immediate cross-task reuse, as well as offline consolidation and reuse as an external memory module. EXG is presented as a plug-and-play component that can be integrated with existing self-evolving agents to improve solution quality and resource efficiency over time. The authors report extensive experiments on code generation and reasoning benchmarks demonstrating more favorable performance-efficiency trade-offs relative to reflection- and memory-based baselines in both online and offline settings.","tokens_in":1876,"tokens_out":390,"duration_ms":18564,"significance":"If the experimental results hold, the work provides a concrete, graph-structured mechanism for experience reuse that directly targets fragmentation and delayed usability issues in current self-evolving agent designs. The dual support for online growth and offline external-memory use, combined with the plug-and-play integration claim, could offer a reusable primitive for building more adaptive agents. The emphasis on efficiency alongside performance is a practical strength that distinguishes the contribution from purely reflective or flat-memory approaches.","major_comments":[],"minor_comments":[{"comment":"The abstract asserts 'extensive experiments' with favorable trade-offs but does not preview key metrics, baselines, or dataset details; adding a concise summary of the evaluation protocol in the abstract or introduction would improve accessibility.","section":null},{"comment":"Clarify the precise node and edge definitions for experience fragments early in the manuscript (ideally with a small illustrative example) to make the graph-construction rules immediately understandable before the algorithmic description.","section":null},{"comment":"Ensure that the experimental section includes explicit statements of statistical significance or variance across runs for the reported performance-efficiency trade-offs, as this is necessary to support the cross-baseline claims.","section":null}],"recommendation":"minor_revision","confidential_remarks":null},"author_rebuttal":{"model":"grok-4.3","summary":"We thank the referee for the positive summary, recognition of the significance of the EXG framework, and recommendation for minor revision. We are pleased that the dual online/offline design and plug-and-play aspects were viewed favorably.","responses":[],"tokens_in":1282,"tokens_out":63,"duration_ms":29180,"standing_objections":[]},"desk_editor":{"model":"grok-4.3","letter":"The main takeaway is that EXG gives agents a structured graph to store and connect successes and failures instead of scattered reflections or loose memory lists. This setup supports real-time graph growth while the agent is working, so experience can transfer across tasks immediately, plus an offline mode where the full graph acts as external memory for later use. It also works as a plug-in for other self-evolving agent setups.","headline":"EXG turns agent experiences into a graph for online reuse during runs and offline consolidation afterward, with experiments claiming better efficiency than reflection or flat memory on code and reasoning tasks.","tokens_in":2351,"tokens_out":159,"would_cite":false,"duration_ms":35696,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":{"model":"grok-4.3","evidence":[{"relation":"unclear","rs_module":"IndisputableMonolith/Cost/FunctionalEquation.lean","rs_theorem":"washburn_uniqueness_aczel","paper_passage":"EXG abstracts each completed attempt within a trajectory into a case... golden cases... warning cases... experience graph G=(V,E) with case nodes, task anchor nodes, contain/similarity/correction edges"},{"relation":"unclear","rs_module":"IndisputableMonolith/Foundation/RealityFromDistinction.lean","rs_theorem":"reality_from_one_distinction","paper_passage":"online self-evolving loop... offline reuse of a consolidated experience graph as an external memory module"}],"headline":"Experience-graph self-evolution for LLM agents has no structural overlap with RS forcing chain","alignment":"orthogonal","rationale":"The paper's core machinery (case nodes for trajectories, task-anchor nodes, similarity/correction/contain edges, retrieval/reranking over the graph, online/offline reuse) is a standard graph-memory architecture for agent experience reuse. It neither invokes nor parallels any RS primitive: no J-cost functional equation, no phi-ladder or golden-ratio identities, no 8-tick periodicity, no distinction-to-spacetime forcing, and no parameter-free constant derivations. The domain (cs.AI agent memory) lies outside the RS canon; the framework therefore neither confirms nor contradicts the reported performance-efficiency gains.","tokens_in":59196,"confidence":"high","tokens_out":333,"duration_ms":8800,"cache_read_input_tokens":38528,"cache_creation_input_tokens":0},"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"grok-4.3","headline":"EXG turns agent successes and failures into a connected graph for instant reuse across tasks.","keywords":["self-evolving agents","experience graph","LLM agents","structured memory","cross-task reuse","online experience","agent improvement"],"falsifier":"A direct comparison on the same code generation and reasoning benchmarks showing that agents equipped with the experience graph produce no measurable gains in solution quality or resource efficiency over reflection-only or unstructured-memory baselines.","tokens_in":2657,"feed_emoji":"🔗","tokens_out":651,"duration_ms":27426,"temperature":0.7,"pith_summary":"The paper presents EXG as a way to organize what an agent learns from its own runs into a graph that links related successes and failures. This structured form replaces scattered reflections or loose memory stores, letting the agent pull in useful past results right when needed for new problems. A sympathetic reader would see this as a step toward agents that keep getting better on the job rather than staying fixed after initial setup. The graph can grow while the agent works and can also be saved for later use as ready-made memory. Experiments on code and reasoning tasks indicate it delivers better results with less wasted effort than earlier approaches.","feed_headline":"Graph structure lets agents reuse past successes across tasks","feed_subtitle":"By linking successes and failures relationally, agents gain immediate reuse and better efficiency than reflection or loose memory alone.","key_machinery":"The experience graph, which explicitly organizes accumulated successes and failures into a structured, relational representation for real-time growth and consolidated reuse.","core_discovery":"EXG is the first experience graph designed for self-evolving agents, supporting both online, real-time graph growth during execution for immediate cross-task experience reuse, and offline reuse of a consolidated experience graph as an external memory module. This design also enables EXG to serve as a plug-and-play component for existing self-evolving agents, organizing prior experience into a unified experience graph and improving both solution quality and resource efficiency as deployment progresses.","pith_inferences":["The graph approach could be tested in domains beyond code and reasoning, such as tool-use or planning agents, to check whether relational linking scales to longer task chains.","If the structure keeps overhead low, it might reduce reliance on periodic retraining by letting agents carry forward lessons in a compact, queryable form.","Connections to graph-based memory systems in other AI work could be explored to see whether the same relational pattern supports transfer between entirely different agent types."],"forward_implications":["Agents gain immediate cross-task reuse from experiences gathered during execution.","A consolidated graph can be used offline as external memory to boost later performance.","Existing self-evolving agents can adopt the graph as a plug-in to organize their prior experience.","Overall performance-efficiency trade-offs improve compared with ad hoc reflection or fragmented memory."],"fun_headline_variants":["EXG organizes experience into graphs for agent reuse","Agents reuse successes via structured experience graphs","Relational experience graphs support online agent improvement","Experience graphs link successes and failures for self-evolving agents"],"cache_read_input_tokens":64,"weakest_assumption_plain":"Successes and failures accumulated during agent execution can be effectively captured and related in a graph structure that enables immediate and transferable reuse without fragmentation or high overhead.","fun_headline_variants_meta":{"raw":{"variants":["EXG organizes experience into graphs for agent reuse","Agents reuse successes via structured experience graphs","Relational experience graphs support online agent improvement","Experience graphs link successes and failures for self-evolving agents"]},"model":"grok-4.3","cost_usd":0.010419,"raw_usage":{"total_tokens":4541,"prompt_tokens":693,"num_sources_used":0,"completion_tokens":54,"cost_in_usd_ticks":104190500,"prompt_tokens_details":{"text_tokens":693,"audio_tokens":0,"image_tokens":0,"cached_tokens":64},"completion_tokens_details":{"audio_tokens":0,"reasoning_tokens":3794,"accepted_prediction_tokens":0,"rejected_prediction_tokens":0}},"tokens_in":693,"tokens_out":54,"duration_ms":37445,"temperature":1.0,"reasoning_tokens":3794,"cache_read_input_tokens":64,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-05-19T22:14:02.846903+00:00","model_set":{"reader":"grok-4.3"},"falsifier":"A direct comparison on the same code generation and reasoning benchmarks showing that agents equipped with the experience graph produce no measurable gains in solution quality or resource efficiency over reflection-only or unstructured-memory baselines.","supporting_citations":[],"review_version":1}