🤖 AI

SciToolAgent-Evo: An Ontology-Aware Self-Evolving Agent for Open-World Scientific Tool Acquisition

The paper introduces SciToolAgent-Evo, an ontology-aware self-evolving agent that dynamically acquires and integrates new scientific tools in open-world environments through contrastive learning and a LinUCB-based exploration-exploitation strategy, validated by the new OpenSciToolBench benchmark.

Original authors: Yuqi Tang, Chenyi Zhou, Libin Wang, Keyan Ding, Qiang Zhang, Huajun Chen

Published 2026-08-03

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Yuqi Tang, Chenyi Zhou, Libin Wang, Keyan Ding, Qiang Zhang, Huajun Chen

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a brilliant detective, but instead of solving crimes, you are solving scientific mysteries. You have a giant, magical toolbox filled with gadgets like "Molecule Weigher" or "Protein Scanner." In the old days, if you needed to solve a case, you could only use the tools already in your box. If the perfect gadget wasn't there, you were stuck, even if you knew exactly what the tool should do. This is how most computer programs that help scientists work today: they are stuck in a "closed world," limited to a fixed list of tools they were taught at the start.

But real science is messy and open-ended. Sometimes, to solve a problem, you need a tool you've never seen before. This is where the concept of an "agent" comes in. Think of an agent as a super-smart robot assistant powered by a Large Language Model (LLM)—a type of AI that is really good at understanding human language and reasoning. These agents are great at picking the right tools from a known list. However, they struggle when the list is incomplete. They don't know how to say, "I don't have the right tool, so I need to go find a new one," and then learn how to use it for next time. The big question is: Can we build a robot scientist that doesn't just pick tools, but actually learns new ones on the fly, just like a human researcher does?

This is exactly what the paper SciToolAgent-Evo tackles. The authors, a team from Zhejiang University, have built a new kind of AI agent that acts like a self-evolving scientific explorer. Instead of being stuck with a static toolbox, this agent has a "growing brain" that remembers past successes and failures. When it encounters a scientific task it can't solve with its current tools, it doesn't give up. Instead, it actively goes out to find a new tool, figures out how it works, and adds it to its permanent collection.

Here is how this "self-evolving" magic works, broken down into simple steps:

1. The "Evolving Memory" (The Agent's Brain)
Imagine the agent has a special notebook. Inside, it keeps three things:

A Skill Library: Shortcuts for common tasks (like "How to calculate the weight of a molecule").
An Experience Pool: Notes on what went wrong and how to fix it next time (like "Don't try to weigh a gas without a container").
A Tool Map: A map of all the tools it knows, organized by what they do.
Every time the agent solves a problem, it updates this notebook. If it fails, it learns why. If it succeeds with a new tool, it writes down exactly how that tool works so it never has to guess again.

2. The "Active Request" (Asking the Right Questions)
Most AI agents wait for you to tell them what to do. SciToolAgent-Evo is different. When it sees a hard problem, it doesn't just look for a tool; it breaks the problem down and asks itself, "What specific capability do I need right now?" It creates a "shopping list" of tool abilities. This helps it find the right tool even if the tool has a weird name or isn't in its original list.

3. The "Bandit Gate" (The Risk-Taker)
This is the most clever part. The agent has to decide: "Should I use a tool I already know (safe), or should I try to find a new, unknown tool (risky)?" To make this choice, it uses a mathematical strategy called a "Bandit Gate" (named after a slot machine game where you have to balance pulling a known lever for a small reward vs. trying a new lever for a big one).

If the known tools look like they will work, it uses them.
If the known tools seem weak, the gate says, "Go explore!" and the agent starts hunting for a new tool.
Once it finds a new tool, it tests it. If it works, the tool gets a full "ID card" (an ontology) describing exactly what it does, and it gets added to the map.

The Results: A New Benchmark
To prove their idea works, the team didn't just test it on easy questions. They built a new test called OpenSciToolBench. Think of this as a video game with four levels of difficulty:

Level 1: Easy tasks using 1–2 tools (like asking for a simple fact).
Level 2: Medium tasks using 2–4 tools (like comparing two chemicals).
Level 3: Hard tasks using 3–6 tools (like finding a molecule that fits a complex set of rules).
Level 4: Expert tasks using 5–10 tools (like designing a whole research strategy).

The benchmark contains 900 realistic scientific tasks across biology, chemistry, and materials science. When they tested SciToolAgent-Evo against other top AI agents, the results were impressive. On the hardest levels, the new agent was significantly better. For example, on Level 3 tasks, it got the right answer about 56% of the time, while the next best agent only got about 35%.

Why This Matters
The paper suggests that this approach is a major step forward because it solves the "capability gap." In the past, if a scientist asked an AI to do something requiring a tool the AI didn't have, the AI would fail or hallucinate (make things up). SciToolAgent-Evo, however, admits it doesn't know the tool, goes out to find it, learns it, and then uses it. It creates a closed loop of learning: Try -> Fail/Find -> Learn -> Update Memory -> Try Again.

The authors found that this "self-evolving" nature makes the agent much more robust. Even when 70% of the tools it needed were initially unknown to it, the agent could still solve about 59% of the tasks. This proves that the agent isn't just memorizing answers; it's actually learning how to acquire and use new scientific tools dynamically.

In short, SciToolAgent-Evo is like a robot scientist that never stops growing. It starts with a small toolbox, but as it works, it builds a massive, organized library of tools and skills, making it ready for the unpredictable, open-world challenges of real scientific discovery.

Technical Summary: SciToolAgent-Evo

Problem Statement

Large Language Model (LLM) agents have shown promise in scientific research for organizing and invoking specialized computational tools. However, existing approaches largely operate within closed-world assumptions, relying on predefined tool spaces with static semantics. This limitation restricts their applicability to open-world scientific workflows, where tool requirements, capabilities, and boundaries evolve dynamically. In real-world scenarios, agents often encounter capability gaps where required tools are absent from their known library. Current frameworks fail to recognize these gaps effectively, leading to passive over-exploitation of known tools or failure when novel capabilities are needed. Furthermore, existing benchmarks typically involve short tool chains with explicit tool-name cues, failing to evaluate the core capabilities required for open-world tool acquisition: recognizing capability gaps, balancing exploration with exploitation, and continually consolidating new knowledge.

Methodology

The authors propose SciToolAgent-Evo, an ontology-aware self-evolving agent designed for open-world scientific tool acquisition. The framework operates through two distinct phases: Knowledge Accumulation and Ontology-Aware Inference, supported by a hierarchical benchmark.

1. Knowledge Accumulation

During the training phase, the agent distills generalizable knowledge from contrastive trajectories without updating the backbone LLM parameters.

Contrastive Rollouts: For a given task, the agent generates a deterministic baseline trajectory. If this fails, it performs exploratory rollouts at varying temperatures. Successful exploratory trajectories are paired with failed baselines to form contrastive pairs.
Knowledge Distillation: The agent critiques these pairs to identify critical divergences and failure reasons. It then distills two types of knowledge:
- Skills ( $K$ ): Abstract, reusable tool-chain guidance units for specific task classes.
- Experiences ( $E$ ): Non-parametric prompts providing fine-grained, domain-specific or general tool-selection guidance.
Evolving Memory: The agent maintains a memory consisting of a skill library, an experience pool, and an ontologized tool graph ( $G_K$ ).

2. Ontology-Aware Inference

During inference, the agent dynamically balances the use of known tools and the exploration of unknown tools.

Routing: The agent first checks for a matching skill in its memory. If found, it executes the associated tool chain. For complex tasks without a direct skill match, it estimates difficulty and routes to active tool acquisition.
Active Tool Requests: Instead of passively matching raw queries, the agent formulates active tool requests ( $R_q$ ) based on ontology-guided reasoning. These requests describe specific capability needs (e.g., "calculate molecular weight") rather than just the task goal.
Bandit Gate (LinUCB): For each request, the agent retrieves candidate tools from the known graph ( $G_K$ $G_{K}$ ) and potentially the unknown set ( $T_U$ $T_{U}$ ). A LinUCB-based bandit gate constructs a four-dimensional context vector (feasibility, confidence margin, ontology alignment, and historical success prior) to decide between:
- Exploitation: Selecting the top-ranked known tool.
- Exploration: Inferring utility from sparse attributes to retrieve a compatible unknown tool.
Online Ontology Completion: Once a novel tool is successfully acquired and used, its scientific ontology is completed online from the interaction history and migrated into the known tool graph ( $G_K$ ), enabling seamless integration for future tasks.

3. OpenSciToolBench

To address the lack of suitable evaluation standards, the authors introduce OpenSciToolBench, a hierarchical benchmark containing 900 realistic tasks across four difficulty levels:

Level-1: Explicit tool invocation (1–2 tools).
Level-2: Property analysis via retrieval or computation (2–4 tools).
Level-3: Constraint-aware reasoning with multi-dimensional properties (3–6 tools).
Level-4: Open-ended research strategy formulation (5–10 tools).
The dataset spans biology, chemistry, and materials science, with tasks generated via a pipeline involving LLM-as-a-Judge and human validation.

Key Contributions

SciToolAgent-Evo: A novel agent architecture that integrates evolving memory (skills, experiences, tool graph), active tool requests, and an exploration–exploitation bandit gate to enable autonomous adaptation in dynamic scientific environments.
OpenSciToolBench: A comprehensive benchmark with 900 tasks across four difficulty levels and multiple scientific domains, designed specifically to evaluate open-world tool acquisition capabilities.
Empirical Validation: Extensive evaluations demonstrating that SciToolAgent-Evo achieves state-of-the-art performance, significantly outperforming competitive baselines (including ReAct, Reflexion, and SciToolAgent) in both tool-use accuracy and final answer correctness.

Results

Experiments were conducted on OpenSciToolBench and SciToolEval using GPT-5.4-mini and Gemini-3-flash backbones.

Performance Gains: SciToolAgent-Evo improved overall answer accuracy on OpenSciToolBench by 12.11 and 9.55 points over the second-best baselines for GPT-5.4-mini and Gemini-3-flash, respectively. On SciToolEval, gains were 6.11 and 2.89 points.
Complexity Handling: The agent showed a significant advantage in complex, multi-tool tasks (Level-3 and Level-4), outperforming in-context learning methods (CoT, ReAct, Reflexion) by margins exceeding 20–30 points in some cases. This highlights the limitation of local step-wise reasoning in open tool spaces.
Ablation Studies: Removing knowledge accumulation caused a 14.87-point drop in performance, while disabling unknown tool migration led to the largest degradation (15.69 points), confirming the necessity of continual learning and migration.
Robustness: The agent maintained competitive performance (59.01% accuracy) even when 70% of the toolset was initially unknown, demonstrating robustness in challenging open-world settings.

Significance

The paper claims that SciToolAgent-Evo represents a shift from closed-world tool selection to open-world scientific tool acquisition. By leveraging an ontology-aware self-evolving mechanism, the agent can continually expand its capabilities, recognizing capability gaps and consolidating new tool knowledge without requiring retraining of the backbone LLM. The introduction of OpenSciToolBench provides a rigorous framework for evaluating these capabilities, moving beyond simple tool invocation to assess research strategy formulation and constraint reasoning. The work validates that balancing exploration and exploitation via a bandit gate, combined with an evolving memory, is critical for robust adaptation in dynamic scientific environments.