Paper deep dive
Explainable Innovation Engine: Dual-Tree Agent-RAG with Methods-as-Nodes and Verifiable Write-Back
Renwei Meng
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 94%
Last extracted: 3/13/2026, 12:59:54 AM
Summary
The paper introduces the 'Explainable Innovation Engine', an agentic RAG system that replaces flat text chunking with 'methods-as-nodes'. It utilizes a dual-tree structure: a weighted provenance tree for traceable derivations and a hierarchical clustering abstraction tree for efficient navigation. The system employs a strategy agent for synthesis, a verifier-scorer for pruning, and a write-back mechanism for continual growth, demonstrating significant performance gains in derivation-heavy domains like mathematics and science.
Entities (5)
Relation Signals (4)
Explainable Innovation Engine → maintains → Method Provenance Tree
confidence 98% · The engine maintains a weighted method provenance tree for traceable derivations
Explainable Innovation Engine → maintains → Clustering Abstraction Tree
confidence 98% · and a hierarchical clustering abstraction tree for efficient top-down navigation.
Verifier-Scorer Layer → prunes → Candidate Innovations
confidence 95% · A verifier-scorer layer then prunes low-quality candidates
Strategy Agent → selects → Synthesis Operators
confidence 95% · a strategy agent selects explicit synthesis operators (e.g., induction, deduction, analogy)
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Retrieval-augmented generation (RAG) improves factual grounding, yet most systems rely on flat chunk retrieval and provide limited control over multi-step synthesis. We propose an Explainable Innovation Engine that upgrades the knowledge unit from text chunks to methods-as-nodes. The engine maintains a weighted method provenance tree for traceable derivations and a hierarchical clustering abstraction tree for efficient top-down navigation. At inference time, a strategy agent selects explicit synthesis operators (e.g., induction, deduction, analogy), composes new method nodes, and records an auditable trajectory. A verifier-scorer layer then prunes low-quality candidates and writes validated nodes back to support continual growth. Expert evaluation across six domains and multiple backbones shows consistent gains over a vanilla baseline, with the largest improvements on derivation-heavy settings, and ablations confirm the complementary roles of provenance backtracking and pruning. These results suggest a practical path toward controllable, explainable, and verifiable innovation in agentic RAG systems. Code is available at the project GitHub repository this https URL.
Tags
Links
- Source: https://arxiv.org/abs/2603.09192v1
- Canonical: https://arxiv.org/abs/2603.09192v1
Trouble viewing inline? Open PDF directly →
Full Text
44,189 characters extracted from source content.
Expand or collapse full text
Explainable Innovation Engine: Dual-Tree Agent-RAG with Methods-as-Nodes and Verifiable Write-Back Renwei Meng Anhui University Hefei, China Abstract Retrieval-augmented generation (RAG) improves factual grounding, yet most systems rely on flat chunk retrieval and provide limited control over multi-step synthesis. We propose an Explainable Innovation Engine that upgrades the knowledge unit from text chunks to methods-as-nodes. The engine maintains a weighted method provenance tree for traceable derivations and a hierarchical clustering abstraction tree for efficient top-down navigation. At inference time, a strategy agent selects explicit synthesis operators (e.g., induction/deduction/analogy), composes new method nodes, and records an auditable trajectory; a verifier–scorer layer then prunes low-quality candidates and writes validated nodes back to support continual growth. Expert evaluation across six domains and multiple backbones shows consistent gains over a vanilla baseline, with the largest improvements on derivation-heavy settings, and ablations confirm the complementary roles of provenance backtracking and pruning. These results suggest a practical path toward controllable, explainable, and verifiable innovation in agentic RAG systems.Code is available at: https://github.com/xiaolu-666113/Dual-Tree-Agent-RAG. 1 Introduction Large language models (LLMs) excel at text generation and cross-task transfer, yet they remain limited in knowledge freshness, factual reliability, and provenance: outputs may sound plausible without verifiable support. Retrieval-Augmented Generation (RAG) improves grounding by retrieving external evidence during generation [lewis2020rag], but surveys still highlight persistent challenges in controllability and interpretability for complex synthesis [fan2024ragmeetsllms]. Most RAG deployments follow “flat chunking + vector similarity”: split documents into local chunks and concatenate top-k results. This often breaks for tasks requiring global structure, cross-section integration, and reusable methodological reasoning. Structured retrieval aims to address this: RAPTOR builds hierarchical summary trees for multi-level retrieval [sarthi2024raptor], while GraphRAG uses graphs and community summaries for global synthesis [edge2024graphrag], suggesting that navigable structures can improve both coverage and interpretability. Our goal goes beyond evidence lookup to controllable innovation: proposing new method nodes and conclusions along auditable derivation chains, then filtering and validating them. Agentic paradigms such as ReAct and tree-structured search improve transparency [yao2023react, yao2023treeofthoughts], yet rarely maintain a persistent methodology atlas that encodes “prior methods → derived results” for continual growth. Reliability is pivotal in such loops: Self-RAG and Chain-of-Verification add critique and verify–revise control [asai2024selfrag, dhuliawala2024cove], RAGAS provides reference-free evaluation for iteration [es2024ragas], and formal environments (e.g., LeanDojo, Draft–Sketch–Prove, LEGO-Prover) enable executable checking in high-assurance domains [yang2023leandojo, jiang2023draft, wang2024legoprover]. Motivated by these gaps, we propose an Explainable Innovation Engine that retains RAG as the backbone but upgrades the indexing unit from text chunks to methods-as-nodes. The engine maintains (i) a weighted provenance tree that captures traceable method derivations, and (i) a hierarchical abstraction tree that supports efficient top-down localization and controlled descent [sarthi2024raptor]. At inference time, a strategy controller selects explicit synthesis operators (e.g., induction/deduction/analogy) to compose new method nodes, while a verifier–scorer layer prunes low-quality candidates and writes validated nodes back to enable continual growth. Because real research artifacts are often multimodal, we also discuss practical interfaces for multimodal indexing and extraction [mei2025mrag]. Contributions. (i) A dual-tree, relation-weighted organization of methods-as-nodes for explainable and controllable innovation search; (i) a closed-loop pipeline—strategy-guided synthesis, score-based pruning, executable verification, and write-back—to balance novelty and reliability; (i) a unified retrieval pathway that combines global localization (summary abstractions) with fine-grained reuse (provenance backtracking) for visualization and auditing. Paper organization. Section 2 presents current work related to this field. Section 3 details algorithm flow. Section 4 introduce the mathematical methods of evaluation indicators and discuss the results. Section 5 concludes with limitations and future directions. 2 Related Work Our work lies at the intersection of Retrieval-Augmented Generation (RAG), structured indexing, agentic reasoning, and verification-oriented discovery. We review the most relevant threads and highlight what remains missing for controllable, explainable method synthesis. Figure 1: The complete algorithm process 2.1 Retrieval-Augmented Generation and Structured Indexing RAG augments LLMs with external evidence to improve grounding and updateability [lewis2020rag], yet most systems still retrieve flat text chunks with limited control over multi-step synthesis. To improve global coverage, RAPTOR builds hierarchical summary trees for multi-level retrieval [sarthi2024raptor], while GraphRAG organizes corpora into graphs and community summaries for global question answering [edge2024graphrag]. KG-guided RAG further exploits relational structure for multi-hop expansion [sanmartin2024kgrag, zhu2025kg2rag]. We complement these lines by indexing method units directly: a provenance structure supports reuse and auditing, while an abstraction tree enables top-down navigation. 2.2 Retrieval Strategy, Reflection, and Evaluation Retrieval strategy work addresses when/how to retrieve; HyDE, for example, improves dense retrieval via hypothetical-document embeddings [gao2023precise]. Reliability-oriented pipelines such as Self-RAG and Chain-of-Verification add critique and verify–revise loops to reduce evidence misuse and hallucination [asai2024selfrag, dhuliawala2024cove]. RAGAS provides reference-free signals to disentangle retrieval and generation quality for iteration [es2024ragas]. We extend these ideas from text-level grounding to method-level pruning and validation of synthesized nodes. 2.3 Agentic Search and Verification Loops ReAct and Tree-of-Thoughts introduce explicit tool-using and multi-branch search patterns with evaluation/backtracking [yao2023react, yao2023treeofthoughts]; we instantiate these principles over a method-node space with logged operators and attributions for auditability. In high-assurance domains, executable verification strengthens discovery loops: LeanDojo and Draft–Sketch–Prove support retrieval-augmented and sketch-guided proving [yang2023leandojo, jiang2023draft], while LEGO-Prover emphasizes reuse via growing verified libraries [wang2024legoprover]. AlphaGeometry and FunSearch further show that coupling generation with external evaluators can yield measurable progress under selection [trinh2024alphageometry, romera2024funsearch]. For multimodal evidence, surveys highlight alignment and structure preservation challenges [mei2025mrag], motivating our context-preserving segmentation for method extraction. 2.4 Summary and Gap Prior work improves retrieval, indexing, agentic search, and post-generation verification, but rarely unifies methods-as-nodes with explainable weighted derivations and dual structures for provenance (reuse/auditing) and abstraction (navigation). Our approach integrates structured retrieval, strategy-driven synthesis, pruning, and verification into a controllable innovation loop. 3 Methods We present an explainable, controllable, and verifiable innovation engine built on retrieval-augmented generation (RAG) [lewis2020rag]. The core idea is to index methods-as-nodes and explicitly represent how methods contribute to subsequent methods/results, enabling structured retrieval, strategy-guided synthesis, and post-hoc verification [fan2024ragmeetsllms]. We construct two complementary structures: a provenance tree for traceable derivations and an abstraction tree for efficient hierarchical navigation, inspired by structured retrieval over long corpora [sarthi2024raptor, edge2024graphrag]. The complete algorithm process is shown in the figure 1. See Appendix C for the complete pseudocode of the algorithm. 3.1 Two-Tree Knowledge Representation 3.1.1 Method Provenance Tree Let TM=(ℳ,ℰM)T_M=(M,E_M) be the method provenance tree. Each node m∈ℳm is a reusable research method unit (e.g., model, theorem, experimental paradigm, proof tactic). Each directed edge (mi→mj)∈ℰM(m_i\!→\!m_j) _M indicates that mim_i contributes to mjm_j, with weight wij∈[0,1]w_ij∈[0,1]. Real scientific method dependencies are typically a DAG with multi-parent contributions. To obtain a tree backbone for efficient search and visualization, we define the primary parent of mjm_j as parent(mj)=argmaxiwij,parent(m_j)= _iw_ij, (1) and keep other incoming edges as optional supporting edges (for explanation/scoring without breaking the tree backbone). 3.1.2 Clustering Abstraction Tree Let TCT_C be a hierarchical abstraction tree whose leaves correspond to method nodes in ℳM. Internal nodes are clusters c produced by recursive clustering, each associated with an LLM-generated summary s(c)s(c). The root (there are often many of them) represents the highest-level summary of the overall method space. This structure is analogous to recursive abstraction for long-context retrieval [sarthi2024raptor] and complements graph-based global summarization [edge2024graphrag]. The schematic diagrams of the two trees are shown in the figure 2. 3.2 Offline Construction: From Multimodal Sources to Two Trees 3.2.1 Multimodal Normalization Inputs may include PDFs, web pages, figures/tables, formula screenshots, code snippets, and datasets. A parser converts multimodal content into a unified representation (text + structural markers + image captions/descriptions), following multimodal RAG design considerations [mei2025mrag]. 3.2.2 Context-Preserving Segmentation Given a document D with length L(D)L(D) (tokens or characters) and threshold L0L_0: • If L(D)≤L0L(D)≤ L_0, keep D as a single segment p. • If L(D)>L0L(D)>L_0, split into chapter/section segments p1,…,pk\p_1,…,p_k\ using semantic boundaries; intra-section hard cuts are avoided to preserve argument continuity. Segmentation and downstream extraction are embarrassingly parallel across documents/segments. Figure 2: A schematic diagram of Clustering Abstraction Tree and Method Provenance Tree 3.2.3 Method Extraction, Edge Attribution, and Weighting For each segment p, an LLM performs structured extraction: • prior method set Mpre(p)M_pre(p), • derived method/result set Mpost(p)M_post(p), • short summary sum(m)sum(m) for each method m, • for each relation (mi→mj)(m_i\!→\!m_j): an explanatory summary sum(mi→mj)sum(m_i\!→\!m_j) and a contribution score. To improve stability and interpretability, we ask the LLM for a discrete rating rij∈1,2,3,4,5r_ij∈\1,2,3,4,5\ (weak → strong) and map it to a continuous weight: wij=rij−14.w_ij= r_ij-14. (2) Optionally, for each target node mjm_j, we normalize its incoming weights into contribution shares: w~ij=wij∑kwkj+ϵ. w_ij= w_ij _kw_kj+ε. (3) 3.2.4 Method Deduplication and Canonicalization Each method m is embedded into a vector v(m)v(m) (name + summary + keywords). We compute cosine similarity sim(ma,mb)=v(ma)⊤v(mb)∥v(ma)∥∥v(mb)∥.sim(m_a,m_b)= v(m_a) v(m_b) v(m_a) v(m_b) . (4) If sim(ma,mb)>δmergesim(m_a,m_b)> _merge, the nodes are merged into a canonical method m⋆m . All provenance (original mentions, sources, and incident edges) is retained for auditability. Similarity search can be accelerated via ANN indexing [malkov2018efficient] and parallel batching. 3.2.5 Building the Provenance Tree TMT_M We aggregate extracted edges into a directed graph and then select, for each node mjm_j, its primary parent by the maximum-weight rule above, yielding a tree backbone plus optional supporting edges. 3.2.6 Building the Abstraction Tree TCT_C via Recursive Clustering We construct TCT_C by n rounds of clustering and summarization. Let N0=|ℳ|N_0=|M| be the number of leaf methods. At level t∈1,…,nt∈\1,…,n\, we form KtK_t clusters (with KtK_t decreasing by design), and generate summaries s(c)s(c) for each cluster. Clustering method: we apply MiniBatch k-means on method embeddings for efficiency and scalability [sculley2010web], and summarize each cluster with an LLM into s(c)s(c). We use geometric decay to schedule the number of clusters: Kt K_t =max(Kmin,⌈K1ρt−1⌉), = \! (K_ ,\, K_1ρ^t-1 ), (5) ρ ρ =(KnK1)1n−1,0<ρ<1. = ( K_nK_1 ) 1n-1, 0<ρ<1. A practical heuristic is K1≈N0K_1≈ N_0 and Kn∈[5,20]K_n∈[5,20] (top-level themes). This yields a compact top-level navigation layer while preserving leaf-level resolution [sarthi2024raptor]. 3.3 Online Inference: Funnel Retrieval → Strategy Synthesis → Pruning 3.3.1 Hierarchical Funnel Retrieval on TCT_C Given a query q, we embed q and compute cosine similarity to each cluster summary on TCT_C: sim(q,s(c))=cos(v(q),v(s(c))).sim(q,s(c))= \! (v(q),v(s(c)) ). (6) We retrieve top clusters at each level and descend until reaching leaf methods. To avoid exponential branching, we apply a decaying selection budget: kt=max(1,⌈k1ηt−1⌉),0<η<1,k_t= \! (1,\ k_1η^t-1 ), 0<η<1, (7) where k1k_1 is the top-level budget and η controls the decay. This forms a wide-to-narrow funnel: broad recall at higher levels and lower cost near the leaves. Let ℳqM_q be the retrieved leaf method set. We perform weight-adaptive provenance backtracking on TMT_M: high-weight directions are traced deeper, while weak edges stop early. For a leaf m∈ℳqm _q, let ad(m)a_d(m) be the ancestor at depth d along the primary-parent chain with edge weights wℓ(m)ℓ=1d⊂[0,1]\w_ (m)\_ =1^d⊂[0,1]. We define the cumulative influence Id(m)=∏ℓ=1d(wℓ(m)+ϵ),I_d(m)= _ =1^d (w_ (m)+ε ), (8) where ϵ>0ε>0 is a small constant. Given a threshold τ∈(0,1)τ∈(0,1) and a hard cap mmaxm_ , we include ancestors whose influence remains above τ: AncestorsTM(w)(m;τ,mmax) ^(w)_T_M(m;τ,m_ ) =ad(m)∣1≤d≤mmax, =\a_d(m) 1≤ d≤ m_ , (9) Id(m)≥τ. I_d(m)≥τ\. The final retrieval context is q=ℳq∪⋃m∈ℳqAncestorsTM(w)(m;τ,mmax),C_q=M_q\ ∪\ _m _qAncestors^(w)_T_M(m;τ,m_ ), (10) so the model observes both retrieved methods and deeper provenance along high-contribution paths. 3.3.2 Strategy Agent as Innovation Operators We maintain a library of methodological operators Φ=ϕded,ϕind,ϕana,ϕabd,… =\ _ded, _ind, _ana, _abd,…\, each with definition, applicability conditions, a prompt skeleton, and failure-mode checks. A strategy agent selects operator(s) ϕ∈Φφ∈ consistent with the user intent and produces j candidate innovations: m^1,…,m^j=Innovateϕ(q,q).\ m_1,…, m_j\=Innovate_φ(C_q,q). (11) The agent logs (i) which parent methods were used, (i) why they were selected, and (i) how the operator was applied, making the synthesis auditable. This design is aligned with agentic reasoning and search principles [yao2023react, yao2023treeofthoughts]. Each candidate m m must output: a concise summary, attributed parent methods with contribution explanations, novelty vs. prior methods, applicability boundaries, and a validation plan. 3.3.3 Contribution-Driven Ancestor Depth for Evaluation For a new node m m with parent methods pip_i and normalized contributions w~i∈[0,1] w_i∈[0,1], we adaptively choose how far to trace provenance upward: di=dmin+⌊drange⋅(w~i)γ⌋,γ>0,d_i=d_ + d_range·( w_i)^γ , γ>0, (12) so highly contributing parents provide longer evidence chains for scoring and verification. 3.4 Quality Control: Scoring, Verification, and Write-Back 3.4.1 Human-Interpretable Scoring Rubric For each candidate m m, we collect evidence ℰ(m^)E( m) from its traced ancestors and supporting edges. A scorer (LLM-based or hybrid) outputs an overall score S(m^)∈[0,1]S( m)∈[0,1] based on: • Novelty: more than paraphrase; • Consistency/Explainability: closed derivation chain and explainable edges; • Verifiability: executable validation path; • Applicability: explicit assumptions and failure modes; • Goal alignment: addresses the user instruction. This extends reflection and evaluation ideas from retrieval-augmented systems [asai2024selfrag, dhuliawala2024cove, es2024ragas] to method-level innovation. We keep m m iff S(m^)≥o,S( m)≥ o, (13) where o is a user- or system-defined threshold. 3.4.2 Executable Verification in Formal Domains When the domain admits formalization (e.g., mathematics), we translate m m into Lean/Isabelle statements and attempt machine-checked proofs. Systems for retrieval-augmented and sketch-guided proving motivate this verifier design [yang2023leandojo, jiang2023draft]. If proof fails or does not converge, we discard m m or downgrade it to an explicitly labeled conjecture; successful proofs promote m m to a verified node. Growing-library paradigms further suggest that validated sub-results should be retained for reuse [wang2024legoprover]. 3.4.3 Write-Back and Continual Update For retained nodes m m: • add m m to the method repository, • create weighted contribution edges to its parents, • update TMT_M (primary-parent selection) and TCT_C (incremental or periodic reclustering), • present to the user the innovation, the derivation chain, and a visual navigation path. This creates a continual innovation loop with explicit selection and retention, conceptually similar to evaluator-coupled discovery processes [romera2024funsearch]. 3.5 Efficiency, Timeliness, and Parallelization Hierarchical navigation avoids exponential blow-up: the retrieval cost is dominated by per-level similarity search over KtK_t summaries with a decreasing budget ktk_t, yielding approximately (∑t=1nktlogKt)O\! ( _t=1^nk_t K_t ) (14) with ANN acceleration, rather than multiplicative branching. The pipeline is parallelizable at multiple points: segmentation and extraction across documents, embedding/similarity computation in batches, and multi-operator innovation generation. For timeliness, we apply caching (summaries/embeddings), budget limits (token and call caps), and staged updates (frequent local updates with low-frequency global reclustering). The detailed proof is deferred to Appendix A. 3.6 Optional Unsupervised Evolution and Safety The system can be run in an autonomous loop: generate research questions from gaps/contradictions, retrieve evidence, synthesize candidates, verify/score, and write back. To ensure responsible operation, we enforce explicit uncertainty labels (e.g., conjecture vs. verified), provenance logging, and domain-specific safety constraints (e.g., disallowing high-risk operational instructions, rejecting fabricated citations, and keeping versioned audit trails). 4 Experiments We evaluate the proposed Agent-RAG against a Vanilla Baseline (plain chat with the same backbone LLM). Our goal is to quantify the gain brought by the dual-tree pipeline and to understand how the improvement varies across domains and backbone models. 4.1 Setup Systems. Agent-RAG enables dual-tree indexing (provenance tree TMT_M and abstraction tree TCT_C), hierarchical retrieval with ancestor backtracking, strategy-guided synthesis, and score-based pruning with optional verification. Baseline uses the same backbone LLM but without our structured retrieval, method chaining, or pruning. Domains and questions. We evaluate six domains: Mathematics, Physics, Computer Science, Biology, Chemistry, and Sociology. Each domain includes 100 questions (600 total). Questions are stratified into 5 subtopics (20 questions each), and filtered to keep medium difficulty. 4.2 Human Evaluation Protocol Dimensions and scoring. Experts rate each answer on a 5-point scale (1=Very Poor, 5=Excellent) along: Novelty (N), Correctness (C), Usefulness (U), and Explainability/Consistency (E). We compute a weighted score: S⋆=0.20N+0.35C+0.30U+0.15E.S =0.20N+0.35C+0.30U+0.15E. (15) We also use a binary goal-alignment gate G∈0,1G∈\0,1\. If an answer is off-topic (G=0G=0), we clip the final score: S=min(S⋆,2.0).S= (S ,2.0). (16) Blind rating. We recruit 5 experts per domain (30 total). For each question, experts see two anonymous answers (Agent-RAG vs. Baseline) in randomized order and score them independently. 4.3 Statistics We report mean and standard deviation (μ±σμ±σ). Agent-RAG vs. Baseline comparisons are paired by question. For each domain–backbone setting, we compute the per-question score by averaging expert ratings, and test whether the paired improvement δi=SiAgent−SiBase _i=S^Agent_i-S^Base_i differs from zero using a two-sided paired t-test. As a robustness check for ordinal ratings and potential non-normality, we also apply the Wilcoxon signed-rank test on δi\ _i\. We control the family-wise error rate across all 6×4=246× 4=24 domain–backbone comparisons using Holm–Bonferroni correction and report corrected p-values (pHolmp_Holm). We additionally report the paired effect size dz=δ¯/sδd_z= δ/s_δ (Cohen’s d for paired designs). 4.4 Results Table 1: Agent-RAG expert scores (μ±σμ±σ). Domain GPT-5.2 Gemini 3.0 Llama4 70B DeepSeek Sociology 4.52± 0.35 4.41± 0.38 4.28± 0.41 4.12± 0.45 Computer Science 4.35± 0.37 4.23± 0.39 4.10± 0.42 3.96± 0.44 Biology 4.08± 0.40 3.97± 0.42 3.86± 0.45 3.73± 0.47 Chemistry 4.06± 0.41 3.95± 0.43 3.85± 0.46 3.71± 0.48 Physics 4.04± 0.42 3.93± 0.44 3.83± 0.46 3.70± 0.49 Mathematics 3.60± 0.48 3.45± 0.50 3.28± 0.52 3.10± 0.55 Table 2: Baseline (plain chat) expert scores (μ±σμ±σ). Domain GPT-5.2 Gemini 3.0 Llama4 70B DeepSeek Sociology 4.30± 0.36 4.20± 0.38 4.05± 0.41 3.92± 0.44 Computer Science 4.05± 0.38 3.95± 0.40 3.80± 0.43 3.68± 0.45 Biology 3.66± 0.41 3.57± 0.42 3.45± 0.45 3.34± 0.47 Chemistry 3.64± 0.41 3.55± 0.43 3.44± 0.46 3.32± 0.48 Physics 3.62± 0.42 3.53± 0.44 3.42± 0.46 3.30± 0.49 Mathematics 2.78± 0.52 2.62± 0.54 2.45± 0.56 2.28± 0.58 4.4.1 Improvement over Baseline Tables 1 and 2 report the domain-wise expert scores (μ±σμ±σ) for Agent-RAG and the vanilla baseline across four backbones, while Table 3 summarizes the average domain-level gain Δ (averaged over backbones) and Table 4 reports the backbone-level averages across domains. Table 3: Average improvement Δ (Agent-RAG minus Baseline), averaged across backbones. Domain Avg. Δ Mathematics +0.83 Biology +0.41 Chemistry +0.42 Physics +0.41 Computer Science +0.29 Sociology +0.21 Agent-RAG improves all domains, with the largest gain in Mathematics, followed by Biology/Chemistry/Physics, then Computer Science, and the smallest gain in Sociology (a ceiling effect where baseline is already strong). Table 4: Average scores across domains. Backbone Agent-RAG Baseline Avg. Δ GPT-5.2 4.11 3.68 +0.43 Gemini 3.0 3.99 3.57 +0.42 Llama4 70B 3.87 3.44 +0.43 DeepSeek 3.72 3.31 +0.41 Significance testing. We assess whether the improvements are statistically reliable at the question level using paired tests with Holm–Bonferroni correction. Table 5 reports corrected p-values and paired effect sizes for each domain–backbone setting. The detailed statistical breakdown is provided in Appendix B. 4.4.2 Ablation Study We ablate one module at a time while keeping the backbone LLM, prompts, questions, and decoding parameters fixed. We consider four variants: removing the philosophy operator library Φ , disabling ancestor backtracking (leaf-only context), replacing adaptive backtracking with a fixed depth, and removing the pruning threshold (no filtering). Figure 3 reports the score drop (Full minus Ablated) across domains. Sociology is most sensitive to Φ , while Mathematics is most sensitive to ancestor backtracking and pruning, consistent with their reliance on explicit method chains and error filtering. Figure 3: Ablation results: score drop when removing each module. Larger values indicate higher sensitivity. 4.4.3 Timeliness and Cost–Quality Trade-off We measure end-to-end latency and token cost per question, and study the controllability of the system by sweeping retrieval depth n, top-layer fan-out k1k_1, and the number of candidate innovations j. Figure 4 plots expert score versus token cost and highlights the Pareto frontier. Quality improves as n, k1k_1, and j increase, but the gain saturates quickly, while cost grows roughly linearly, revealing a practical operating region with near-optimal quality under moderate budgets. Figure 4: Cost–quality trade-off: expert score vs. token cost, colored by latency. The curve indicates the Pareto frontier. 4.4.4 Unsupervised Agent Innovation: Qualitative Insights We also ran an unsupervised setting where the agent autonomously proposes research questions, constructs/updates its own RAG memory, and iterates the innovation–evaluation–writeback loop over a long horizon (no external task prompts). Across runs, we observed a punctuated pattern: long periods of scientific stagnation with repetitive recombination of existing nodes, occasionally followed by a breakthrough after which the knowledge graph expands rapidly. A critical failure mode is the absence of an explicit falsification mechanism: once a claim is written back, it is treated as correct, and downstream derivations may amplify early errors, making recovery difficult as the graph grows (e.g., If neutrinos undergo "interstitial periodic decay" and subsequently bind with "creatinos", it will trigger a 50% decay of "chroninos" within a unit space, macroscopically enabling temporal displacement.111This is obviously outrageous.). We also found that, without safety constraints, the agent quickly suggests unethical biological experiments (especially in the field of biology), indicating that unconstrained optimization can treat ethics as a bottleneck rather than a requirement. These observations motivate adding a falsifier module (e.g., targeted contradiction search and periodic re-verification) as an integral part of continual innovation. 4.5 Discussion Two patterns are consistent in these results. First, Agent-RAG yields robust improvements across domains by enforcing structured retrieval and traceable method chaining, which is especially helpful for derivation-heavy tasks (e.g., Mathematics). Second, absolute performance is bounded by the backbone LLM, producing a stable ranking across settings. 5 Conclusion We presented an explainable innovation engine that extends RAG from flat evidence retrieval to methods-as-nodes reasoning, combining a provenance-oriented method tree with a hierarchical abstraction tree for controllable navigation. A strategy layer composes method nodes under explicit operators, while verification and scoring enable pruning and safe writeback, yielding a continual innovation loop with auditable derivations. Expert evaluation (and additional ablations/timeliness studies) suggests consistent gains over a vanilla baseline, especially on domains that require structured reasoning. Future work includes stronger falsification for long-horizon self-evolution, tighter multimodal grounding, and deeper integration with formal verifiers to improve reliability at scale. References Supplementary Material Appendix A Time Complexity Analysis This appendix derives the time complexity of the proposed dual-tree Agent-RAG pipeline. The hierarchical navigation avoids exponential blow-up and yields an online retrieval cost on the order of (∑t=1nktlogKt)O\! ( _t=1^nk_t K_t ) under ANN acceleration. A.1 Notation and Assumptions Let: • N0=|ℳ|N_0=|M|: number of leaf method nodes after deduplication. • TCT_C: abstraction tree with n levels; level t has KtK_t clusters (summaries). • TMT_M: provenance tree backbone (each node has a unique primary parent). • Funnel budget: kt=max(1,⌈k1ηt−1⌉)k_t= \! (1, k_1η^t-1 ), 0<η<10<η<1. • Backtrack depth: m ancestor layers on TMT_M. • Candidate innovations per query: j. We separate (i) algorithmic indexing/retrieval time from (i) LLM inference time. In practice, LLM calls may dominate wall-clock latency; however, the purpose of this appendix is to justify the algorithmic scaling claimed in the paper. ANN query model. We assume similarity search over level-t cluster summaries is implemented with an approximate nearest neighbor (ANN) index. We use the standard average-case abstraction that one ANN query over a set of size KtK_t costs TANN(Kt)=(logKt),T_ANN(K_t)=O( K_t), (17) and returning top-ktk_t neighbors can be absorbed into the constant factors (or treated as (logKt+kt)O( K_t+k_t), which does not change the final conclusion below). A.2 Online Complexity (Per Query) A.2.1 Funnel Retrieval on the Abstraction Tree TCT_C At level t, the algorithm selects ktk_t clusters to continue descending. Operationally, this can be implemented as ktk_t localized ANN queries (one per currently selected cluster) on the child-summary index at that level. Hence the retrieval time at level t is: Tt=kt⋅TANN(Kt)=(ktlogKt).T_t=k_t· T_ANN(K_t)=O\! (k_t K_t ). (18) Summing over n levels yields the total funnel retrieval time: Tfunnel(q)=∑t=1nTt=(∑t=1nktlogKt).T_funnel(q)= _t=1^nT_t=O\! ( _t=1^nk_t K_t ). (19) Geometric budget bound. Because ktk_t decays geometrically, ∑t=1nkt≤∑t=1n(k1ηt−1+1)=k11−ηn1−η+n, _t=1^nk_t≤ _t=1^n (k_1η^t-1+1 )=k_1 1-η^n1-η+n, (20) so if we denote Kmax=maxtKtK_ = _tK_t, then Tfunnel(q)=((k11−ηn1−η+n)logKmax),T_funnel(q)=O\! ( (k_1 1-η^n1-η+n ) K_ ), (21) which is sublinear in KmaxK_ and avoids multiplicative branching across levels. A.2.2 Ancestor Backtracking on the Provenance Tree TMT_M Let |ℳq||M_q| be the number of retrieved leaf methods from TCT_C. Backtracking m ancestors in a tree backbone visits at most m nodes per leaf (duplicates can be removed by a visited set), hence |AncestorsTM(ℳq,m)|≤m|ℳq|.|Ancestors_T_M(M_q,m)|≤ m|M_q|. (22) Therefore the time to materialize the provenance context qC_q is Tbacktrack(q)=(|ℳq|+m|ℳq|)=(m|ℳq|).T_backtrack(q)=O\! (|M_q|+m|M_q| )=O\! (m|M_q| ). (23) In typical operation, |ℳq||M_q| is upper bounded by the deepest funnel budget (and often much smaller), so this term remains moderate. A.2.3 Candidate Generation, Scoring, and Optional Verification The strategy agent produces j candidates. For each candidate m m, the pipeline performs: (i) attribution and evidence collection from a bounded provenance neighborhood, (i) scoring, and (i) optional formal verification. We represent the non-LLM algorithmic overhead per candidate as (B)O(B), where B is the size of collected evidence (bounded by the adaptive backtracking budget and cached indices). Thus, the algorithmic overhead across candidates is: Tscore(q)=(jB).T_score(q)=O(jB). (24) If a formal verifier is invoked, let TproveT_prove denote its runtime; the worst-case verification time is Tverify(q)=(∑ℓ=1j[m^ℓformalizable]⋅Tprove(m^ℓ)).T_verify(q)=O\! ( _ =1^j1[ m_ \ formalizable]· T_prove( m_ ) ). (25) This term is domain-dependent and is explicitly optional in the system design; when disabled, it vanishes. A.2.4 Overall Online Complexity Combining Eq. (19), Eq. (23), and Eq. (24) (and optionally Eq. (25)), we obtain the per-query online time: Tonline(q) T_online(q) =Tfunnel(q)+Tbacktrack(q)+Tscore(q)+Tverify(q) =T_funnel(q)+T_backtrack(q)+T_score(q)+T_verify(q) =(∑t=1nktlogKt)+(m|ℳq|)+(jB)+Tverify(q). =O\! ( _t=1^nk_t K_t )+O\! (m|M_q| )+O(jB)+T_verify(q). (26) The main-text conclusion follows by observing that the retrieval term scales as (∑t=1nktlogKt)O\! ( _t=1^nk_t K_t ), which is additive over levels (not multiplicative), hence does not exhibit exponential branching. A.3 Offline Complexity (Index Construction) Offline construction is amortized across queries and is highly parallelizable. We give a concise bound for completeness. Segmentation and extraction. Let |||D| documents produce |||P| segments. Parsing and segmentation are linear in total input length LtotL_tot: Tseg=(Ltot).T_seg=O(L_tot). (27) Method extraction is dominated by LLM inference; algorithmic overhead is at most linear in extracted items. Deduplication with ANN. Embedding all methods costs (N0)O(N_0) vector calls (LLM/encoder time abstracted away). Using an ANN index, inserting and querying N0N_0 nodes yields Tdedup=(N0logN0)T_dedup=O(N_0 N_0) (28) in the common average-case model. Building trees. Selecting the primary parent for each node in TMT_M is linear in the number of stored edges |ℰ||E|: TTM=(|ℰ|).T_T_M=O(|E|). (29) Constructing TCT_C by recursive clustering depends on the clustering algorithm; with efficient approximate clustering and cached embeddings, it is typically near-linear or N0logN0N_0 N_0-like per (re)build in practice. Since this is offline, it does not affect per-query latency claims. A.4 Takeaway Under ANN-accelerated similarity search, hierarchical funnel retrieval over TCT_C costs (∑t=1nktlogKt)O\! ( _t=1^nk_t K_t ), which is additive across levels and bounded by a geometric series in ktk_t. The proposed dual-tree design improves scalability by avoiding exponential branching while retaining controllable budgets for timeliness. Appendix B significance testing Table 5: Paired significance tests for Agent-RAG vs. Baseline at the question level. We report Holm–Bonferroni corrected p-values (pHolmp_Holm) for the paired t-test, the Wilcoxon signed-rank test as a robustness check, and the paired effect size dzd_z. Domain Backbone n ¯ t d_z p_Holm (t / Wilcoxon) Mathematics GPT-5.2 100 +0.82 12.30 1.23 2.0×10−212.0× 10^-21 / 1.1×10−191.1× 10^-19 Physics GPT-5.2 100 +0.42 9.10 0.91 3.8×10−153.8× 10^-15 / 7.2×10−147.2× 10^-14 Chemistry GPT-5.2 100 +0.42 9.25 0.93 2.6×10−152.6× 10^-15 / 6.0×10−146.0× 10^-14 Biology GPT-5.2 100 +0.42 9.05 0.90 4.6×10−154.6× 10^-15 / 8.1×10−148.1× 10^-14 Computer Science GPT-5.2 100 +0.30 7.10 0.71 2.1×10−102.1× 10^-10 / 9.0×10−109.0× 10^-10 Sociology GPT-5.2 100 +0.22 5.60 0.56 6.7×10−76.7× 10^-7 / 2.4×10−62.4× 10^-6 Mathematics Gemini 3.0 100 +0.83 12.55 1.26 1.2×10−211.2× 10^-21 / 7.0×10−207.0× 10^-20 Physics Gemini 3.0 100 +0.40 8.90 0.89 8.7×10−158.7× 10^-15 / 1.4×10−131.4× 10^-13 Chemistry Gemini 3.0 100 +0.40 8.95 0.90 6.8×10−156.8× 10^-15 / 1.2×10−131.2× 10^-13 Biology Gemini 3.0 100 +0.40 8.85 0.88 1.1×10−141.1× 10^-14 / 1.8×10−131.8× 10^-13 Computer Science Gemini 3.0 100 +0.28 6.85 0.69 5.6×10−105.6× 10^-10 / 2.0×10−92.0× 10^-9 Sociology Gemini 3.0 100 +0.21 5.35 0.54 1.1×10−61.1× 10^-6 / 3.7×10−63.7× 10^-6 Mathematics Llama4 70B 100 +0.83 12.40 1.24 1.8×10−211.8× 10^-21 / 9.2×10−209.2× 10^-20 Physics Llama4 70B 100 +0.41 9.05 0.91 4.4×10−154.4× 10^-15 / 8.4×10−148.4× 10^-14 Chemistry Llama4 70B 100 +0.41 9.00 0.90 5.6×10−155.6× 10^-15 / 9.9×10−149.9× 10^-14 Biology Llama4 70B 100 +0.41 9.10 0.91 3.7×10−153.7× 10^-15 / 7.8×10−147.8× 10^-14 Computer Science Llama4 70B 100 +0.30 7.20 0.72 1.5×10−101.5× 10^-10 / 6.6×10−106.6× 10^-10 Sociology Llama4 70B 100 +0.23 5.70 0.57 5.1×10−75.1× 10^-7 / 1.9×10−61.9× 10^-6 Mathematics DeepSeek 100 +0.82 12.10 1.21 4.1×10−214.1× 10^-21 / 2.0×10−192.0× 10^-19 Physics DeepSeek 100 +0.40 8.80 0.88 1.4×10−141.4× 10^-14 / 2.1×10−132.1× 10^-13 Chemistry DeepSeek 100 +0.39 8.65 0.87 2.7×10−142.7× 10^-14 / 3.6×10−133.6× 10^-13 Biology DeepSeek 100 +0.39 8.70 0.87 2.2×10−142.2× 10^-14 / 3.1×10−133.1× 10^-13 Computer Science DeepSeek 100 +0.28 6.75 0.68 7.2×10−107.2× 10^-10 / 2.6×10−92.6× 10^-9 Sociology DeepSeek 100 +0.20 5.10 0.51 2.0×10−62.0× 10^-6 / 6.2×10−66.2× 10^-6 Appendix C Algorithm pseudo-code Algorithm 1 Explainable Innovation Engine (Dual-Tree Agent-RAG) 1:Corpus of multimodal sources D; LLM(s) for extraction/summarization/generation; embedder Embed(⋅)Embed(·); segment length threshold L0L_0; merge threshold δmerge _merge; clustering rounds n; cluster schedule (K1,Kn,Kmin)(K_1,K_n,K_ ); funnel schedule (k1,η)(k_1,η); backtrack depth m; operator library Φ ; candidates per query j; score threshold o; (optional) formal verifier Prove(⋅)Prove(·). 2:Method repository ℳM; provenance tree TMT_M; abstraction tree TCT_C. 3:Offline Construction (Build Two Trees) 4:←∅P← ⊳ segments 5:for all D∈D in parallel do 6: D′←Normalize(D)D (D) ⊳ text+structure+image descriptions 7: ←∪Segment(D′,L0)P (D ,L_0) ⊳ chapter/section boundaries 8:end for 9:ℳ←∅;ℰ←∅M← ;\;E← ⊳ methods and contribution edges 10:for all p∈p in parallel do 11: (Mpre,Mpost,sum(m),ℛ)←ExtractMethods(p)(M_pre,M_post,\sum(m)\,R) (p) 12: for all (mi→mj,rij,sum(mi→mj))∈ℛ(m_i\!→\!m_j,\,r_ij,\,sum(m_i\!→\!m_j)) do 13: wij←rij−14w_ij← r_ij-14 ⊳ discrete→ 14: ℰ←ℰ∪(mi,mj,wij,sum(mi→mj))E ∪\(m_i,m_j,w_ij,sum(m_i\!→\!m_j))\ 15: end for 16: ℳ←ℳ∪Mpre∪MpostM ∪ M_pre∪ M_post 17:end for 18:←Embed(name(m)∥sum(m)∥kw(m)):m∈ℳV←\Embed(name(m)\|sum(m)\|kw(m)):\;m \ 19:ℳ←Deduplicate(ℳ,,δmerge)M (M,V, _merge) ⊳ merge into canonical nodes; keep provenance 20:ℰ←RemapEdges(ℰ,ℳ)E (E,M) 21:TM←BuildProvenanceTree(ℳ,ℰ)T_M (M,E) ⊳ primary parent: parent(mj)=argmaxiwijparent(m_j)= _iw_ij; others as supporting edges 22:TC←BuildAbstractionTree(ℳ,n,K1,Kn,Kmin)T_C (M,n,K_1,K_n,K_ ) ⊳ recursive: embed→ → summarize 23:Online Inference (Per Query) 24:procedure AnswerQuery(q) 25: ←FunnelRetrieve(TC,q,k1,η)C (T_C,q,k_1,η) ⊳ top-down, decreasing budget ktk_t 26: ℳq←LeafMethods()M_q (C) 27: q←ℳq∪AncestorsTM(ℳq,m)C_q _q _T_M(M_q,m) 28: ϕ←SelectOperator(Φ,q,q)φ ( ,q,C_q) ⊳ strategy controller; log trajectory 29: m^1,…,m^j←Innovateϕ(q,q)\ m_1,…, m_j\ _φ(C_q,q) ⊳ generate j candidates 30: ←∅K← ⊳ kept candidates 31: for all m^∈m^1,…,m^j m∈\ m_1,…, m_j\ do 32: (pi,w~i)←AttributeParents(m^,TM)\(p_i, w_i)\ ( m,T_M) ⊳ normalized contributions 33: for all (pi,w~i)(p_i, w_i) do 34: di←dmin+⌊drange⋅(w~i)γ⌋d_i← d_ + d_range·( w_i)^γ 35: end for 36: ℰ(m^)←CollectEvidence(TM,(pi,di))E( m) (T_M,\(p_i,d_i)\) ⊳ longer chains for higher w~i w_i 37: S(m^)←Score(m^,ℰ(m^),q)S( m) ( m,E( m),q) ⊳ novelty/consistency/verifiability/applicability/alignment 38: if Formalizable(m^)Formalizable( m) and ProveProve is available then 39: ok←Prove(m^)ok ( m) ⊳ Lean/Isabelle attempt 40: if not okok then 41: S(m^)←0S( m)← 0 ⊳ discard or downgrade to conjecture 42: end if 43: end if 44: if S(m^)≥oS( m)≥ o then 45: ←∪m^K ∪\ m\ 46: end if 47: end for 48: for all m^∈ m do 49: ℳ←ℳ∪m^M ∪\ m\ 50: ℰ←ℰ∪WriteBackEdges(m^)E ( m) ⊳ weighted parent links 51: TM←UpdateProvenanceTree(TM,m^)T_M (T_M, m) 52: TC←UpdateAbstractionTree(TC,m^)T_C (T_C, m) ⊳ incremental or periodic recluster 53: end for 54: return RenderAnswer(,TM,TC)RenderAnswer(K,T_M,T_C) ⊳ innovation + derivation chain + navigation path 55:end procedure