Upload folder using huggingface_hub

icml26/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/appendix_chunks.jsonl

@@ -0,0 +1,69 @@
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0068", "section": "A. Evaluation Methodology Details", "page_start": 12, "page_end": 12, "type": "Text", "text": "We provide mathematical formulations and implementation details for the metrics in Section 2.2. We evaluate N generated MCP-server implementations \\{\\hat{e}_i\\}_{i=1}^N . Each server is expected to expose a list_tools endpoint returning a tool registry (a list of tool schemas).", "source": "marker_v2", "marker_block_id": "/page/11/Text/2"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0069", "section": "A.1. Layer 1: Surface Compliance and Server Execution", "page_start": 12, "page_end": 12, "type": "Text", "text": "Compliance (OpenAI tool-calling format). We treat compliance as a strict format check: whether the returned tool registry is parseable and satisfies the OpenAI tool-calling specification. Let \\mathcal{V}_{OpenAI} denote the corresponding JSON Schema validator, and let parse(·) return a parsed JSON object if successful (otherwise \\bot ). We define the per-instance compliance indicator:", "source": "marker_v2", "marker_block_id": "/page/11/Text/4"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0070", "section": "A.1. Layer 1: Surface Compliance and Server Execution", "page_start": 12, "page_end": 12, "type": "Equation", "text": "compliant(\\hat{e}_i) = \\mathbb{I}[parse(list\\_tools(\\hat{e}_i)) \\neq \\bot \\land parse(list\\_tools(\\hat{e}_i)) \\models \\mathcal{V}_{OpenAI}], \\tag{2}", "source": "marker_v2", "marker_block_id": "/page/11/Equation/5"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0071", "section": "A.1. Layer 1: Surface Compliance and Server Execution", "page_start": 12, "page_end": 12, "type": "Text", "text": "and report the dataset-level score:", "source": "marker_v2", "marker_block_id": "/page/11/Text/6"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0072", "section": "A.1. Layer 1: Surface Compliance and Server Execution", "page_start": 12, "page_end": 12, "type": "Equation", "text": "Compliance = \\frac{1}{N} \\sum_{i=1}^{N} \\text{compliant}(\\hat{e}_i) . (3)", "source": "marker_v2", "marker_block_id": "/page/11/Equation/7"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0073", "section": "A.1. Layer 1: Surface Compliance and Server Execution", "page_start": 12, "page_end": 12, "type": "Text", "text": "Server execution (3 independent launches). We attempt to start each server R=3 times under fixed timeouts. Let \\operatorname{run}(\\hat{e}_i,r)\\in\\{0,1\\} indicate whether the r-th launch succeeds and the server remains responsive (e.g., responds to list_tools) within the timeout. We define the per-instance execution score:", "source": "marker_v2", "marker_block_id": "/page/11/Text/8"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0074", "section": "A.1. Layer 1: Surface Compliance and Server Execution", "page_start": 12, "page_end": 12, "type": "Equation", "text": "\\operatorname{exec}(\\hat{e}_i) = \\frac{1}{R} \\sum_{r=1}^{R} \\operatorname{run}(\\hat{e}_i, r), \\qquad R = 3, (4)", "source": "marker_v2", "marker_block_id": "/page/11/Equation/9"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0075", "section": "A.1. Layer 1: Surface Compliance and Server Execution", "page_start": 12, "page_end": 12, "type": "Text", "text": "and report the dataset-level score:", "source": "marker_v2", "marker_block_id": "/page/11/Text/10"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0076", "section": "A.1. Layer 1: Surface Compliance and Server Execution", "page_start": 12, "page_end": 12, "type": "Equation", "text": "ServerExecution = \\frac{1}{N} \\sum_{i=1}^{N} \\operatorname{exec}(\\hat{e}_i) . (5)", "source": "marker_v2", "marker_block_id": "/page/11/Equation/11"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0077", "section": "A.2. Layer 2: Semantic Interface Fidelity (Schema-F1)", "page_start": 12, "page_end": 12, "type": "Text", "text": "Layer 2 evaluates whether the predicted tool interfaces match the reference interfaces, independent of code execution. For instance i, let \\hat{s}_i be the predicted tool set and s_i^* the reference tool set. Each tool schema is represented as t = \\langle \\eta, \\phi \\rangle , where \\eta is function_name and \\phi is the JSON-schema-like argument definition.", "source": "marker_v2", "marker_block_id": "/page/11/Text/13"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0078", "section": "A.2. Layer 2: Semantic Interface Fidelity (Schema-F1)", "page_start": 12, "page_end": 12, "type": "Text", "text": "Embedding-based similarity on function_name + args. We define a canonical serialization g(t) = \\eta \\oplus \\operatorname{canon}(\\phi) , where \\oplus denotes concatenation and \\operatorname{canon}(\\cdot) produces a deterministic string form (e.g., JSON dump with sorted keys). We embed g(t) using sentence-transformers/all-MiniLM-L6-v2, denoted by \\mathbf{E}(\\cdot) , and define cosine similarity:", "source": "marker_v2", "marker_block_id": "/page/11/Text/14"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0079", "section": "A.2. Layer 2: Semantic Interface Fidelity (Schema-F1)", "page_start": 12, "page_end": 12, "type": "Equation", "text": "w(u,v) = \\cos(\\mathbf{E}(g(u)), \\mathbf{E}(g(v))). \\tag{6}", "source": "marker_v2", "marker_block_id": "/page/11/Equation/15"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0080", "section": "A.2. Layer 2: Semantic Interface Fidelity (Schema-F1)", "page_start": 12, "page_end": 12, "type": "Text", "text": "Maximum-weight matching and F1. We construct a bipartite graph between \\hat{s}_i and s_i^* with edge weights w(\\cdot,\\cdot) , and compute a maximum-weight matching M_i . A matched pair is counted as correct if w(u,v) \\geq \\tau for a fixed threshold \\tau . Let m_i = |\\{(u,v) \\in M_i : w(u,v) \\geq \\tau\\}| . Then", "source": "marker_v2", "marker_block_id": "/page/11/Text/16"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0081", "section": "A.2. Layer 2: Semantic Interface Fidelity (Schema-F1)", "page_start": 12, "page_end": 12, "type": "Equation", "text": "P_i = \\frac{m_i}{|\\hat{s}_i|}, \\qquad R_i = \\frac{m_i}{|s_i^*|}, \\qquad \\text{SchemaF1}_i = \\frac{2P_i R_i}{P_i + R_i + \\epsilon}, \\tag{7}", "source": "marker_v2", "marker_block_id": "/page/11/Equation/17"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0082", "section": "A.2. Layer 2: Semantic Interface Fidelity (Schema-F1)", "page_start": 12, "page_end": 12, "type": "Text", "text": "where \\epsilon is a small constant for numerical stability, and we report:", "source": "marker_v2", "marker_block_id": "/page/11/Text/18"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0083", "section": "A.2. Layer 2: Semantic Interface Fidelity (Schema-F1)", "page_start": 12, "page_end": 12, "type": "Equation", "text": "SchemaF1 = \\frac{1}{N} \\sum_{i=1}^{N} SchemaF1_{i}. (8)", "source": "marker_v2", "marker_block_id": "/page/11/Equation/19"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0084", "section": "A.2. Layer 2: Semantic Interface Fidelity (Schema-F1)", "page_start": 12, "page_end": 12, "type": "Text", "text": "Note. Schema-F1 compares tool interfaces (names and argument schemas), and is distinct from the structured score in Layer 3, which compares tool outputs via key-path overlap.", "source": "marker_v2", "marker_block_id": "/page/11/Text/20"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0085", "section": "A.3. Layer 3: Functional Correctness via Unit Tests (UT)", "page_start": 13, "page_end": 13, "type": "Text", "text": "Layer 3 evaluates functional correctness by executing unit tests. Each unit test is a triple ⟨η, x, y ∗ ⟩, where η is the tool name, x is the input arguments, and y ∗ is the expected output. Running the tool on the generated server yields an actual output yˆ. We score each test case by combining (i) a structured score and (ii) an embedding similarity score.", "source": "marker_v2", "marker_block_id": "/page/12/Text/2"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0086", "section": "A.3. Layer 3: Functional Correctness via Unit Tests (UT)", "page_start": 13, "page_end": 13, "type": "Text", "text": "(i) Structured score (JSON key-path overlap). We consider the common case where y ∗ is JSON (or parseable as JSON). Let parse(·) parse JSON successfully or return ⊥. If parse(ˆy) = ⊥, we set the structured score to 0. Otherwise, we extract a set of key-path strings from a JSON object, denoted by paths(·) (e.g., a.b[0].c). Define", "source": "marker_v2", "marker_block_id": "/page/12/Text/3"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0087", "section": "A.3. Layer 3: Functional Correctness via Unit Tests (UT)", "page_start": 13, "page_end": 13, "type": "Equation", "text": "P_{\\text{path}} = \\frac{|\\text{paths}(\\hat{y}) \\cap \\text{paths}(y^*)|}{|\\text{paths}(\\hat{y})| + \\epsilon}, \\qquad R_{\\text{path}} = \\frac{|\\text{paths}(\\hat{y}) \\cap \\text{paths}(y^*)|}{|\\text{paths}(y^*)| + \\epsilon}, \\tag{9}", "source": "marker_v2", "marker_block_id": "/page/12/Equation/4"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0088", "section": "A.3. Layer 3: Functional Correctness via Unit Tests (UT)", "page_start": 13, "page_end": 13, "type": "Text", "text": "and the structured score (F1 over key paths):", "source": "marker_v2", "marker_block_id": "/page/12/Text/5"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0089", "section": "A.3. Layer 3: Functional Correctness via Unit Tests (UT)", "page_start": 13, "page_end": 13, "type": "Equation", "text": "struct(\\hat{y}, y^*) = \\frac{2P_{path}R_{path}}{P_{path} + R_{path} + \\epsilon}. (10)", "source": "marker_v2", "marker_block_id": "/page/12/Equation/6"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0090", "section": "A.3. Layer 3: Functional Correctness via Unit Tests (UT)", "page_start": 13, "page_end": 13, "type": "Text", "text": "(ii) Embedding similarity of outputs. We canonicalize outputs via canon(·) (stable JSON dump if parseable; otherwise raw text), embed using sentence-transformers/all-MiniLM-L6-v2 (denoted by E(·)), and compute:", "source": "marker_v2", "marker_block_id": "/page/12/Text/7"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0091", "section": "A.3. Layer 3: Functional Correctness via Unit Tests (UT)", "page_start": 13, "page_end": 13, "type": "Equation", "text": "\\operatorname{emb}(\\hat{y}, y^*) = \\max \\Big( 0, \\cos \\left( \\mathbf{E}(\\operatorname{canon}(\\hat{y})), \\mathbf{E}(\\operatorname{canon}(y^*)) \\right) \\Big). \\tag{11}", "source": "marker_v2", "marker_block_id": "/page/12/Equation/8"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0092", "section": "A.3. Layer 3: Functional Correctness via Unit Tests (UT)", "page_start": 13, "page_end": 13, "type": "Text", "text": "UT score (equal-weight combination). For a single test case:", "source": "marker_v2", "marker_block_id": "/page/12/Text/9"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0093", "section": "A.3. Layer 3: Functional Correctness via Unit Tests (UT)", "page_start": 13, "page_end": 13, "type": "Equation", "text": "UT(\\hat{y}, y^*) = \\frac{1}{2} struct(\\hat{y}, y^*) + \\frac{1}{2} emb(\\hat{y}, y^*). (12)", "source": "marker_v2", "marker_block_id": "/page/12/Equation/10"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0094", "section": "A.3. Layer 3: Functional Correctness via Unit Tests (UT)", "page_start": 13, "page_end": 13, "type": "Text", "text": "Aggregating across tests (standard vs. boundary). Let T std be the set of standard (positive) tests and T bnd include additional boundary/negative tests. For S ∈ {std, bnd}, we report:", "source": "marker_v2", "marker_block_id": "/page/12/Text/11"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0095", "section": "A.3. Layer 3: Functional Correctness via Unit Tests (UT)", "page_start": 13, "page_end": 13, "type": "Equation", "text": "UT_{S} = \\frac{1}{|\\mathcal{T}^{S}|} \\sum_{\\langle \\eta, \\mathbf{x}, y^{*} \\rangle \\in \\mathcal{T}^{S}} UT(\\hat{y}(\\eta, \\mathbf{x}), y^{*}). (13)", "source": "marker_v2", "marker_block_id": "/page/12/Equation/12"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0096", "section": "A.4. Layer 4: Downstream Task Utility (Oracle-normalized SR)", "page_start": 13, "page_end": 13, "type": "Text", "text": "To evaluate end-to-end utility, we run a fixed agent based on Qwen3-14B on benchmark trajectories under two tool environments: (i) the generated MCP server eˆ and (ii) the ground-truth MCP server e ∗ . For each task instance j, an LLM judge produces two scores in [0, 1]:", "source": "marker_v2", "marker_block_id": "/page/12/Text/14"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0097", "section": "A.4. Layer 4: Downstream Task Utility (Oracle-normalized SR)", "page_start": 13, "page_end": 13, "type": "Equation", "text": "s_j^{\\text{gen}} = \\mathcal{J}(\\text{trajectory produced with } \\hat{e}), \\qquad s_j^{\\text{gt}} = \\mathcal{J}(\\text{trajectory produced with } e^*). (14)", "source": "marker_v2", "marker_block_id": "/page/12/Equation/15"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0098", "section": "A.4. Layer 4: Downstream Task Utility (Oracle-normalized SR)", "page_start": 13, "page_end": 13, "type": "Text", "text": "We compute the per-task oracle-normalized score:", "source": "marker_v2", "marker_block_id": "/page/12/Text/16"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0099", "section": "A.4. Layer 4: Downstream Task Utility (Oracle-normalized SR)", "page_start": 13, "page_end": 13, "type": "Equation", "text": "SR_j = \\frac{1 - s_j^{\\text{gt}}}{1 - s_j^{\\text{gen}} + \\epsilon},\\tag{15}", "source": "marker_v2", "marker_block_id": "/page/12/Equation/17"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0100", "section": "A.4. Layer 4: Downstream Task Utility (Oracle-normalized SR)", "page_start": 13, "page_end": 13, "type": "Text", "text": "and report the dataset-level score:", "source": "marker_v2", "marker_block_id": "/page/12/Text/18"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0101", "section": "A.4. Layer 4: Downstream Task Utility (Oracle-normalized SR)", "page_start": 13, "page_end": 13, "type": "Equation", "text": "SR = \\frac{1}{|\\mathcal{D}_{task}|} \\sum_{j \\in \\mathcal{D}_{task}} SR_j. (16)", "source": "marker_v2", "marker_block_id": "/page/12/Equation/19"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0102", "section": "B. More Dataset Construction Details", "page_start": 13, "page_end": 13, "type": "Text", "text": "This appendix provides implementation details for the four-stage construction pipeline in Figure 2, including crawling, schema standardization, executable validation, clustering/deduplication, LLM-as-judge rubrics, task/trajectory generation filters, unit-test synthesis, and final release policies.", "source": "marker_v2", "marker_block_id": "/page/12/Text/21"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0103", "section": "B. More Dataset Construction Details", "page_start": 14, "page_end": 14, "type": "FigureGroup", "text": "Figure 7. Data flow and attrition in MCP-server collection. Sankey diagram summarizing the sequential filtering stages for constructing Dsrv, reporting the number of servers retained (and discarded) at each stage. Placeholder: will be replaced by the final figure.", "source": "marker_v2", "marker_block_id": "/page/13/FigureGroup/337"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0104", "section": "Example 1: MCP-server schema instance (Dsrv).", "page_start": 14, "page_end": 14, "type": "Code", "text": "{ \"metadata\": { \"server_name\": \"Airbnb Search and Listing Details Server\", \"mode\": \"smithery\", \"timestamp\": 1751938055, \"remote_server_response\": { \"url\": \" \"is_success\": true, \"error\": null, \"tools\": [ { \"name\": \"airbnb_search\", \"description\": \"Search for Airbnb listings with various filters and pagination. Provide direct links ,→ to the user\", \"input_schema\": { \"type\": \"object\", \"properties\": { \"location\": { \"type\": \"string\", \"description\": \"Location to search for (city, state, etc.)\" }, \"placeId\": { \"type\": \"string\", \"description\": \"Google Maps Place ID (overrides the location parameter)\" }, \"checkin\": { \"type\": \"string\", \"description\": \"Check-in date (YYYY-MM-DD)\" }, \"checkout\": { \"type\": \"string\", \"description\": \"Check-out date (YYYY-MM-DD)\" }, \"adults\": { \"type\": \"number\", \"description\": \"Number of adults\" }, \"children\": { \"type\": \"number\", \"description\": \"Number of children\" }, \"infants\": { \"type\": \"number\", \"description\": \"Number of infants\" },", "source": "marker_v2", "marker_block_id": "/page/13/Code/5"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0105", "section": "Example 1: MCP-server schema instance (Dsrv).", "page_start": 15, "page_end": 15, "type": "Code", "text": "770 774 778 779 780 781 782 783 784 785 786 788 789 790 791 792 793 794 796 797 799 801 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 822 823 824 \"pets\": { \"type\": \"number\", \"description\": \"Number of pets\" }, \"minPrice\": { \"type\": \"number\", \"description\": \"Minimum price for the stay\" }, \"maxPrice\": { \"type\": \"number\", \"description\": \"Maximum price for the stay\" }, \"cursor\": { \"type\": \"string\", \"description\": \"Base64-encoded string used for Pagination\" }, \"ignoreRobotsText\": { \"type\": \"boolean\", \"description\": \"Ignore robots.txt rules for this request\" } }, \"required\": [ \"location\" ] }, \"annotations\": null }, { \"name\": \"airbnb_listing_details\", \"description\": \"Get detailed information about a specific Airbnb listing. Provide direct links to the ,→ user\", \"input_schema\": { \"type\": \"object\", \"properties\": { \"id\": { \"type\": \"string\", \"description\": \"The Airbnb listing ID\" }, \"checkin\": { \"type\": \"string\", \"description\": \"Check-in date (YYYY-MM-DD)\" }, \"checkout\": { \"type\": \"string\", \"description\": \"Check-out date (YYYY-MM-DD)\" }, \"adults\": { \"type\": \"number\", \"description\": \"Number of adults\" }, \"children\": { \"type\": \"number\", \"description\": \"Number of children\" }, \"infants\": { \"type\": \"number\", \"description\": \"Number of infants\" }, \"pets\": { \"type\": \"number\", \"description\": \"Number of pets\" }, \"ignoreRobotsText\": { \"type\": \"boolean\", \"description\": \"Ignore robots.txt rules for this request\"", "source": "marker_v2", "marker_block_id": "/page/14/Code/1"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0106", "section": "Example 1: MCP-server schema instance (Dsrv).", "page_start": 16, "page_end": 16, "type": "Code", "text": "} }, \"required\": [ \"id\" }, \"annotations\": null } ], \"tool_count\": 2, \"tool_names\": [ \"airbnb_search\", \"airbnb_listing_details\" ] }, \"processed_timestamp\": 1753731940, \"processing_mode\": \"smithery\", \"rank\": 556 } }", "source": "marker_v2", "marker_block_id": "/page/15/Code/1"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0107", "section": "Example 2: Task instance (Dtraj ).", "page_start": 16, "page_end": 16, "type": "Code", "text": "{ \"question_id\":12413, \"question\": \"I am trying to determine the launch angles for a projectile that must travel 30 m horizontally and ,→ reach a height of 5 m at that point.#\" }", "source": "marker_v2", "marker_block_id": "/page/15/Code/3"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0108", "section": "Example 3: Unit test instance (Dut).", "page_start": 16, "page_end": 16, "type": "Code", "text": "{ \"function_name\": \"listProviders\", \"arguments\": {}, \"function_output_content\": \"{\\n \\\"ollama\\\": {\\n \\\"models\\\": [\\n \\\"llama2\\\",\\n \\\"mistral\\\",\\n ,→ \\\"mixtral\\\",\\n \\\"nous-hermes\\\",\\n \\\"neural-chat\\\",\\n \\\"vicuna\\\",\\n ,→ \\\"codellama\\\",\\n \\\"phi\\\"\\n ],\\n \\\"supportsReasoning\\\": false\\n }\\n}\" }", "source": "marker_v2", "marker_block_id": "/page/15/Code/5"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0109", "section": "B.2. MCP-server Filtering Details", "page_start": 16, "page_end": 16, "type": "Text", "text": "We provide implementation details of the four-stage MCP-server filtering pipeline summarized in the main text.", "source": "marker_v2", "marker_block_id": "/page/15/Text/7"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0110", "section": "B.2. MCP-server Filtering Details", "page_start": 16, "page_end": 16, "type": "Text", "text": "Stage I: Structure Validation. We require each candidate server to expose a parseable MCP tool registry with valid tool_name and description fields, as well as JSON schemas for tool inputs (and outputs when available). Servers with missing, malformed, or non-parseable registries are removed.", "source": "marker_v2", "marker_block_id": "/page/15/Text/8"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0111", "section": "B.2. MCP-server Filtering Details", "page_start": 16, "page_end": 16, "type": "Text", "text": "Stage II: Executable Validation. We launch each server in a sandboxed environment with resource and network isolation, and attempt to invoke its tools under fixed timeouts. Servers that fail to start or cannot be successfully invoked within 3 retries are discarded, ensuring basic executability and robustness.", "source": "marker_v2", "marker_block_id": "/page/15/Text/9"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0112", "section": "B.2. MCP-server Filtering Details", "page_start": 16, "page_end": 16, "type": "Text", "text": "Stage III: Deduplication and Clustering. To reduce redundancy, we first remove exact duplicates based on server_name/tool_name. We then construct a schema text for each server from its server_name and tool name/description, and embed these texts using sentence-transformers/all-MiniLM-L6-v2. Servers are clustered using complete-link hierarchical clustering with cosine similarity threshold 0.9, i.e., a server joins a cluster only if it is at least 0.9 similar to all existing members. We retain one representative per cluster, preferring servers with (i) fully parseable registries, (ii) clearer tool descriptions, and (iii) fewer external dependencies. This stage yields 121 servers.", "source": "marker_v2", "marker_block_id": "/page/15/Text/10"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0113", "section": "B.2. MCP-server Filtering Details", "page_start": 17, "page_end": 17, "type": "Text", "text": "Stage IV: LLM Semantic Validation. We apply an LLM-based auditor to analyze each server's tool descriptions and schemas. The auditor labels servers as stateless or stateful, flags whether external API credentials are required (requires_api), and assigns a sandbox requirement level (L0–L5). We discard servers that require external credentials or whose sandbox requirement level is L3–L5, ensuring safe execution under our benchmark setting.", "source": "marker_v2", "marker_block_id": "/page/16/Text/1"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0114", "section": "B.2. MCP-server Filtering Details", "page_start": 17, "page_end": 17, "type": "Text", "text": "Appendix Figure 7 summarizes the end-to-end filtering pipeline and per-stage attrition.", "source": "marker_v2", "marker_block_id": "/page/16/Text/2"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0115", "section": "B.3. LLM-as-Judge Prompt for Server Semantic Validation", "page_start": 17, "page_end": 17, "type": "Code", "text": "LLM-as-Judge Mcp-server You are an AI assistant. I will give you a tool-scheme JSON for a single server. Please output ONLY one JSON object (no array, no markdown fences) with exactly these fields: - server_name (string): the name of the server - clarity_score (integer 1--10): overall clarity of all tool descriptions - 1 = completely unclear, jargon-filled - 5 = generally understandable but some omissions or ambiguities - 10 = crystal-clear, concise, no ambiguity - clarity_comment (string): brief rationale, e.g. which parts were ambiguous or exemplary - usefulness_score (integer 1--10): overall usefulness of descriptions for a developer - 1 = almost no practical guidance, missing parameters/examples - 5 = some guidance present but lacks examples or edge-case notes - 10 = highly practical, with examples, parameter hints, and usage notes - usefulness_comment (string): brief rationale, e.g. missing examples or strong guidance - risk_level (\"low\"/\"medium\"/\"high\"): Assess overall risk as low for read-only tools, medium for write/modify operations with safeguards, and ,→ high for destructive or privileged actions (e.g. file deletion, shell execution) or known malicious patterns. - risk_reason (string): explanation for the chosen risk level - domain (string): choose one of the existing domains or invent a new one if none fit - complexity_avg (number 1--10): average complexity across tools - 1 = trivial single-parameter lookup - 5 = moderate (several parameters, optional flags) - 10 = very complex (multiple steps, nested structures) - complexity_comment (string): brief note on what drove the complexity up or down - api_type (string): choose exactly one from the list below Here is the list of existing domains: {', '.join(existing_domains) if existing_domains else '[no existing domains]'} Here is the list of acceptable API types: {', '.join(api_types)} Here is the raw tool-scheme JSON: {json.dumps(data, ensure_ascii=False)} Ensure the returned JSON object uses one–and only one–value for both \"domain\" and \"api_type\", and includes all fields above with concise but clear comments.", "source": "marker_v2", "marker_block_id": "/page/16/Code/4"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0116", "section": "B.4. Task Generation and Filtering", "page_start": 18, "page_end": 18, "type": "Code", "text": "Task Generate ### Task Objective Generate a Tool Use Question based on the provided MCP Server and its tool descriptions. ### Goal Analyze the provided MCP Server and its available tools, then create a realistic user question that would ,→ naturally require the use of one of these tools to solve. ### Guidelines #### Question Realism * Create questions that represent real-world scenarios where users would need to interact with the MCP ,→ Server's tools. * The question should sound natural and authentic, as if asked by someone genuinely needing to accomplish ,→ a task. * Consider common use cases, problems, or workflows that would require the functionality provided by the ,→ MCP Server's tools. #### Tool Selection * Focus on ONE specific tool from the MCP Server that would be most appropriate to answer the question. * Choose tools based on the core functionality they provide and how they would solve real user problems. * Consider each tool's description and purpose when crafting the question. #### Question Complexity * Create questions that are clear and specific enough to warrant tool usage. * Avoid overly simple questions that could be answered without tools. * Include relevant context or constraints that make the tool usage necessary. * Do not include the tool's name directly in the question. #### Output Format Your response should include the following: 1. Tool Analysis: Briefly analyze the MCP Server's available tools and their main functionalities. 2. Target Tool: The specific tool name from the MCP Server that should be used to answer this question. 3. Question: A clear, realistic user question that requires tool usage. ### MCP Server Description {{ MCP_SERVER_NAME }}: {{ MCP_SERVER_DESCRIPTION }} Available Tools: {{ TOOL_LIST }} Initial State: {{ INIT_STATE }} ### Ideas {{ CONSTRUCTIVE_IDEAS }} ### Output Example Please provide your response in the following JSON format:", "source": "marker_v2", "marker_block_id": "/page/17/Code/2"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0117", "section": "B.4. Task Generation and Filtering", "page_start": 19, "page_end": 19, "type": "Code", "text": "1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1014 1015 1016 1018 1019 1020 1021 1024 1026 1028 1030 1031 1034 1036 1038 1040 1041 1042 ```json { \"tool_analysis\": \"Briefly analyze the MCP Server's available tools and their main functionalities.\", \"target_tool\": \"The specific tool name from the MCP Server that should be used to answer this ,→ question.\", \"question\": \"A clear, realistic user question that requires tool usage.\" } ``` Task filtering (LLM-as-judge) ### Task Conduct a Question Quality Assessment of a tool use question across six key dimensions to ensure it meets ,→ high standards for realistic tool usage scenarios. ### Objective Analyze the provided tool use question and assess its quality across six primary dimensions: 1. Tool Selection Difficulty - How challenging it is to determine which tools to use from all available ,→ tools. 2. Tool Selection Uniqueness - How unique and necessary the selected tools are for this specific task ,→ among the available tools. 3. Question Quality - Overall clarity, specificity, and effectiveness of the question. 4. Scenario Realism - How authentic and believable the scenario is. 5. Verifiability - How easy it is to verify the correctness of the final model's answer. 6. Stability - How stable the answer will be when requested under different time and geolocation. 7. Completeness - Whether the question provides sufficient information to solve the problem without ,→ requiring additional clarification. ### Assessment Criteria #### 1. Tool Selection Difficulty What to Evaluate: How difficult it would be for a user to determine which specific tools are needed to ,→ solve the question. Rating Guidelines: * very easy: Question explicitly mentions tool names or makes tool selection obvious. * easy: Tool selection is straightforward with clear indicators. * medium: Requires some reasoning, but tool needs are fairly apparent. * hard: Requires careful analysis to determine appropriate tools. * very hard: Requires extensive expertise and deep reasoning to identify the correct tools. #### 2. Tool Selection Uniqueness What to Evaluate: How unique and necessary the selected tools are for completing this task, and whether ,→ the task can only be solved with these tools in the specified sequence. Rating Guidelines: * not unique: Many alternative tool combinations could achieve the same task. * somewhat unique: Some alternative approaches exist, but selected tools offer advantages. * moderately unique: Selected tools are well-suited, with limited alternatives. * quite unique: Selected tools are particularly well-matched to the task requirements. * highly unique: Task can only be accomplished effectively with these specific tools in this sequence. #### 3. Question Quality", "source": "marker_v2", "marker_block_id": "/page/18/Code/1"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0118", "section": "B.4. Task Generation and Filtering", "page_start": 20, "page_end": 20, "type": "Code", "text": "1045 1046 1047 1048 1049 1050 1051 1054 1056 1058 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1071 1074 1075 1076 1078 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 What to Evaluate: Overall clarity, specificity, and effectiveness of the question as a realistic user ,→ query. Rating Guidelines: * very poor: Unclear, ambiguous, or poorly constructed question. * poor: Some clarity issues, missing important context. * average: Clear and understandable, but could be more specific or engaging. * good: Well-constructed, clear, specific, and realistic. * excellent: Exceptionally clear, detailed, engaging, and professionally written. #### 4. Scenario Realism What to Evaluate: How authentic, believable, and true-to-life the described scenario is. Rating Guidelines: * unrealistic: Artificial, contrived, or implausible scenario. * somewhat unrealistic: Some realistic elements, but feels forced or unlikely. * moderately realistic: Believable scenario with minor authenticity issues. * realistic: Authentic scenario that represents genuine use cases. * highly realistic: Completely natural, authentic scenario indistinguishable from real user needs. #### 5. Verifiability What to Evaluate: How easy it is to verify the correctness of the final model answer. Rating Guidelines: * hard to verify: Fully free-form answer that requires extensive human judgment. * somewhat hard: Mostly subjective answer with some verifiable elements. * moderately verifiable: Short sentence that can be verified by LLM comparison. * mostly verifiable: Answer with clear, objective components and some subjective elements. * easy to verify: Answer can be verified by simple rules, exact matches, or clear success criteria. #### 6. Stability (1-5 Scale) What to Evaluate: How stable and consistent the answer will be when the question is asked under different ,→ environmental conditions and system contexts. Consider factors like temporal dependency, ,→ geographical variations, operating system differences, network environments, and software version ,→ variations. Rating Guidelines: * highly unstable: Answer changes significantly across different conditions (real-time data, ,→ location-specific, system-dependent). * somewhat unstable: Answer may vary moderately based on environmental or system factors. * moderately stable: Answer mostly consistent with minor variations due to context. * mostly stable: Answer remains largely consistent across different conditions. * highly stable: Answer is completely independent of environmental and system factors. #### 7. Completeness What to Evaluate: Whether the question contains all necessary information (parameters, constraints, ,→ context) for the tool to successfully execute the task without needing to ask the user for more ,→ details. Rating Guidelines: * incomplete: Missing critical information required by the tool (e.g., missing destination for a trip). * somewhat complete: Missing some non-critical information, might require assumption or default values. * complete: Contains all necessary information to execute the task.", "source": "marker_v2", "marker_block_id": "/page/19/Code/1"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0119", "section": "B.4. Task Generation and Filtering", "page_start": 21, "page_end": 21, "type": "Code", "text": "1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 ### Question Analysis #### All Available Tools ``` {{ ALL_SERVER_AND_TOOL_INFORMATION }} ``` #### Question Content ``` {{ QUESTION_CONTENT }} ``` #### Intended Tool for This Question ``` {{ INTENDED_TOOL }} ``` #### Previous Feedback (if any) ``` {{ FEEDBACK }} ``` ### Output Requirements Provide a detailed analysis with reasoning BEFORE scores for each of the seven metrics. If the question is rated as incomplete or somewhat complete, provide specific Constructive Feedback on ,→ what information is missing and how to improve the question. ### Output Provide your response in the following JSON format: ```json { \"tool_selection_difficulty\": { \"reasoning\": \"Detailed explanation including ambiguity level, domain knowledge required, and ,→ alternative solutions giving all available tools.\", \"rating\": \"Rating: very easy, easy, medium, hard, very hard\" }, \"tool_selection_uniqueness\": { \"reasoning\": \"Detailed explanation of tool necessity, sequential dependencies, and alternative tool ,→ viability giving all available tools.\", \"rating\": \"Rating: not unique, somewhat unique, moderately unique, quite unique, highly unique\" }, \"question_quality\": { \"reasoning\": \"Detailed explanation covering linguistic quality, information architecture, and ,→ actionability.\", \"rating\": \"Rating: very poor, poor, average, good, excellent\" }, \"scenario_realism\": { \"reasoning\": \"Detailed explanation of industry authenticity, workflow accuracy, and stakeholder ,→ behavior.\", \"rating\": \"Rating: unrealistic, somewhat unrealistic, moderately realistic, realistic, highly ,→ realistic\" },", "source": "marker_v2", "marker_block_id": "/page/20/Code/1"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0120", "section": "B.4. Task Generation and Filtering", "page_start": 22, "page_end": 22, "type": "Code", "text": "1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 \"verifiability\": { \"reasoning\": \"Detailed explanation of answer format, objective criteria, and ground truth ,→ availability.\", \"rating\": \"Rating: hard to verify, somewhat hard, moderately verifiable, mostly verifiable, easy to ,→ verify\" }, \"stability\": { \"reasoning\": \"Detailed explanation of temporal/geographical/system dependencies and environmental ,→ factors.\", \"rating\": \"Rating: highly unstable, somewhat unstable, moderately stable, mostly stable, highly stable\" }, \"completeness\": { \"reasoning\": \"Detailed explanation of whether all necessary parameters are present.\", \"rating\": \"Rating: incomplete, somewhat complete, complete\" }, \"feedback\": \"Specific instructions on how to improve the question if it failed any criteria, especially ,→ completeness. Leave empty if all good.\" } ```", "source": "marker_v2", "marker_block_id": "/page/21/Code/1"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0121", "section": "B.5. Trajectory Generation and Filtering", "page_start": 22, "page_end": 22, "type": "Text", "text": "Trajectory Filtering(LLM-as-judge).", "source": "marker_v2", "marker_block_id": "/page/21/Text/3"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0122", "section": "B.5. Trajectory Generation and Filtering", "page_start": 22, "page_end": 22, "type": "Code", "text": "1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1208 1209 Deep Researcher ### Task You are given: 1. the user's request (QUESTION_CONTENT) 2. the full conversation history (CONVERSATION_HISTORY), including all assistant turns and any tool ,→ outputs. Your task is to assess whether the assistant has ultimately delivered a usable, end-to-end outcome by the ,→ end of the conversation. Completeness is the ONLY evaluation dimension. Ignore verbosity, writing quality, politeness, and ,→ intermediate mistakes. ### Core Principle At the end of the conversation, if the user stops right there, can they achieve their goal without any ,→ essential follow-up? * If YES -> higher completeness score. * If NO -> you must identify the missing element that prevents success. ### What Counts as \"Complete\" The assistant is complete only if it satisfies the user's goal end-to-end, which typically requires: * The must-have deliverable is provided (e.g., final answer, file, code patch, plan, table, steps). * If actions depend on tools/files, the assistant either: * successfully uses them and delivers results, or * if blocked (tool failure / missing access), provides a working fallback (clear manual steps, ,→ alternative method, or minimal viable deliverable). * Includes any essential \"last-mile\" details: paths, commands, file links, or instructions needed to use", "source": "marker_v2", "marker_block_id": "/page/21/Code/4"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0123", "section": "B.5. Trajectory Generation and Filtering", "page_start": 23, "page_end": 23, "type": "Code", "text": "1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 ,→ the output. Do NOT reward partial attempts unless the outcome is still usable. ### Rating (1-5) Assign exactly one integer score: 1 – very incomplete: No usable outcome; major must-haves missing. 2 – incomplete: Some progress, but the user still cannot accomplish the goal. 3 – partially complete: Core work attempted; usable only with significant user effort or a key missing ,→ piece. 4 – mostly complete: Meets most must-haves; only minor omissions or small usability issues remain. 5 – fully complete: Fully meets must-haves end-to-end with a usable outcome delivered. ### NEVER Do * NEVER score tool-call accuracy or penalize \"wrong tool usage\" unless it directly prevents completion. * NEVER judge style/verbosity/formatting elegance. * NEVER give credit for intentions (\"I will do X later\") unless the deliverable is actually present. * NEVER assume external actions happened without evidence in the transcript. ## Inputs ### Question Content ```json {QUESTION_CONTENT} ``` ### Conversation History ```json {CONVERSATION_HISTORY} ``` ## Output Provide your response in the following JSON format: ```json { \"completeness\": { \"reasoning\": \"Evaluate if the assistant delivered an end-to-end usable outcome, addressed all ,→ requirements, handled tool failures with alternatives, and provided necessary ,→ confirmations/paths.\", \"rating\": \"Rating: very incomplete, incomplete, partially complete, mostly complete, fully complete\" } } ```", "source": "marker_v2", "marker_block_id": "/page/22/Code/1"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0124", "section": "B.6. Unit Test Prompts", "page_start": 23, "page_end": 23, "type": "Code", "text": "Unit test synthesis You are given: (1) one tool schema (name/description/JSON schema for inputs/outputs). Generate K unit tests that improve parameter coverage, including: - boundary-value inputs,", "source": "marker_v2", "marker_block_id": "/page/22/Code/3"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0125", "section": "B.6. Unit Test Prompts", "page_start": 24, "page_end": 24, "type": "Code", "text": "- invalid or missing required fields, 1266 - rare branches implied by the description. 1267 1268 Output a JSON list. Each test: 1269 \"test_id\": \"...\", \"tool_name\": \"...\", 1270 1271 \"inputs\": { ... }, 1272 \"expected\": { \"type\": \"output\" | \"error\", 1273 \"value\": ..., 1274 \"error_type\": \"...\" // optional 1275 1276 \"source\": \"llm_synth\" 1277 } 1278 1279 Constraints: - Inputs must be schema-valid for output-type tests. 1280 - For invalid tests, violate exactly one constraint and specify the expected error_type. 1281 - Avoid any dependence on private accounts, API keys, or hidden external state. 1282 1283", "source": "marker_v2", "marker_block_id": "/page/23/Code/1"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0126", "section": "D.1. Signal-Validation Alignment (SVA) score", "page_start": 24, "page_end": 24, "type": "Text", "text": "Verification signals. We use three automated verification signals computed from the produced MCP server artifact: (i) Schema-F1 , measuring interface match quality between predicted and reference tool signatures; (ii) UT_{soft} and (iii) UT_{hard} , measuring tool-call verification pass rates under a permissive (soft) versus strict (hard) matching criterion.", "source": "marker_v2", "marker_block_id": "/page/23/Text/5"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0127", "section": "D.1. Signal-Validation Alignment (SVA) score", "page_start": 24, "page_end": 24, "type": "Text", "text": "Downstream validation target. For each instance i, we denote the downstream validation value as r_i \\in [0, 1] , instantiated in our experiments as the trajectory-level validation rate (soft).", "source": "marker_v2", "marker_block_id": "/page/23/Text/6"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0128", "section": "D.1. Signal-Validation Alignment (SVA) score", "page_start": 24, "page_end": 24, "type": "Text", "text": "Definition. Given a verification signal s_i \\in [0,1] and downstream validation r_i , we define the Signal-Validation Alignment (SVA) score as", "source": "marker_v2", "marker_block_id": "/page/23/Text/7"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0129", "section": "D.1. Signal-Validation Alignment (SVA) score", "page_start": 24, "page_end": 24, "type": "Equation", "text": "SVA(s,r) = \\frac{\\sum_{i:s_i>0} s_i r_i}{\\sum_{i:s_i>0} s_i + |\\{i:s_i \\le 0\\}|}. (17)", "source": "marker_v2", "marker_block_id": "/page/23/Equation/8"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0130", "section": "D.1. Signal-Validation Alignment (SVA) score", "page_start": 24, "page_end": 24, "type": "Text", "text": "Unlike correlation, SVA evaluates whether high verification-signal values concentrate on instances with high downstream validation, and it additionally penalizes zero-signal cases through the term |\\{i: s_i \\leq 0\\}| , capturing signal coverage (i.e., how often a signal collapses to zero or becomes uninformative). Higher SVA therefore indicates a verification signal that is both more indicative of downstream validation and more consistently defined across instances.", "source": "marker_v2", "marker_block_id": "/page/23/Text/9"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0131", "section": "E.1. Finetuning Exploration", "page_start": 24, "page_end": 24, "type": "Text", "text": "We study finetuning on TOOL GENESIS as a simple and reproducible adaptation mechanism.", "source": "marker_v2", "marker_block_id": "/page/23/Text/12"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0132", "section": "E.1. Finetuning Exploration", "page_start": 24, "page_end": 24, "type": "Text", "text": "Data construction. We construct an executable supervision signal by collecting successful tool-creation trajectories from a held-out pool of MCP servers. Concretely, we run our Code-Agent pipeline (generate-execute-repair) with DeepSeek-V3.2 as the backbone model and synthesize approximately 1,000 tool-creation trajectories. Each trajectory records the requirement, the generated MCP tool registry (schema), the materialized implementation artifact (server code), and optional execution/verification feedback produced during the loop (e.g., launch errors and unit-test summaries). We then apply strict filtering to retain only high-quality instances whose final artifacts are (i) MCP-compliant and parseable, (ii) executable under our sandbox, and (iii) verifiable by our automated checks (unit tests when available). We further remove trajectories", "source": "marker_v2", "marker_block_id": "/page/23/Text/13"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0133", "section": "E.1. Finetuning Exploration", "page_start": 25, "page_end": 25, "type": "Text", "text": "that require external credentials or unstable external state, and drop samples with malformed registries, non-deterministic outcomes, or excessively long logs. After filtering, we retain 500 high-quality trajectories as our finetuning training set. Unless otherwise stated, training and evaluation are server-disjoint to avoid leakage.", "source": "marker_v2", "marker_block_id": "/page/24/Text/1"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0134", "section": "E.1. Finetuning Exploration", "page_start": 25, "page_end": 25, "type": "Text", "text": "Functioning (supervision formatting). We convert each retained trajectory into instruction–response examples aligned with the TI+TM lifecycle. Specifically, we include: (i) Direct examples mapping a requirement to a single-pass output (schema plus implementation), and (ii) Repair examples unrolled from the generate–execute–repair loop, where the input additionally contains truncated executable feedback and the target is a corrected patch or revised implementation. Each repair iteration is treated as an independent example, enabling the model to learn bug localization and correction conditioned on execution signals.", "source": "marker_v2", "marker_block_id": "/page/24/Text/2"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0135", "section": "E.1. Finetuning Exploration", "page_start": 25, "page_end": 25, "type": "Text", "text": "Finetuning configuration. We fine-tune Qwen3-8B on the curated finetuning set using teacher-forcing maximum likelihood. We train for 3 epochs and keep the rest of the evaluation pipeline unchanged (prompting, decoding, tool-call parsing, runtime sandbox, and verification), ensuring an apples-to-apples comparison. We use AdamW with cosine learning-rate scheduling and warmup, gradient clipping, and mixed-precision training. The learning rate is selected within 1e-5–5e-5 on a server-disjoint development split; in our runs, the best checkpoint typically uses a learning rate around 2e-5. Unless otherwise specified, we use a max sequence length of 4k–8k tokens with packing, and gradient accumulation to match the target effective batch size under fixed hardware constraints. We report the best checkpoint on the development split and evaluate on held-out test servers.", "source": "marker_v2", "marker_block_id": "/page/24/Text/3"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0136", "section": "E.1. Finetuning Exploration", "page_start": 25, "page_end": 25, "type": "Text", "text": "Results. Finetuning on TOOL GENESIS leads to better performance. Table 6 shows that finetuning yields consistent gains across evaluation layers, demonstrating that TOOL GENESIS can serve not only as an evaluation benchmark but also as an effective training signal for tool creation. Under the Direct setting, finetuning improves one-shot schema generation quality and increases downstream task success, suggesting that finetuning internalizes MCP-compliant interface patterns and reduces schema-level failures in single-pass TI+TM. Under the Code-Agent setting, finetuning further strengthens closed-loop repair: the fine-tuned model more reliably fixes execution-triggered implementation bugs, increasing unit-test pass rates (UT) and improving task success (SR). Overall, finetuning primarily strengthens one-shot generation under Direct, while under Code-Agent it improves bug localization and correction, translating executable feedback into measurable downstream utility.", "source": "marker_v2", "marker_block_id": "/page/24/Text/4"}

icml26/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/appendix_text_v3.txt

@@ -0,0 +1,206 @@
+[p. 12 | section: A. Evaluation Methodology Details | type: Text]
+We provide mathematical formulations and implementation details for the metrics in Section 2.2. We evaluate N generated MCP-server implementations \{\hat{e}_i\}_{i=1}^N . Each server is expected to expose a list_tools endpoint returning a tool registry (a list of tool schemas).
+
+[p. 12 | section: A.1. Layer 1: Surface Compliance and Server Execution | type: Text]
+Compliance (OpenAI tool-calling format). We treat compliance as a strict format check: whether the returned tool registry is parseable and satisfies the OpenAI tool-calling specification. Let \mathcal{V}_{OpenAI} denote the corresponding JSON Schema validator, and let parse(·) return a parsed JSON object if successful (otherwise \bot ). We define the per-instance compliance indicator:
+
+[p. 12 | section: A.1. Layer 1: Surface Compliance and Server Execution | type: Equation]
+compliant(\hat{e}_i) = \mathbb{I}[parse(list\_tools(\hat{e}_i)) \neq \bot \land parse(list\_tools(\hat{e}_i)) \models \mathcal{V}_{OpenAI}], \tag{2}
+
+[p. 12 | section: A.1. Layer 1: Surface Compliance and Server Execution | type: Text]
+and report the dataset-level score:
+
+[p. 12 | section: A.1. Layer 1: Surface Compliance and Server Execution | type: Equation]
+Compliance = \frac{1}{N} \sum_{i=1}^{N} \text{compliant}(\hat{e}_i) . (3)
+
+[p. 12 | section: A.1. Layer 1: Surface Compliance and Server Execution | type: Text]
+Server execution (3 independent launches). We attempt to start each server R=3 times under fixed timeouts. Let \operatorname{run}(\hat{e}_i,r)\in\{0,1\} indicate whether the r-th launch succeeds and the server remains responsive (e.g., responds to list_tools) within the timeout. We define the per-instance execution score:
+
+[p. 12 | section: A.1. Layer 1: Surface Compliance and Server Execution | type: Equation]
+\operatorname{exec}(\hat{e}_i) = \frac{1}{R} \sum_{r=1}^{R} \operatorname{run}(\hat{e}_i, r), \qquad R = 3, (4)
+
+[p. 12 | section: A.1. Layer 1: Surface Compliance and Server Execution | type: Text]
+and report the dataset-level score:
+
+[p. 12 | section: A.1. Layer 1: Surface Compliance and Server Execution | type: Equation]
+ServerExecution = \frac{1}{N} \sum_{i=1}^{N} \operatorname{exec}(\hat{e}_i) . (5)
+
+[p. 12 | section: A.2. Layer 2: Semantic Interface Fidelity (Schema-F1) | type: Text]
+Layer 2 evaluates whether the predicted tool interfaces match the reference interfaces, independent of code execution. For instance i, let \hat{s}_i be the predicted tool set and s_i^* the reference tool set. Each tool schema is represented as t = \langle \eta, \phi \rangle , where \eta is function_name and \phi is the JSON-schema-like argument definition.
+
+[p. 12 | section: A.2. Layer 2: Semantic Interface Fidelity (Schema-F1) | type: Text]
+Embedding-based similarity on function_name + args. We define a canonical serialization g(t) = \eta \oplus \operatorname{canon}(\phi) , where \oplus denotes concatenation and \operatorname{canon}(\cdot) produces a deterministic string form (e.g., JSON dump with sorted keys). We embed g(t) using sentence-transformers/all-MiniLM-L6-v2, denoted by \mathbf{E}(\cdot) , and define cosine similarity:
+
+[p. 12 | section: A.2. Layer 2: Semantic Interface Fidelity (Schema-F1) | type: Equation]
+w(u,v) = \cos(\mathbf{E}(g(u)), \mathbf{E}(g(v))). \tag{6}
+
+[p. 12 | section: A.2. Layer 2: Semantic Interface Fidelity (Schema-F1) | type: Text]
+Maximum-weight matching and F1. We construct a bipartite graph between \hat{s}_i and s_i^* with edge weights w(\cdot,\cdot) , and compute a maximum-weight matching M_i . A matched pair is counted as correct if w(u,v) \geq \tau for a fixed threshold \tau . Let m_i = |\{(u,v) \in M_i : w(u,v) \geq \tau\}| . Then
+
+[p. 12 | section: A.2. Layer 2: Semantic Interface Fidelity (Schema-F1) | type: Equation]
+P_i = \frac{m_i}{|\hat{s}_i|}, \qquad R_i = \frac{m_i}{|s_i^*|}, \qquad \text{SchemaF1}_i = \frac{2P_i R_i}{P_i + R_i + \epsilon}, \tag{7}
+
+[p. 12 | section: A.2. Layer 2: Semantic Interface Fidelity (Schema-F1) | type: Text]
+where \epsilon is a small constant for numerical stability, and we report:
+
+[p. 12 | section: A.2. Layer 2: Semantic Interface Fidelity (Schema-F1) | type: Equation]
+SchemaF1 = \frac{1}{N} \sum_{i=1}^{N} SchemaF1_{i}. (8)
+
+[p. 12 | section: A.2. Layer 2: Semantic Interface Fidelity (Schema-F1) | type: Text]
+Note. Schema-F1 compares tool interfaces (names and argument schemas), and is distinct from the structured score in Layer 3, which compares tool outputs via key-path overlap.
+
+[p. 13 | section: A.3. Layer 3: Functional Correctness via Unit Tests (UT) | type: Text]
+Layer 3 evaluates functional correctness by executing unit tests. Each unit test is a triple ⟨η, x, y ∗ ⟩, where η is the tool name, x is the input arguments, and y ∗ is the expected output. Running the tool on the generated server yields an actual output yˆ. We score each test case by combining (i) a structured score and (ii) an embedding similarity score.
+
+[p. 13 | section: A.3. Layer 3: Functional Correctness via Unit Tests (UT) | type: Text]
+(i) Structured score (JSON key-path overlap). We consider the common case where y ∗ is JSON (or parseable as JSON). Let parse(·) parse JSON successfully or return ⊥. If parse(ˆy) = ⊥, we set the structured score to 0. Otherwise, we extract a set of key-path strings from a JSON object, denoted by paths(·) (e.g., a.b[0].c). Define
+
+[p. 13 | section: A.3. Layer 3: Functional Correctness via Unit Tests (UT) | type: Equation]
+P_{\text{path}} = \frac{|\text{paths}(\hat{y}) \cap \text{paths}(y^*)|}{|\text{paths}(\hat{y})| + \epsilon}, \qquad R_{\text{path}} = \frac{|\text{paths}(\hat{y}) \cap \text{paths}(y^*)|}{|\text{paths}(y^*)| + \epsilon}, \tag{9}
+
+[p. 13 | section: A.3. Layer 3: Functional Correctness via Unit Tests (UT) | type: Text]
+and the structured score (F1 over key paths):
+
+[p. 13 | section: A.3. Layer 3: Functional Correctness via Unit Tests (UT) | type: Equation]
+struct(\hat{y}, y^*) = \frac{2P_{path}R_{path}}{P_{path} + R_{path} + \epsilon}. (10)
+
+[p. 13 | section: A.3. Layer 3: Functional Correctness via Unit Tests (UT) | type: Text]
+(ii) Embedding similarity of outputs. We canonicalize outputs via canon(·) (stable JSON dump if parseable; otherwise raw text), embed using sentence-transformers/all-MiniLM-L6-v2 (denoted by E(·)), and compute:
+
+[p. 13 | section: A.3. Layer 3: Functional Correctness via Unit Tests (UT) | type: Equation]
+\operatorname{emb}(\hat{y}, y^*) = \max \Big( 0, \cos \left( \mathbf{E}(\operatorname{canon}(\hat{y})), \mathbf{E}(\operatorname{canon}(y^*)) \right) \Big). \tag{11}
+
+[p. 13 | section: A.3. Layer 3: Functional Correctness via Unit Tests (UT) | type: Text]
+UT score (equal-weight combination). For a single test case:
+
+[p. 13 | section: A.3. Layer 3: Functional Correctness via Unit Tests (UT) | type: Equation]
+UT(\hat{y}, y^*) = \frac{1}{2} struct(\hat{y}, y^*) + \frac{1}{2} emb(\hat{y}, y^*). (12)
+
+[p. 13 | section: A.3. Layer 3: Functional Correctness via Unit Tests (UT) | type: Text]
+Aggregating across tests (standard vs. boundary). Let T std be the set of standard (positive) tests and T bnd include additional boundary/negative tests. For S ∈ {std, bnd}, we report:
+
+[p. 13 | section: A.3. Layer 3: Functional Correctness via Unit Tests (UT) | type: Equation]
+UT_{S} = \frac{1}{|\mathcal{T}^{S}|} \sum_{\langle \eta, \mathbf{x}, y^{*} \rangle \in \mathcal{T}^{S}} UT(\hat{y}(\eta, \mathbf{x}), y^{*}). (13)
+
+[p. 13 | section: A.4. Layer 4: Downstream Task Utility (Oracle-normalized SR) | type: Text]
+To evaluate end-to-end utility, we run a fixed agent based on Qwen3-14B on benchmark trajectories under two tool environments: (i) the generated MCP server eˆ and (ii) the ground-truth MCP server e ∗ . For each task instance j, an LLM judge produces two scores in [0, 1]:
+
+[p. 13 | section: A.4. Layer 4: Downstream Task Utility (Oracle-normalized SR) | type: Equation]
+s_j^{\text{gen}} = \mathcal{J}(\text{trajectory produced with } \hat{e}), \qquad s_j^{\text{gt}} = \mathcal{J}(\text{trajectory produced with } e^*). (14)
+
+[p. 13 | section: A.4. Layer 4: Downstream Task Utility (Oracle-normalized SR) | type: Text]
+We compute the per-task oracle-normalized score:
+
+[p. 13 | section: A.4. Layer 4: Downstream Task Utility (Oracle-normalized SR) | type: Equation]
+SR_j = \frac{1 - s_j^{\text{gt}}}{1 - s_j^{\text{gen}} + \epsilon},\tag{15}
+
+[p. 13 | section: A.4. Layer 4: Downstream Task Utility (Oracle-normalized SR) | type: Text]
+and report the dataset-level score:
+
+[p. 13 | section: A.4. Layer 4: Downstream Task Utility (Oracle-normalized SR) | type: Equation]
+SR = \frac{1}{|\mathcal{D}_{task}|} \sum_{j \in \mathcal{D}_{task}} SR_j. (16)
+
+[p. 13 | section: B. More Dataset Construction Details | type: Text]
+This appendix provides implementation details for the four-stage construction pipeline in Figure 2, including crawling, schema standardization, executable validation, clustering/deduplication, LLM-as-judge rubrics, task/trajectory generation filters, unit-test synthesis, and final release policies.
+
+[p. 14 | section: B. More Dataset Construction Details | type: FigureGroup]
+Figure 7. Data flow and attrition in MCP-server collection. Sankey diagram summarizing the sequential filtering stages for constructing Dsrv, reporting the number of servers retained (and discarded) at each stage. Placeholder: will be replaced by the final figure.
+
+[p. 14 | section: Example 1: MCP-server schema instance (Dsrv). | type: Code]
+{ "metadata": { "server_name": "Airbnb Search and Listing Details Server", "mode": "smithery", "timestamp": 1751938055, "remote_server_response": { "url": " "is_success": true, "error": null, "tools": [ { "name": "airbnb_search", "description": "Search for Airbnb listings with various filters and pagination. Provide direct links ,→ to the user", "input_schema": { "type": "object", "properties": { "location": { "type": "string", "description": "Location to search for (city, state, etc.)" }, "placeId": { "type": "string", "description": "Google Maps Place ID (overrides the location parameter)" }, "checkin": { "type": "string", "description": "Check-in date (YYYY-MM-DD)" }, "checkout": { "type": "string", "description": "Check-out date (YYYY-MM-DD)" }, "adults": { "type": "number", "description": "Number of adults" }, "children": { "type": "number", "description": "Number of children" }, "infants": { "type": "number", "description": "Number of infants" },
+
+[p. 15 | section: Example 1: MCP-server schema instance (Dsrv). | type: Code]
+770 774 778 779 780 781 782 783 784 785 786 788 789 790 791 792 793 794 796 797 799 801 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 822 823 824 "pets": { "type": "number", "description": "Number of pets" }, "minPrice": { "type": "number", "description": "Minimum price for the stay" }, "maxPrice": { "type": "number", "description": "Maximum price for the stay" }, "cursor": { "type": "string", "description": "Base64-encoded string used for Pagination" }, "ignoreRobotsText": { "type": "boolean", "description": "Ignore robots.txt rules for this request" } }, "required": [ "location" ] }, "annotations": null }, { "name": "airbnb_listing_details", "description": "Get detailed information about a specific Airbnb listing. Provide direct links to the ,→ user", "input_schema": { "type": "object", "properties": { "id": { "type": "string", "description": "The Airbnb listing ID" }, "checkin": { "type": "string", "description": "Check-in date (YYYY-MM-DD)" }, "checkout": { "type": "string", "description": "Check-out date (YYYY-MM-DD)" }, "adults": { "type": "number", "description": "Number of adults" }, "children": { "type": "number", "description": "Number of children" }, "infants": { "type": "number", "description": "Number of infants" }, "pets": { "type": "number", "description": "Number of pets" }, "ignoreRobotsText": { "type": "boolean", "description": "Ignore robots.txt rules for this request"
+
+[p. 16 | section: Example 1: MCP-server schema instance (Dsrv). | type: Code]
+} }, "required": [ "id" }, "annotations": null } ], "tool_count": 2, "tool_names": [ "airbnb_search", "airbnb_listing_details" ] }, "processed_timestamp": 1753731940, "processing_mode": "smithery", "rank": 556 } }
+
+[p. 16 | section: Example 2: Task instance (Dtraj ). | type: Code]
+{ "question_id":12413, "question": "I am trying to determine the launch angles for a projectile that must travel 30 m horizontally and ,→ reach a height of 5 m at that point.#" }
+
+[p. 16 | section: Example 3: Unit test instance (Dut). | type: Code]
+{ "function_name": "listProviders", "arguments": {}, "function_output_content": "{\n \"ollama\": {\n \"models\": [\n \"llama2\",\n \"mistral\",\n ,→ \"mixtral\",\n \"nous-hermes\",\n \"neural-chat\",\n \"vicuna\",\n ,→ \"codellama\",\n \"phi\"\n ],\n \"supportsReasoning\": false\n }\n}" }
+
+[p. 16 | section: B.2. MCP-server Filtering Details | type: Text]
+We provide implementation details of the four-stage MCP-server filtering pipeline summarized in the main text.
+
+[p. 16 | section: B.2. MCP-server Filtering Details | type: Text]
+Stage I: Structure Validation. We require each candidate server to expose a parseable MCP tool registry with valid tool_name and description fields, as well as JSON schemas for tool inputs (and outputs when available). Servers with missing, malformed, or non-parseable registries are removed.
+
+[p. 16 | section: B.2. MCP-server Filtering Details | type: Text]
+Stage II: Executable Validation. We launch each server in a sandboxed environment with resource and network isolation, and attempt to invoke its tools under fixed timeouts. Servers that fail to start or cannot be successfully invoked within 3 retries are discarded, ensuring basic executability and robustness.
+
+[p. 16 | section: B.2. MCP-server Filtering Details | type: Text]
+Stage III: Deduplication and Clustering. To reduce redundancy, we first remove exact duplicates based on server_name/tool_name. We then construct a schema text for each server from its server_name and tool name/description, and embed these texts using sentence-transformers/all-MiniLM-L6-v2. Servers are clustered using complete-link hierarchical clustering with cosine similarity threshold 0.9, i.e., a server joins a cluster only if it is at least 0.9 similar to all existing members. We retain one representative per cluster, preferring servers with (i) fully parseable registries, (ii) clearer tool descriptions, and (iii) fewer external dependencies. This stage yields 121 servers.
+
+[p. 17 | section: B.2. MCP-server Filtering Details | type: Text]
+Stage IV: LLM Semantic Validation. We apply an LLM-based auditor to analyze each server's tool descriptions and schemas. The auditor labels servers as stateless or stateful, flags whether external API credentials are required (requires_api), and assigns a sandbox requirement level (L0–L5). We discard servers that require external credentials or whose sandbox requirement level is L3–L5, ensuring safe execution under our benchmark setting.
+
+[p. 17 | section: B.2. MCP-server Filtering Details | type: Text]
+Appendix Figure 7 summarizes the end-to-end filtering pipeline and per-stage attrition.
+
+[p. 17 | section: B.3. LLM-as-Judge Prompt for Server Semantic Validation | type: Code]
+LLM-as-Judge Mcp-server You are an AI assistant. I will give you a tool-scheme JSON for a single server. Please output ONLY one JSON object (no array, no markdown fences) with exactly these fields: - server_name (string): the name of the server - clarity_score (integer 1--10): overall clarity of all tool descriptions - 1 = completely unclear, jargon-filled - 5 = generally understandable but some omissions or ambiguities - 10 = crystal-clear, concise, no ambiguity - clarity_comment (string): brief rationale, e.g. which parts were ambiguous or exemplary - usefulness_score (integer 1--10): overall usefulness of descriptions for a developer - 1 = almost no practical guidance, missing parameters/examples - 5 = some guidance present but lacks examples or edge-case notes - 10 = highly practical, with examples, parameter hints, and usage notes - usefulness_comment (string): brief rationale, e.g. missing examples or strong guidance - risk_level ("low"/"medium"/"high"): Assess overall risk as low for read-only tools, medium for write/modify operations with safeguards, and ,→ high for destructive or privileged actions (e.g. file deletion, shell execution) or known malicious patterns. - risk_reason (string): explanation for the chosen risk level - domain (string): choose one of the existing domains or invent a new one if none fit - complexity_avg (number 1--10): average complexity across tools - 1 = trivial single-parameter lookup - 5 = moderate (several parameters, optional flags) - 10 = very complex (multiple steps, nested structures) - complexity_comment (string): brief note on what drove the complexity up or down - api_type (string): choose exactly one from the list below Here is the list of existing domains: {', '.join(existing_domains) if existing_domains else '[no existing domains]'} Here is the list of acceptable API types: {', '.join(api_types)} Here is the raw tool-scheme JSON: {json.dumps(data, ensure_ascii=False)} Ensure the returned JSON object uses one–and only one–value for both "domain" and "api_type", and includes all fields above with concise but clear comments.
+
+[p. 18 | section: B.4. Task Generation and Filtering | type: Code]
+Task Generate ### Task Objective Generate a Tool Use Question based on the provided MCP Server and its tool descriptions. ### Goal Analyze the provided MCP Server and its available tools, then create a realistic user question that would ,→ naturally require the use of one of these tools to solve. ### Guidelines #### Question Realism * Create questions that represent real-world scenarios where users would need to interact with the MCP ,→ Server's tools. * The question should sound natural and authentic, as if asked by someone genuinely needing to accomplish ,→ a task. * Consider common use cases, problems, or workflows that would require the functionality provided by the ,→ MCP Server's tools. #### Tool Selection * Focus on ONE specific tool from the MCP Server that would be most appropriate to answer the question. * Choose tools based on the core functionality they provide and how they would solve real user problems. * Consider each tool's description and purpose when crafting the question. #### Question Complexity * Create questions that are clear and specific enough to warrant tool usage. * Avoid overly simple questions that could be answered without tools. * Include relevant context or constraints that make the tool usage necessary. * Do not include the tool's name directly in the question. #### Output Format Your response should include the following: 1. Tool Analysis: Briefly analyze the MCP Server's available tools and their main functionalities. 2. Target Tool: The specific tool name from the MCP Server that should be used to answer this question. 3. Question: A clear, realistic user question that requires tool usage. ### MCP Server Description {{ MCP_SERVER_NAME }}: {{ MCP_SERVER_DESCRIPTION }} Available Tools: {{ TOOL_LIST }} Initial State: {{ INIT_STATE }} ### Ideas {{ CONSTRUCTIVE_IDEAS }} ### Output Example Please provide your response in the following JSON format:
+
+[p. 19 | section: B.4. Task Generation and Filtering | type: Code]
+1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1014 1015 1016 1018 1019 1020 1021 1024 1026 1028 1030 1031 1034 1036 1038 1040 1041 1042 ```json { "tool_analysis": "Briefly analyze the MCP Server's available tools and their main functionalities.", "target_tool": "The specific tool name from the MCP Server that should be used to answer this ,→ question.", "question": "A clear, realistic user question that requires tool usage." } ``` Task filtering (LLM-as-judge) ### Task Conduct a Question Quality Assessment of a tool use question across six key dimensions to ensure it meets ,→ high standards for realistic tool usage scenarios. ### Objective Analyze the provided tool use question and assess its quality across six primary dimensions: 1. Tool Selection Difficulty - How challenging it is to determine which tools to use from all available ,→ tools. 2. Tool Selection Uniqueness - How unique and necessary the selected tools are for this specific task ,→ among the available tools. 3. Question Quality - Overall clarity, specificity, and effectiveness of the question. 4. Scenario Realism - How authentic and believable the scenario is. 5. Verifiability - How easy it is to verify the correctness of the final model's answer. 6. Stability - How stable the answer will be when requested under different time and geolocation. 7. Completeness - Whether the question provides sufficient information to solve the problem without ,→ requiring additional clarification. ### Assessment Criteria #### 1. Tool Selection Difficulty What to Evaluate: How difficult it would be for a user to determine which specific tools are needed to ,→ solve the question. Rating Guidelines: * very easy: Question explicitly mentions tool names or makes tool selection obvious. * easy: Tool selection is straightforward with clear indicators. * medium: Requires some reasoning, but tool needs are fairly apparent. * hard: Requires careful analysis to determine appropriate tools. * very hard: Requires extensive expertise and deep reasoning to identify the correct tools. #### 2. Tool Selection Uniqueness What to Evaluate: How unique and necessary the selected tools are for completing this task, and whether ,→ the task can only be solved with these tools in the specified sequence. Rating Guidelines: * not unique: Many alternative tool combinations could achieve the same task. * somewhat unique: Some alternative approaches exist, but selected tools offer advantages. * moderately unique: Selected tools are well-suited, with limited alternatives. * quite unique: Selected tools are particularly well-matched to the task requirements. * highly unique: Task can only be accomplished effectively with these specific tools in this sequence. #### 3. Question Quality
+
+[p. 20 | section: B.4. Task Generation and Filtering | type: Code]
+1045 1046 1047 1048 1049 1050 1051 1054 1056 1058 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1071 1074 1075 1076 1078 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 What to Evaluate: Overall clarity, specificity, and effectiveness of the question as a realistic user ,→ query. Rating Guidelines: * very poor: Unclear, ambiguous, or poorly constructed question. * poor: Some clarity issues, missing important context. * average: Clear and understandable, but could be more specific or engaging. * good: Well-constructed, clear, specific, and realistic. * excellent: Exceptionally clear, detailed, engaging, and professionally written. #### 4. Scenario Realism What to Evaluate: How authentic, believable, and true-to-life the described scenario is. Rating Guidelines: * unrealistic: Artificial, contrived, or implausible scenario. * somewhat unrealistic: Some realistic elements, but feels forced or unlikely. * moderately realistic: Believable scenario with minor authenticity issues. * realistic: Authentic scenario that represents genuine use cases. * highly realistic: Completely natural, authentic scenario indistinguishable from real user needs. #### 5. Verifiability What to Evaluate: How easy it is to verify the correctness of the final model answer. Rating Guidelines: * hard to verify: Fully free-form answer that requires extensive human judgment. * somewhat hard: Mostly subjective answer with some verifiable elements. * moderately verifiable: Short sentence that can be verified by LLM comparison. * mostly verifiable: Answer with clear, objective components and some subjective elements. * easy to verify: Answer can be verified by simple rules, exact matches, or clear success criteria. #### 6. Stability (1-5 Scale) What to Evaluate: How stable and consistent the answer will be when the question is asked under different ,→ environmental conditions and system contexts. Consider factors like temporal dependency, ,→ geographical variations, operating system differences, network environments, and software version ,→ variations. Rating Guidelines: * highly unstable: Answer changes significantly across different conditions (real-time data, ,→ location-specific, system-dependent). * somewhat unstable: Answer may vary moderately based on environmental or system factors. * moderately stable: Answer mostly consistent with minor variations due to context. * mostly stable: Answer remains largely consistent across different conditions. * highly stable: Answer is completely independent of environmental and system factors. #### 7. Completeness What to Evaluate: Whether the question contains all necessary information (parameters, constraints, ,→ context) for the tool to successfully execute the task without needing to ask the user for more ,→ details. Rating Guidelines: * incomplete: Missing critical information required by the tool (e.g., missing destination for a trip). * somewhat complete: Missing some non-critical information, might require assumption or default values. * complete: Contains all necessary information to execute the task.
+
+[p. 21 | section: B.4. Task Generation and Filtering | type: Code]
+1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 ### Question Analysis #### All Available Tools ``` {{ ALL_SERVER_AND_TOOL_INFORMATION }} ``` #### Question Content ``` {{ QUESTION_CONTENT }} ``` #### Intended Tool for This Question ``` {{ INTENDED_TOOL }} ``` #### Previous Feedback (if any) ``` {{ FEEDBACK }} ``` ### Output Requirements Provide a detailed analysis with reasoning BEFORE scores for each of the seven metrics. If the question is rated as incomplete or somewhat complete, provide specific Constructive Feedback on ,→ what information is missing and how to improve the question. ### Output Provide your response in the following JSON format: ```json { "tool_selection_difficulty": { "reasoning": "Detailed explanation including ambiguity level, domain knowledge required, and ,→ alternative solutions giving all available tools.", "rating": "Rating: very easy, easy, medium, hard, very hard" }, "tool_selection_uniqueness": { "reasoning": "Detailed explanation of tool necessity, sequential dependencies, and alternative tool ,→ viability giving all available tools.", "rating": "Rating: not unique, somewhat unique, moderately unique, quite unique, highly unique" }, "question_quality": { "reasoning": "Detailed explanation covering linguistic quality, information architecture, and ,→ actionability.", "rating": "Rating: very poor, poor, average, good, excellent" }, "scenario_realism": { "reasoning": "Detailed explanation of industry authenticity, workflow accuracy, and stakeholder ,→ behavior.", "rating": "Rating: unrealistic, somewhat unrealistic, moderately realistic, realistic, highly ,→ realistic" },
+
+[p. 22 | section: B.4. Task Generation and Filtering | type: Code]
+1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 "verifiability": { "reasoning": "Detailed explanation of answer format, objective criteria, and ground truth ,→ availability.", "rating": "Rating: hard to verify, somewhat hard, moderately verifiable, mostly verifiable, easy to ,→ verify" }, "stability": { "reasoning": "Detailed explanation of temporal/geographical/system dependencies and environmental ,→ factors.", "rating": "Rating: highly unstable, somewhat unstable, moderately stable, mostly stable, highly stable" }, "completeness": { "reasoning": "Detailed explanation of whether all necessary parameters are present.", "rating": "Rating: incomplete, somewhat complete, complete" }, "feedback": "Specific instructions on how to improve the question if it failed any criteria, especially ,→ completeness. Leave empty if all good." } ```
+
+[p. 22 | section: B.5. Trajectory Generation and Filtering | type: Text]
+Trajectory Filtering(LLM-as-judge).
+
+[p. 22 | section: B.5. Trajectory Generation and Filtering | type: Code]
+1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1208 1209 Deep Researcher ### Task You are given: 1. the user's request (QUESTION_CONTENT) 2. the full conversation history (CONVERSATION_HISTORY), including all assistant turns and any tool ,→ outputs. Your task is to assess whether the assistant has ultimately delivered a usable, end-to-end outcome by the ,→ end of the conversation. Completeness is the ONLY evaluation dimension. Ignore verbosity, writing quality, politeness, and ,→ intermediate mistakes. ### Core Principle At the end of the conversation, if the user stops right there, can they achieve their goal without any ,→ essential follow-up? * If YES -> higher completeness score. * If NO -> you must identify the missing element that prevents success. ### What Counts as "Complete" The assistant is complete only if it satisfies the user's goal end-to-end, which typically requires: * The must-have deliverable is provided (e.g., final answer, file, code patch, plan, table, steps). * If actions depend on tools/files, the assistant either: * successfully uses them and delivers results, or * if blocked (tool failure / missing access), provides a working fallback (clear manual steps, ,→ alternative method, or minimal viable deliverable). * Includes any essential "last-mile" details: paths, commands, file links, or instructions needed to use
+
+[p. 23 | section: B.5. Trajectory Generation and Filtering | type: Code]
+1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 ,→ the output. Do NOT reward partial attempts unless the outcome is still usable. ### Rating (1-5) Assign exactly one integer score: 1 – very incomplete: No usable outcome; major must-haves missing. 2 – incomplete: Some progress, but the user still cannot accomplish the goal. 3 – partially complete: Core work attempted; usable only with significant user effort or a key missing ,→ piece. 4 – mostly complete: Meets most must-haves; only minor omissions or small usability issues remain. 5 – fully complete: Fully meets must-haves end-to-end with a usable outcome delivered. ### NEVER Do * NEVER score tool-call accuracy or penalize "wrong tool usage" unless it directly prevents completion. * NEVER judge style/verbosity/formatting elegance. * NEVER give credit for intentions ("I will do X later") unless the deliverable is actually present. * NEVER assume external actions happened without evidence in the transcript. ## Inputs ### Question Content ```json {QUESTION_CONTENT} ``` ### Conversation History ```json {CONVERSATION_HISTORY} ``` ## Output Provide your response in the following JSON format: ```json { "completeness": { "reasoning": "Evaluate if the assistant delivered an end-to-end usable outcome, addressed all ,→ requirements, handled tool failures with alternatives, and provided necessary ,→ confirmations/paths.", "rating": "Rating: very incomplete, incomplete, partially complete, mostly complete, fully complete" } } ```
+
+[p. 23 | section: B.6. Unit Test Prompts | type: Code]
+Unit test synthesis You are given: (1) one tool schema (name/description/JSON schema for inputs/outputs). Generate K unit tests that improve parameter coverage, including: - boundary-value inputs,
+
+[p. 24 | section: B.6. Unit Test Prompts | type: Code]
+- invalid or missing required fields, 1266 - rare branches implied by the description. 1267 1268 Output a JSON list. Each test: 1269 "test_id": "...", "tool_name": "...", 1270 1271 "inputs": { ... }, 1272 "expected": { "type": "output" | "error", 1273 "value": ..., 1274 "error_type": "..." // optional 1275 1276 "source": "llm_synth" 1277 } 1278 1279 Constraints: - Inputs must be schema-valid for output-type tests. 1280 - For invalid tests, violate exactly one constraint and specify the expected error_type. 1281 - Avoid any dependence on private accounts, API keys, or hidden external state. 1282 1283
+
+[p. 24 | section: D.1. Signal-Validation Alignment (SVA) score | type: Text]
+Verification signals. We use three automated verification signals computed from the produced MCP server artifact: (i) Schema-F1 , measuring interface match quality between predicted and reference tool signatures; (ii) UT_{soft} and (iii) UT_{hard} , measuring tool-call verification pass rates under a permissive (soft) versus strict (hard) matching criterion.
+
+[p. 24 | section: D.1. Signal-Validation Alignment (SVA) score | type: Text]
+Downstream validation target. For each instance i, we denote the downstream validation value as r_i \in [0, 1] , instantiated in our experiments as the trajectory-level validation rate (soft).
+
+[p. 24 | section: D.1. Signal-Validation Alignment (SVA) score | type: Text]
+Definition. Given a verification signal s_i \in [0,1] and downstream validation r_i , we define the Signal-Validation Alignment (SVA) score as
+
+[p. 24 | section: D.1. Signal-Validation Alignment (SVA) score | type: Equation]
+SVA(s,r) = \frac{\sum_{i:s_i>0} s_i r_i}{\sum_{i:s_i>0} s_i + |\{i:s_i \le 0\}|}. (17)
+
+[p. 24 | section: D.1. Signal-Validation Alignment (SVA) score | type: Text]
+Unlike correlation, SVA evaluates whether high verification-signal values concentrate on instances with high downstream validation, and it additionally penalizes zero-signal cases through the term |\{i: s_i \leq 0\}| , capturing signal coverage (i.e., how often a signal collapses to zero or becomes uninformative). Higher SVA therefore indicates a verification signal that is both more indicative of downstream validation and more consistently defined across instances.
+
+[p. 24 | section: E.1. Finetuning Exploration | type: Text]
+We study finetuning on TOOL GENESIS as a simple and reproducible adaptation mechanism.
+
+[p. 24 | section: E.1. Finetuning Exploration | type: Text]
+Data construction. We construct an executable supervision signal by collecting successful tool-creation trajectories from a held-out pool of MCP servers. Concretely, we run our Code-Agent pipeline (generate-execute-repair) with DeepSeek-V3.2 as the backbone model and synthesize approximately 1,000 tool-creation trajectories. Each trajectory records the requirement, the generated MCP tool registry (schema), the materialized implementation artifact (server code), and optional execution/verification feedback produced during the loop (e.g., launch errors and unit-test summaries). We then apply strict filtering to retain only high-quality instances whose final artifacts are (i) MCP-compliant and parseable, (ii) executable under our sandbox, and (iii) verifiable by our automated checks (unit tests when available). We further remove trajectories
+
+[p. 25 | section: E.1. Finetuning Exploration | type: Text]
+that require external credentials or unstable external state, and drop samples with malformed registries, non-deterministic outcomes, or excessively long logs. After filtering, we retain 500 high-quality trajectories as our finetuning training set. Unless otherwise stated, training and evaluation are server-disjoint to avoid leakage.
+
+[p. 25 | section: E.1. Finetuning Exploration | type: Text]
+Functioning (supervision formatting). We convert each retained trajectory into instruction–response examples aligned with the TI+TM lifecycle. Specifically, we include: (i) Direct examples mapping a requirement to a single-pass output (schema plus implementation), and (ii) Repair examples unrolled from the generate–execute–repair loop, where the input additionally contains truncated executable feedback and the target is a corrected patch or revised implementation. Each repair iteration is treated as an independent example, enabling the model to learn bug localization and correction conditioned on execution signals.
+
+[p. 25 | section: E.1. Finetuning Exploration | type: Text]
+Finetuning configuration. We fine-tune Qwen3-8B on the curated finetuning set using teacher-forcing maximum likelihood. We train for 3 epochs and keep the rest of the evaluation pipeline unchanged (prompting, decoding, tool-call parsing, runtime sandbox, and verification), ensuring an apples-to-apples comparison. We use AdamW with cosine learning-rate scheduling and warmup, gradient clipping, and mixed-precision training. The learning rate is selected within 1e-5–5e-5 on a server-disjoint development split; in our runs, the best checkpoint typically uses a learning rate around 2e-5. Unless otherwise specified, we use a max sequence length of 4k–8k tokens with packing, and gradient accumulation to match the target effective batch size under fixed hardware constraints. We report the best checkpoint on the development split and evaluate on held-out test servers.
+
+[p. 25 | section: E.1. Finetuning Exploration | type: Text]
+Results. Finetuning on TOOL GENESIS leads to better performance. Table 6 shows that finetuning yields consistent gains across evaluation layers, demonstrating that TOOL GENESIS can serve not only as an evaluation benchmark but also as an effective training signal for tool creation. Under the Direct setting, finetuning improves one-shot schema generation quality and increases downstream task success, suggesting that finetuning internalizes MCP-compliant interface patterns and reduces schema-level failures in single-pass TI+TM. Under the Code-Agent setting, finetuning further strengthens closed-loop repair: the fine-tuned model more reliably fixes execution-triggered implementation bugs, increasing unit-test pass rates (UT) and improving task success (SR). Overall, finetuning primarily strengthens one-shot generation under Direct, while under Code-Agent it improves bug localization and correction, translating executable feedback into measurable downstream utility.

icml26/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/assets.json

@@ -0,0 +1,68 @@
+[
+  {
+    "filename": "_page_0_Figure_18.jpeg",
+    "path": "data/processed_papers/icml26_20260429_1952_duequeue/marker_raw/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/marker_markdown/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/_page_0_Figure_18.jpeg",
+    "bytes": 98301,
+    "width": 661,
+    "height": 609,
+    "aspect_ratio": 1.0853858784893267,
+    "keep": true,
+    "reject_reason": null,
+    "model_path": "assets/_page_0_Figure_18.jpeg"
+  },
+  {
+    "filename": "_page_13_Figure_1.jpeg",
+    "path": "data/processed_papers/icml26_20260429_1952_duequeue/marker_raw/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/marker_markdown/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/_page_13_Figure_1.jpeg",
+    "bytes": 46424,
+    "width": 1325,
+    "height": 345,
+    "aspect_ratio": 3.8405797101449277,
+    "keep": true,
+    "reject_reason": null,
+    "model_path": "assets/_page_13_Figure_1.jpeg"
+  },
+  {
+    "filename": "_page_2_Figure_1.jpeg",
+    "path": "data/processed_papers/icml26_20260429_1952_duequeue/marker_raw/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/marker_markdown/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/_page_2_Figure_1.jpeg",
+    "bytes": 156263,
+    "width": 1350,
+    "height": 596,
+    "aspect_ratio": 2.2651006711409396,
+    "keep": true,
+    "reject_reason": null,
+    "model_path": "assets/_page_2_Figure_1.jpeg"
+  },
+  {
+    "filename": "_page_3_Figure_8.jpeg",
+    "path": "data/processed_papers/icml26_20260429_1952_duequeue/marker_raw/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/marker_markdown/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/_page_3_Figure_8.jpeg",
+    "bytes": 24650,
+    "width": 659,
+    "height": 415,
+    "aspect_ratio": 1.5879518072289156,
+    "keep": true,
+    "reject_reason": null,
+    "model_path": "assets/_page_3_Figure_8.jpeg"
+  },
+  {
+    "filename": "_page_6_Figure_1.jpeg",
+    "path": "data/processed_papers/icml26_20260429_1952_duequeue/marker_raw/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/marker_markdown/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/_page_6_Figure_1.jpeg",
+    "bytes": 76545,
+    "width": 1279,
+    "height": 427,
+    "aspect_ratio": 2.9953161592505855,
+    "keep": true,
+    "reject_reason": null,
+    "model_path": "assets/_page_6_Figure_1.jpeg"
+  },
+  {
+    "filename": "_page_6_Figure_8.jpeg",
+    "path": "data/processed_papers/icml26_20260429_1952_duequeue/marker_raw/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/marker_markdown/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/_page_6_Figure_8.jpeg",
+    "bytes": 32416,
+    "width": 663,
+    "height": 361,
+    "aspect_ratio": 1.8365650969529086,
+    "keep": true,
+    "reject_reason": null,
+    "model_path": "assets/_page_6_Figure_8.jpeg"
+  }
+]

icml26/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/dataset_meta.json

@@ -0,0 +1,60 @@
+{
+  "paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0",
+  "pipeline": "Paper2Markdown-V3",
+  "ok": true,
+  "page_count": 25,
+  "chunk_count": 137,
+  "main_body_chunk_count": 62,
+  "appendix_chunk_count": 69,
+  "reference_chunk_count": 6,
+  "model_text_chars": 38054,
+  "raw_markdown_chars": 99874,
+  "sanitized_chars": 84120,
+  "page_provenance": {
+    "min_page": 1,
+    "max_page": 25,
+    "invalid_count": 0
+  },
+  "marker_block_type_counts": {
+    "Code": 15,
+    "Equation": 17,
+    "FigureGroup": 6,
+    "Footnote": 1,
+    "ListGroup": 7,
+    "PageFooter": 25,
+    "PageHeader": 26,
+    "SectionHeader": 47,
+    "Table": 3,
+    "TableGroup": 3,
+    "Text": 292
+  },
+  "asset_count_raw": 6,
+  "asset_count_model_kept": 6,
+  "asset_count_rejected": 0,
+  "asset_reject_reasons": {
+    "kept": 6
+  },
+  "artifact_leak_audit": {
+    "ok": true,
+    "hits": {
+      "Anonymous Authors": [],
+      "ACKNOWLEDGMENT": [],
+      "OpenReview": [],
+      "\"accept_label\"": [],
+      "\"decision\"": [],
+      "\"decision_tier\"": [],
+      "\"source_status\"": [],
+      "Meta-review": [],
+      "Official Review": [],
+      "official_reviews": [],
+      "meta_reviews": [],
+      "suggested_verdict_score": []
+    },
+    "artifact_count": 2
+  },
+  "default_model_input": "model_text_v3.txt",
+  "appendix_input": "appendix_text_v3.txt",
+  "reference_input": "reference_text_v3.txt",
+  "source": "koala_icml26_due_queue",
+  "run_name": "icml26_20260429_1952_duequeue"
+}

icml26/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/main_body_chunks.jsonl

@@ -0,0 +1,62 @@
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0000", "section": "Abstract", "page_start": 1, "page_end": 1, "type": "Text", "text": "Research on self-evolving language agents progresses, increasing attention has focused on their ability to create, adapt, and maintain tools from task requirements.However, existing benchmarks predominantly rely on pre-defined specifications, which limits scalability and hinders true autonomous evolution. While recent studies attempt to dynamically generate tools, they primarily focus on downstream performance, creating a \"black box\" evaluation that makes it difficult to accurately attribute the causes of failure.To address this, we propose Tool-Genesis, a diagnostic benchmark designed to quantify agent capabilities across multiple dimensions—from interface compliance and functional correctness to downstream utility. It evaluates the ability of agents to construct task-relevant tools solely from abstract requirements (without pre-set specifications) and solve realistic problems.Crucially, we find that even state-of-the-art models struggle to construct precise tool interfaces or executable logic in a one-shot setting. These minor initial flaws are amplified through the pipeline, leading to a precipitous drop in downstream metrics. We hope this benchmark will guide future research toward steering models to synthesize persistent, general-purpose tools capable of addressing broader real-world challenges.Project page:", "source": "marker_v2", "marker_block_id": "/page/0/Text/13"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0001", "section": "1. Introduction", "page_start": 1, "page_end": 1, "type": "Text", "text": "Prior work has established a \"reason–call–execute\" paradigm, typically assuming reliable tool interfaces and schemas, where tools are treated as callable functions with well-defined inputs/outputs and stable semantics.(e.g.,", "source": "marker_v2", "marker_block_id": "/page/0/Text/15"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0002", "section": "1. Introduction", "page_start": 1, "page_end": 1, "type": "FigureGroup", "text": "Figure 1. Comparison of tool creation paradigms: (a) Outcome-Driven: Ad-hoc solving with disposable scripts; (b) Code-Centric: Spec-based translation with limited safety; (c) Tool-Genesis(Ours): Inductive design for verified, reusable assets.", "source": "marker_v2", "marker_block_id": "/page/0/FigureGroup/619"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0003", "section": "1. Introduction", "page_start": 1, "page_end": 1, "type": "Text", "text": "(Karpas et al., 2022; Yao et al., 2023; Schick et al., 2023) ), with benchmarks further standardizing the evaluation (e.g., (Patil et al., 2023; Qin et al., 2023a; Li et al., 2023; Anony mous, 2023; Guo et al., 2024; Berkeley Function Call ing Leaderboard (BFCL) Team, 2024; Wang et al., 2024a; Huang et al., 2024; Zhang et al., 2025c; Shi et al., 2024; Wang et al., 2024b) ). In this paradigm, tool use is largely reduced to selecting an API, filling arguments, and executing calls under a fixed contract, while success is measured by answer correctness or call-level validity. In realistic deployments, however, this assumption often breaks due to missing specifications, evolving APIs, uncovered long-tail needs, or execution failures caused by bugs. Even small interface ambiguities (e.g., optional fields, implicit constraints, undocumented edge cases) can cascade into repeated execution errors and brittle agent behaviors, especially when the task requires multi-step composition across tools. As a result, agents must evolve from merely using tools to creating , adapting , and repairing tools from abstract requirements, and to distilling reusable pipelines into maintainable tool assets—a core mechanism of self-evolving language agents", "source": "marker_v2", "marker_block_id": "/page/0/Text/20"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0004", "section": "1. Introduction", "page_start": 2, "page_end": 2, "type": "TableGroup", "text": "Benchmark Scale (Reported) I. Artifacts Required II. Verification Signals Tool Sets Avg Tools # Domains No Doc Schema Gen Reuse Tool Toolset (≥ 2) Held-out UnitTests Neg Tests GT Tools CREATOR (Qian et al., 2023b) 2K 1 9 ✗ ✗ ✓ ✓ ✗ ✗ ✗ LATM (Cai et al., 2024) 6 1 6 ✓ ✗ ✗ ✗ ✗ ✗ ✗ CRAFT (Yuan et al., 2024) 150 3 3 ✗ ✗ ✓ ✓ ✗ ✗ ✗ TM-Bench (Wölflein et al., 2025) 15 1 4 ✓ ✗ ✓ ✗ ✓ ✗ ✗ SciEvo (Zhang et al., 2025a) 925 6 25 ✓ ✗ ✓ ✗ ✓ ✗ ✗ TOOL-GENESIS (Ours) 86 6 24 ✓ ✓ ✓ ✓ ✓ ✓ ✓ Table 1. Feature-wise comparison of representative tool-creation benchmarks under a strict binary rubric. Held-out UnitTests indicates tests/invocations are not available during tool creation and used strictly for evaluation (e.g., TM-Bench).", "source": "marker_v2", "marker_block_id": "/page/1/TableGroup/674"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0005", "section": "1. Introduction", "page_start": 2, "page_end": 2, "type": "Text", "text": "that improve over long-horizon task distributions (Wu et al., 2024; Tan et al., 2024) .", "source": "marker_v2", "marker_block_id": "/page/1/Text/4"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0006", "section": "1. Introduction", "page_start": 2, "page_end": 2, "type": "Text", "text": "Despite steady progress, when the goal is to evaluate this self-evolving capability along the tool dimension under deployment-like constraints, existing benchmarks exhibit three practical disconnects. First, most evaluations remain spec-first: they assume that interfaces or schemas are directly available, or implicitly rely on high-quality reference specifications. This emphasizes correctness under predefined contracts, while the end-to-end capability of inferring interface contracts from requirements and producing machine-checkable schemas is not systematically measured. Second, regarding tool organization, many settings primarily evaluate the scale or diversity of tool collections rather than the construction of a scenario-closed toolbox. They often overlook the agent's ability to distill capabilities into a cohesive, maintainable toolset that covers key sub-processes of a specific real-world scenario (e.g., Yuan et al., 2024; Wang et al., 2024c; Zhao et al., 2025; Huang et al., 2025; Qian et al., 2024) . Third, and most critically, evaluation signals are often outcome-centric, creating a \"black box\" dilemma. Benchmarks frequently rely on final answers or coarse call-level checks. Even when unit tests are used, their coverage and attribution granularity vary widely. This makes it difficult to disentangle whether a failure stems from defective tool construction (e.g., invalid schemas, logic bugs) or suboptimal tool utilization strategies, obscuring the specific stage where the error occurred (e.g., Zhang et al., 2025b; Wölflein et al., 2025; Guo et al., 2024; Anonymous, 2024; Lu et al., 2024) .", "source": "marker_v2", "marker_block_id": "/page/1/Text/5"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0007", "section": "1. Introduction", "page_start": 2, "page_end": 2, "type": "Text", "text": "To address these deployment-facing gaps, we introduce Tool-Genesis, a diagnostic benchmark designed to decouple tool generation from tool utilization. Unlike spec-first settings, Tool-Genesis evaluates agents under missing or underspecified interfaces, requiring them to infer contracts from abstract requirements, generate machine-checkable schemas, and produce executable implementations that satisfy criteria for reuse and maintenance. Crucially, our protocol serves as a diagnostic probe: it reveals that even state-ofthe-art models struggle to construct precise tool interfaces", "source": "marker_v2", "marker_block_id": "/page/1/Text/6"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0008", "section": "1. Introduction", "page_start": 2, "page_end": 2, "type": "Text", "text": "or logic in a one-shot setting. These minor initial flaws are amplified through the pipeline, leading to precipitous drops in downstream metrics. By shifting the target from one-off scripts to reusable tool assets, Tool-Genesis evaluates whether agents can continuously distill capabilities to cover a scenario's task distribution. Finally, we provide a unified, full-lifecycle evaluation protocol that jointly measures compliance, server executability, schema consistency, and functional validation (via explicit negative/boundary tests). We also introduce an oracle-normalized upper bound to quantify the utility gap between generated tool assets and reference tools.", "source": "marker_v2", "marker_block_id": "/page/1/Text/7"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0009", "section": "1. Introduction", "page_start": 2, "page_end": 2, "type": "ListGroup", "text": "Benchmark setting. We formalize a requirement-driven tool-creation setting that elevates toolsets as reusable assets. It evaluates creation under missing specifications, focusing on the agent's ability to infer schemas and implement executable logic from abstract requirements. Diagnostic evaluation protocol. We provide a fulllifecycle, execution-grounded protocol designed to disentangle failure causes. By incorporating multi-level signals—including compliance, schema fidelity, and explicit negative/boundary unit tests—we enable precise attribution of errors to either tool quality or usage strategy, addressing the \"black box\" issue. Oracle-normalized utility gap. We introduce an oraclenormalized upper-bound comparison to quantify the utility gap between generated tool assets and reference tools under the same task distribution, providing a clearer measure of practical self-evolution capability.", "source": "marker_v2", "marker_block_id": "/page/1/ListGroup/675"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0010", "section": "2.1. Task Definition", "page_start": 2, "page_end": 2, "type": "Text", "text": "We formalize TOOL GENESIS as a conditional generation problem over Model Context Protocol (MCP) interfaces. Let X denote the natural-language task description, S the space of valid MCP interface schemas, and E the space of", "source": "marker_v2", "marker_block_id": "/page/1/Text/13"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0011", "section": "2.1. Task Definition", "page_start": 3, "page_end": 3, "type": "FigureGroup", "text": "Figure 2. Dataset construction pipeline of TOOL GENESIS.", "source": "marker_v2", "marker_block_id": "/page/2/FigureGroup/759"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0012", "section": "2.1. Task Definition", "page_start": 3, "page_end": 3, "type": "Text", "text": "executable server implementations. An MCP schema s ∈ S is represented as an ordered list of atomic tool definitions, s = [t1, . . . , tK], where each tool t k = ⟨ηk, ϕk, δk⟩ consists of a unique invocation identifier ηk, a parameter interface ϕ k specified by a JSON-schema-like typed signature with constraints, and a natural-language description δ k grounding its intended semantics and usage.", "source": "marker_v2", "marker_block_id": "/page/2/Text/3"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0013", "section": "2.1. Task Definition", "page_start": 3, "page_end": 3, "type": "Text", "text": "We decompose the tool creation process into two coupled prediction phases: Tool Interface Prediction and Tool Materialization. Formally, the joint probability of producing a schema s and an implementation e given requirement x is factorized as:", "source": "marker_v2", "marker_block_id": "/page/2/Text/4"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0014", "section": "2.1. Task Definition", "page_start": 3, "page_end": 3, "type": "Equation", "text": "P_{\\theta}(s, e \\mid x) = \\underbrace{P_{\\theta}(s \\mid x)}_{\\text{Interface Prediction}} \\cdot \\underbrace{P_{\\theta}(e \\mid s)}_{\\text{Materialization}}. \\tag{1}", "source": "marker_v2", "marker_block_id": "/page/2/Equation/5"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0015", "section": "2.1. Task Definition", "page_start": 3, "page_end": 3, "type": "Text", "text": "In the first phase, the model predicts an interface schema sˆ = arg maxs∈S Pθ(s | x), specifying the structured tool signatures. In the second phase, conditioned on a schema scond, the model materializes an executable server implementation via eˆ = arg maxe∈E Pθ(e | scond). We evaluate this materialization under two settings: Oracle Materializa tion , where scond = s ∗ (ground truth) to isolate engineering capability, and Cascaded Materialization , where scond = ˆs (predicted schema) to assess end-to-end performance.", "source": "marker_v2", "marker_block_id": "/page/2/Text/6"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0016", "section": "2.2. Metrics", "page_start": 3, "page_end": 3, "type": "Text", "text": "We evaluate tool creation with a four-level metric suite (Appendix A) : (i) Level 1 (Surface Compliance) reports Compliance Rate and Server Execution Rate. Compliance Rate measures whether list_tools returns a parseable, MCPcompliant registry, while Server Execution Rate measures whether the server launches and remains responsive under fixed timeouts. (ii) Level 2 (Semantic Interface Fidelity)", "source": "marker_v2", "marker_block_id": "/page/2/Text/8"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0017", "section": "2.2. Metrics", "page_start": 3, "page_end": 3, "type": "Text", "text": "reports Schema-F1, quantifying schema-level fidelity by aligning predicted and reference tools via bipartite matching and computing an F1 score over tool interfaces. (iii) Level 3 (Functional Correctness) reports UTsoft and UThard, which measure the fraction of tools passing predefined Unit Tests under relaxed and strict (boundary/negative) criteria, respectively. (iv) Level 4 (Downstream Task Utility) assesses the end-to-end practical efficacy by employing a fixed proxy agent (qwen3-14b-instruct) to solve benchmark tasks equipped with the generated tools. To rigorously isolate tool quality from solver capability, we conduct a parallel control experiment using ground-truth reference tools, with all final outcomes evaluated by an LLM-as-a-Judge. This comparative setup allows us to report an Oracle-Normalized Success Rate (SR), which quantifies the utility of the synthesized tools relative to the upper-bound performance achieved by the optimal reference implementation under the same experimental conditions.", "source": "marker_v2", "marker_block_id": "/page/2/Text/9"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0018", "section": "3. Dataset Construction", "page_start": 3, "page_end": 3, "type": "Text", "text": "This section describes the dataset construction pipeline of TOOL GENESIS. It covers Compliant MCP-server Data Collection ( §3.1) , High-Quality Task & Trajectory Genera tion ( §3.2) , Comprehensive Unit Test Generation ( §3.3) , and Manual Quality Inspection ( §3.4) . The overall procedure is illustrated in Figure 2. Detailed prompts, rubrics, thresholds, and implementation specifics are provided in Appendix B.", "source": "marker_v2", "marker_block_id": "/page/2/Text/11"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0019", "section": "3.1. Compliant MCP-server Data Collection", "page_start": 3, "page_end": 3, "type": "Text", "text": "MCP Crawling: We collect MCP servers from web sources: (i) MCP aggregators (GLMA, Smithery), (ii) GitHub search and curated lists, and (iii) HuggingFace (e.g., Toucan) in", "source": "marker_v2", "marker_block_id": "/page/2/Text/13"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0020", "section": "3.1. Compliant MCP-server Data Collection", "page_start": 4, "page_end": 4, "type": "Text", "text": "Aug–Sep 2025. We keep source links and server metadata (server_name, description), without mirroring repositories. We obtain tool registries by launching servers and calling list_tools, falling back to static registries/specifications when needed. Schemas are normalized using server_name and tool_name as server/tool IDs.", "source": "marker_v2", "marker_block_id": "/page/3/Text/1"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0021", "section": "3.1. Compliant MCP-server Data Collection", "page_start": 4, "page_end": 4, "type": "Text", "text": "MCP-server Filtering. We apply a four-stage filtering pipeline to construct a high-quality MCP-server dataset. (i) Structure Validation enforces that each server exposes a parseable tool registry with well-formed tool names, descriptions, and input schemas. (ii) Executable Validation removes servers that cannot be reliably launched or invoked in a sandboxed environment. (iii) Deduplication & Clustering reduces redundancy by grouping servers with similar schema-level interfaces and retaining a single representative per group. (iv) LLM Semantic Validation filters servers that require external credentials or exhibit high sandbox requirements, ensuring safe and self-contained execution. The remaining servers form the MCP-server Dataset Dsrv (86 servers).", "source": "marker_v2", "marker_block_id": "/page/3/Text/2"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0022", "section": "3.2. High-Quality Task & Trajectory Generation", "page_start": 4, "page_end": 4, "type": "Text", "text": "Task generation and filtering. We follow a Toucan-style LLM-driven pipeline (Xu et al., 2025) to synthesize tasks. For each server, an LLM is prompted with tool schemas (and docs, if any) to generate tasks, expanded along breadth (distinct scenarios and tool subsets) and depth (multi-step tasks with more tool calls).To ensure high data diversity, we further employ a rejection sampling strategy that penalizes redundant tool combinations, forcing the LLM to explore edge cases and rare parameter configurations. An LLM-as-judge scores candidates on a fixed 1–5 Likert rubric (quality, realism, verifiability, stability) and assesses solv ability ; we retain only tasks with all dimensions > 3 and solvable=true.", "source": "marker_v2", "marker_block_id": "/page/3/Text/4"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0023", "section": "3.2. High-Quality Task & Trajectory Generation", "page_start": 4, "page_end": 4, "type": "Text", "text": "Trajectory generation and filtering. For each retained task, we generate execution trajectories by running an agent in a sandbox(to support servers requiring network access).This sandbox execution ensures that each trajectory is grounded in real-time tool feedback, allowing us to filter out \"hallucinated\" successful executions that do not reflect actual API behaviors. We apply lightweight rule-based checks (parseable calls, valid responses) and employ LLM-as-ajudge to verify consistency and completion and penalize redundancy; we retain trajectories with completion and conciseness > 3 and complete=true, with solvability and completion judged by the LLM.", "source": "marker_v2", "marker_block_id": "/page/3/Text/5"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0024", "section": "3.3. Comprehensive Unit Test Generation", "page_start": 4, "page_end": 4, "type": "Text", "text": "Unit test generation. We extract unit tests from Dtraj by converting replayable tool-call steps (executable in the sandbox) into a unified format (tool_name, inputs, expected", "source": "marker_v2", "marker_block_id": "/page/3/Text/7"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0025", "section": "3.3. Comprehensive Unit Test Generation", "page_start": 4, "page_end": 4, "type": "FigureGroup", "text": "Figure 3. Comparison of benchmarks in terms of task reasoning depth and tool compositionality.", "source": "marker_v2", "marker_block_id": "/page/3/FigureGroup/592"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0026", "section": "3.3. Comprehensive Unit Test Generation", "page_start": 4, "page_end": 4, "type": "Text", "text": "outputs), retaining up to 100 tests per server for coverage. When extraction provides insufficient coverage for a tool, we synthesize additional tests with an LLM conditioned on the tool schema, targeting diverse valid calls.", "source": "marker_v2", "marker_block_id": "/page/3/Text/10"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0027", "section": "3.3. Comprehensive Unit Test Generation", "page_start": 4, "page_end": 4, "type": "Text", "text": "Unit test filtering. We apply two post-filters for quality and deduplication. (i) Parameter-based filtering removes tests with invalid inputs, type errors, or disallowed dependencies. (ii) We cluster tests per tool to merge near-duplicates and keep representatives, embedding normalized (input, output) pairs and merging those with cosine similarity ≥ 0.9.", "source": "marker_v2", "marker_block_id": "/page/3/Text/11"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0028", "section": "3.4. Manual Quality Inspection", "page_start": 4, "page_end": 4, "type": "Text", "text": "Manual Annotation: (i) MCP-server Data Consistency Check—verify schema/version consistency, stable unique IDs, split integrity, and formatting rules; (ii) Task Tool Functionality Match—confirm that referenced tools exist in the registry, required arguments are schema-compatible, and the task intent aligns with documented tool functionality; (iii) Trajectory Validity Check—ensure trajectories satisfy task constraints with coherent ordering, contain no malformed tool calls, and have no forbidden dependencies; (iv) Unit Test Coverage Check—check that tests cover diverse tools and parameter regimes, meet per-server coverage targets, and avoid redundancy.", "source": "marker_v2", "marker_block_id": "/page/3/Text/13"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0029", "section": "3.4. Manual Quality Inspection", "page_start": 4, "page_end": 4, "type": "Text", "text": "Manual Review. All instances are manually re-checked by graduate-level reviewers (3 annotators over two weeks) in multiple passes. Reviewers conduct both instance-level inspection (task statement, referenced tools, trajectories, and unit tests) and cross-file consistency checks (registry ↔ task ↔ trajectory ↔ tests), correcting minor issues when possible and removing samples that violate any requirement. In particular, they (a) verify that each task is solvable using only the declared toolset and does not rely on hidden assumptions; (b) validate that every tool call conforms to the declared schema (argument names/types, required fields, and return usage); (c) check that trajectories are coherent and free of malformed calls, missing steps, or forbidden ex-", "source": "marker_v2", "marker_block_id": "/page/3/Text/14"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0030", "section": "3.4. Manual Quality Inspection", "page_start": 5, "page_end": 5, "type": "Table", "text": "Foundation & Core Tech Data Intelligence & Automation Productivity & Workflow Creative & Digital Life Services & Emerging Fields General & Others Operating System Core software platform AI/ML Tools Intelligent algorithms Daily Productivity Task management Content Creation Media generation Financial Services Banking & finance Web Search & Research Information retrieval Memory Management System resource optimization Data Analysis Insights from data Time & Calendar Scheduling & planning Social Media Networking platforms Health & Fitness Wellness tracking Education Learning resources Database Operations Data storage & management Browser Automation Web task scripting Communication Tools Messaging & collaboration Gaming Interactive entertainment Travel & Maps Navigation & trips Weather Forecast services Security & Authentication Protection & identity Development Tools Software building File Management Organization & storage API Integration Connecting services Crypto & Blockchain Decentralized finance Others Miscellaneous categories", "source": "marker_v2", "marker_block_id": "/page/4/Table/2"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0031", "section": "3.4. Manual Quality Inspection", "page_start": 5, "page_end": 5, "type": "TableGroup", "text": "Statistic Number MCP-servers 86 Total Tools 508 Domain classes 24 Label classes 18 Unit test 9441 Total tasks 2150 Average task length 53 Average step length 6 Average tool-using length 3 Figure 4. Overview statistics of TOOL GENESIS. Left: functional domain coverage of MCP servers across 24 domain classes. Right: dataset scale and task/trajectory structure statistics.", "source": "marker_v2", "marker_block_id": "/page/4/TableGroup/756"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0032", "section": "3.4. Manual Quality Inspection", "page_start": 5, "page_end": 5, "type": "Text", "text": "ternal dependencies; and (d) inspect unit tests to ensure they include both positive and negative/boundary cases, span representative parameter regimes, and do not leak answers or duplicate existing tests. We retain an instance only when at least two annotators independently agree on accept/reject, and the inter-annotator agreement on accept/reject decisions reaches a Cohen's κ of 0.85 (Landis & Koch, 1977) . Finally, after edits and removals, we perform a final end-to-end recheck on the finalized dataset to ensure each retained instance meets all constraints and yields a coherent tool-use process.", "source": "marker_v2", "marker_block_id": "/page/4/Text/5"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0033", "section": "4. Data Analysis", "page_start": 5, "page_end": 5, "type": "Text", "text": "Overall scale. Figure 4 summarizes the scale of TOOL GEN-ESIS. After filtering and manual inspection, the dataset contains 86 executable MCP servers with 508 tools, spanning 24 domain classes. We collect 2,150 tasks and 9,441 unit tests, covering 18 task label classes. These statistics provide a concise overview of the benchmark size across servers, tools, tasks, and tests.", "source": "marker_v2", "marker_block_id": "/page/4/Text/7"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0034", "section": "4. Data Analysis", "page_start": 5, "page_end": 5, "type": "Text", "text": "Domain coverage. The retained MCP servers span a diverse set of functional domains. The 24 domain classes are grouped into six high-level categories, covering foundational system tools, data intelligence and automation, productivity and workflow utilities, creative and digital-life applications, service-oriented domains (e.g., finance, health, travel), and general-purpose tools. The distribution includes both commonly used domains and a long tail of more specialized categories.", "source": "marker_v2", "marker_block_id": "/page/4/Text/8"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0035", "section": "4. Data Analysis", "page_start": 5, "page_end": 5, "type": "Text", "text": "Execution structure. We further examine the execution structure of task trajectories. Tasks have an average length of 53 tokens, while trajectories involve 6 execution steps on average and invoke 3 distinct tools per task. This indicates that many instances require sequential tool invocation rather than single-step execution. As shown in Figure 3, the", "source": "marker_v2", "marker_block_id": "/page/4/Text/9"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0036", "section": "4. Data Analysis", "page_start": 5, "page_end": 5, "type": "Text", "text": "dataset covers task structures ranging from simple singletool interactions to multi-step, multi-tool compositions.", "source": "marker_v2", "marker_block_id": "/page/4/Text/10"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0037", "section": "5.1. Experimental Setup", "page_start": 5, "page_end": 5, "type": "Text", "text": "Models. We evaluate a broad suite of frontier and opensource LLMs, covering closed-source families—OpenAI GPT models (gpt-4o, gpt-4.1-mini, gpt-4.1, gpt-5.1; (Ope nAI, 2025) ), Anthropic Claude (claude-sonnet-4; (An thropic, 2025) ), and Google Gemini (gemini-3-flash; (Google DeepMind, 2025) )—as well as open-source families including Qwen3 (4B/8B/14B/30B-A3B/32B/235B-A22B; (Yang et al., 2025) ), DeepSeek (deepseek-v3.2; (DeepSeek-AI et al., 2024) ), and MoonshotAI Kimi (Kimi-K2(-Instruct); (Kimi Team, 2025) ).", "source": "marker_v2", "marker_block_id": "/page/4/Text/13"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0038", "section": "5.1. Experimental Setup", "page_start": 5, "page_end": 5, "type": "Text", "text": "Inference Strategy. On top of this model suite, we run a unified evaluation harness with two inference strategies: (i) Direct, which performs single-pass generation of TI and TM outputs; and (ii) Code-Agent, which wraps the same LLM in a ReAct-style agent loop (Yao et al., 2023) . Specifically, Code-Agent follows a \"think → act (tool) → observe\" procedure for up to 10 steps, and can invoke sandboxed execution tools to run and validate generated artifacts.", "source": "marker_v2", "marker_block_id": "/page/4/Text/14"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0039", "section": "5.1. Experimental Setup", "page_start": 5, "page_end": 5, "type": "Text", "text": "Implementation Details. All models are queried through their standard chat APIs using a shared prompt template and fixed decoding settings (max tokens = 40,960, temperature = 0, top_p = 1). For Code-Agent, sandboxed execution is performed under fixed resource limits and timeouts to support automated artifact validation and downstream task execution.", "source": "marker_v2", "marker_block_id": "/page/4/Text/15"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0040", "section": "5.2. Experimental Results", "page_start": 5, "page_end": 5, "type": "Text", "text": "Several conclusions can be drawn from TableTable 2: (i) Closed-loop repair yields consistent multi-layer gains", "source": "marker_v2", "marker_block_id": "/page/4/Text/17"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0041", "section": "5.2. Experimental Results", "page_start": 6, "page_end": 6, "type": "TableGroup", "text": "Model Family Version L1 L2 L3 L4 Compliance ↑ Exec.↑ Schema-F1↑ UTsoft ↑ UThard ↑ SR↑ Direct gpt-4o 0.779 0.209 0.175 0.089 0.049 0.153 gpt-4.1-mini 0.686 0.318 0.293 0.127 0.088 0.199 OpenAI (OpenAI, 2025) gpt-4.1 0.860 0.738 0.675 0.261 0.129 0.330 gpt-5.1 0.826 0.759 0.688 0.281 0.161 0.372 Anthropic (Anthropic, 2025) claude-haiku-3.5 0.744 0.012 0.012 0.007 0.000 0.012 Google (Google DeepMind, 2025) gemini-3-flash-preview 0.872 0.140 0.116 0.084 0.037 0.103 235b-a22b-instruct-2507 0.884 0.333 0.320 0.143 0.108 0.287 32b 0.791 0.282 0.258 0.176 0.078 0.178 30b-a3b-instruct-2507 0.884 0.256 0.250 0.093 0.025 0.218 Qwen3 (Yang et al., 2025) 14b 0.791 0.186 0.175 0.154 0.075 0.128 8b 0.686 0.012 0.011 0.001 0.001 0.012 4b 0.651 0.000 0.000 0.000 0.000 0.000 DeepSeek (DeepSeek-AI et al., 2024) deepseek-v3.2 0.826 0.400 0.365 0.195 0.129 0.224 MoonshotAI (Kimi Team, 2025) Kimi-K2-Instruct 0.860 0.372 0.342 0.144 0.087 0.215 Code-Agent gpt-4o 0.802 0.531 0.456 0.237 0.117 0.226 gpt-4.1-mini 0.651 0.906 0.640 0.278 0.144 0.344 OpenAI (OpenAI, 2025) gpt-4.1 0.884 0.756 0.691 0.288 0.145 0.433 gpt-5.1 0.895 0.941 0.867 0.421 0.246 0.604 Anthropic (Anthropic, 2025) claude-haiku-3.5 0.733 0.964 0.821 0.342 0.180 0.472 Google (Google DeepMind, 2025) gemini-3-flash-preview 0.849 0.977 0.912 0.448 0.255 0.581 Qwen3 (Yang et al., 2025) 235b-a22b-instruct-2507 0.686 0.971 0.722 0.363 0.212 0.472 32b 0.860 0.892 0.801 0.317 0.179 0.495 30b-a3b-instruct-2507 0.744 0.913 0.694 0.336 0.187 0.410 14b 0.686 0.807 0.707 0.316 0.178 0.453 8b 0.767 0.694 0.646 0.243 0.121 0.332 4b 0.651 0.326 0.285 0.127 0.058 0.181 DeepSeek (DeepSeek-AI et al., 2024) deepseek-v3.2 0.872 0.744 0.702 0.330 0.195 0.449 MoonshotAI (Kimi Team, 2025) Kimi-K2 0.872 0.976 0.898 0.389 0.235 0.585 Table 2. Main results under two evaluation paradigms (Direct and Code-Agent) updated with the latest metrics. Metrics follow our four-level evaluation: L1 surface compliance (Compliance, Server Execution), L2 semantic interface fidelity (Schema-F1), L3 functional correctness via unit tests (UTsoft, UThard), and L4 downstream task utility (Task Success Rate, SR).", "source": "marker_v2", "marker_block_id": "/page/5/TableGroup/558"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0042", "section": "5.2. Experimental Results", "page_start": 6, "page_end": 6, "type": "Text", "text": "and can produce step-changes in end-to-end utility. Across most model families, Code-Agent improves functional correctness and task success beyond surface executability and schema fidelity. For Gemini-3-Flash, EXEC. increases from 0.140 to 0.977, Schema-F1 from 0.116 to 0.912, and UThard from 0.129 to 0.726, resulting in a large SRsoft jump (0.103 → 0.581). A similar effect is observed for Qwen3-235B (SRsoft: 0.193 → 0.622), indicating that execution feedback is effectively translated into verifiable correctness and downstream utility.(ii) High compliance and plausible schemas are necessary but insufficient, revealing a utility-conversion bottleneck. Strong upstream signals (L1/L2) do not guarantee downstream success (L4). Under Direct , Qwen3-32B achieves high EXEC. (0.938) and Schema-F1 (0.880), yet SRsoft remains 0.535. Conversely, when schema fidelity degrades (e.g., gpt-4.1 under Direct ), downstream utility collapses accordingly. These gaps sug-", "source": "marker_v2", "marker_block_id": "/page/5/Text/4"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0043", "section": "5.2. Experimental Results", "page_start": 6, "page_end": 6, "type": "Text", "text": "gest that failures increasingly arise from implementation robustness, boundary handling, and state discipline that are only exposed through execution.(iii) Repair benefits are scale-dependent and can reorder models within a family. Under Code-Agent , larger models achieve higher downstream utility (e.g., Qwen3 SRsoft: 0.336 for 4B vs. 0.622 for 235B). Notably, model rankings can flip across strategies: Qwen3-32B outperforms 235B under Direct , while 235B overtakes under Code-Agent . This indicates that closed-loop tool creation relies on an additional capability—the ability to exploit execution feedback for targeted repair—that is not captured by single-pass generation alone.", "source": "marker_v2", "marker_block_id": "/page/5/Text/5"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0044", "section": "6. Analysis", "page_start": 6, "page_end": 6, "type": "Text", "text": "Beyond aggregate success rates, we analyze tool creation along three axes that align with our lifecycle evaluation.", "source": "marker_v2", "marker_block_id": "/page/5/Text/7"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0045", "section": "6. Analysis", "page_start": 7, "page_end": 7, "type": "FigureGroup", "text": "Figure 5. Direct prompting vs. code-agent repair on Qwen3 scales: (a) Signal–Validation Alignment (SVA) of Schema-F1 and UT (soft/hard); (b) stage-wise cumulative pass-through across verification stages (Start, L1–L4) for selected scales, with solid/dashed lines denoting the two paradigms.", "source": "marker_v2", "marker_block_id": "/page/6/FigureGroup/406"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0046", "section": "6. Analysis", "page_start": 7, "page_end": 7, "type": "Text", "text": "(i) We measure whether intermediate verification signals are predictive of downstream trajectory validation, and how closed-loop repair changes this predictiveness across model scales (Sec. 6.1). (ii) We localize where failures concentrate along the verification cascade by reporting stage-wise cumulative pass-through from Start to L1–L4, contrasting Direct prompting with Code-Agent repair and identifying the dominant attrition stages (Sec. 6.2). (iii) We move from inference-time interventions to capability internalization via finetuning, and examine how training reshapes one-shot synthesis under Direct and patch effectiveness under Code-Agent (Sec. 6.3).", "source": "marker_v2", "marker_block_id": "/page/6/Text/3"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0047", "section": "6.1. Signal-validation alignment under closed-loop", "page_start": 7, "page_end": 7, "type": "Text", "text": "Figure 5(a) quantifies how indicative verification signals are of downstream trajectory validation via a Signal–Validation Alignment (SVA) score (App. D.1). Under direct prompting, SVA remains low across scales: even at Qwen3-235B, Schema SVA is 0.19 and UT<sub>hard</sub> is 0.14, while Qwen3-8B collapses toward zero (Schema \\approx 0.01 , UT<sub>hard</sub> \\approx 0.00 ). Without execution feedback, interface- and verification-level metrics are weak proxies for downstream utility; with closed-loop repair, signal–validation alignment strengthens substantially. At Qwen3-235B, SVA reaches 0.58, and the improvement is stage-wise with a threshold around 8B \\rightarrow 14B: Schema increases from 0.32 to 0.51, and UT<sub>hard</sub> from 0.26 to 0.48.", "source": "marker_v2", "marker_block_id": "/page/6/Text/5"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0048", "section": "6.2. Pass-through along the verification cascade", "page_start": 7, "page_end": 7, "type": "Text", "text": "Figure 5(b) reports the cumulative pass-through (in %) across Start and L1–L4. Under direct prompting, Qwen3-8B drops to 1.11% at L1 and \\approx 0.12\\% by L2–L4; for Qwen3-14B/32B/235B, pass-through is 17.52/24.84/31.60% at L1 and 3.99/5.44/9.47% at L4. Closed-loop repair lifts early-stage pass-through (L1: 65.34%, 84.06%, 83.02%, 91.36% for 8B/14B/32B/235B) and improves late-stage retention", "source": "marker_v2", "marker_block_id": "/page/6/Text/7"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0049", "section": "6.2. Pass-through along the verification cascade", "page_start": 7, "page_end": 7, "type": "FigureGroup", "text": "Figure 6. Base vs. fine-tuned performance under Direct and Code-Agent evaluation, summarized across our four-layer metric suite (L1–L4).", "source": "marker_v2", "marker_block_id": "/page/6/FigureGroup/407"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0050", "section": "6.2. Pass-through along the verification cascade", "page_start": 7, "page_end": 7, "type": "Text", "text": "(L4: 8.85%, 7.97%, 15.69%, 30.01%), vs. 0.12%, 3.99%, 5.44%, and 9.47% under direct prompting. Once early stages are stabilized, the dominant attrition concentrates at L3/L4, and scaling mainly improves late-stage retention (e.g., L4: 7.97\\% \\rightarrow 15.69\\% \\rightarrow 30.01\\% from 14B to 32B to 235B under code-agent). Overall, repair primarily reduces early structural failures, leaving deeper validation as the bottleneck.", "source": "marker_v2", "marker_block_id": "/page/6/Text/10"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0051", "section": "6.3. Finetuning exploration: internalizing capability", "page_start": 7, "page_end": 7, "type": "Text", "text": "Prompting and inference-time repair can improve tool creation by injecting demonstrations or execution feedback, but they do not necessarily strengthen the model's intrinsic ability to synthesize reusable tool assets. We therefore finetune models on TOOL GENESIS and evaluate whether training improves both intermediate verification and downstream task success. We defer training configurations and implementation details to Appendix E.", "source": "marker_v2", "marker_block_id": "/page/6/Text/12"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0052", "section": "6.3. Finetuning exploration: internalizing capability", "page_start": 7, "page_end": 7, "type": "Text", "text": "Finetuning on TOOL GENESIS yields consistent gains across all evaluation layers (Table 6), indicating that TOOL GEN-ESIS provides not only a diagnostic benchmark but also an effective training signal for requirement-driven tool cre-", "source": "marker_v2", "marker_block_id": "/page/6/Text/13"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0053", "section": "6.3. Finetuning exploration: internalizing capability", "page_start": 8, "page_end": 8, "type": "Text", "text": "ation. On Qwen3-8B, under the Direct setting, finetuning improves one-shot generation at the interface and schema level: Compliance increases from 0.686 to 0.826 (+0.140), while Exec. rises from 0.012 to 0.047 (+0.035) and Schema-F1 from 0.011 to 0.046 (+0.035). These early-stage gains translate into measurable (though still small) functional validation improvements, with UTsoft increasing from 0.001 to 0.017 (+0.016) and UThard from 0.001 to 0.007 (+0.006), and downstream success SR improving from 0.012 to 0.026 (+0.014). Notably, because the Direct baseline is near-zero on executability and testing, absolute gains are more informative than relative ratios in this regime.", "source": "marker_v2", "marker_block_id": "/page/7/Text/1"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0054", "section": "6.3. Finetuning exploration: internalizing capability", "page_start": 8, "page_end": 8, "type": "Text", "text": "Under the Code-Agent setting, finetuning strengthens closed-loop repair and improves how execution feedback is converted into downstream utility. For Qwen3-8B, Compliance increases from 0.718 to 0.906 (+0.188), Exec. from 0.694 to 0.777 (+0.083), and Schema-F1 from 0.653 to 0.736 (+0.083). Improvements also propagate to functional validation, with UTsoft increasing from 0.307 to 0.377 (+0.070) and UThard from 0.456 to 0.533 (+0.077), yielding a higher SR from 0.336 to 0.399 (+0.063). Compared to Direct, gains under Code-Agent are less concentrated at the earliest gates and more evenly reflected in UT and SR, consistent with the interpretation that finetuning improves bug localization and patch quality under a fixed repair budget.", "source": "marker_v2", "marker_block_id": "/page/7/Text/2"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0055", "section": "6.3. Finetuning exploration: internalizing capability", "page_start": 8, "page_end": 8, "type": "Text", "text": "Overall, finetuning complements inference-time repair: it improves one-shot interface/schema synthesis under Direct, and under Code-Agent it increases the effectiveness of execution-triggered debugging, thereby raising the rate at which intermediate verification improvements translate into downstream task success.", "source": "marker_v2", "marker_block_id": "/page/7/Text/3"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0056", "section": "7. Related Work", "page_start": 8, "page_end": 8, "type": "Text", "text": "Tool-augmented LLMs are commonly evaluated by whether an agent can correctly invoke external tools and APIs to accomplish tasks (Karpas et al., 2022; Yao et al., 2023; Schick et al., 2023; Patil et al., 2023; Li et al., 2023; Qin et al., 2023a; b; Guo et al., 2024; Berkeley Function Call ing Leaderboard (BFCL) Team, 2024; Wang et al., 2024a; Huang et al., 2024; Anonymous, 2025; Zhang et al., 2025c; Shen et al., 2024; Liu et al., 2024; Wang et al., 2024f; Liu et al., 2023b; Zhang et al., 2024; Wang et al., 2024e) . Within this broader line, early tool-creation benchmarks and systems largely treat creation as a task-scoped deliverable and score it with downstream success as a black-box signal (Cai et al., 2023; Qian et al., 2023a; Wölflein et al., 2025) ; while task-relevant, such outcome-only evaluation is diagnostically weak because failures conflate requirement misunderstanding, interface/spec errors, implementation bugs, and unsafe or incorrect usage policies. To reduce hallucinated specifications and better reflect real constraints, later", "source": "marker_v2", "marker_block_id": "/page/7/Text/5"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0057", "section": "7. Related Work", "page_start": 8, "page_end": 8, "type": "Text", "text": "work increasingly grounds creation in external references (API docs/specs/repos/knowledge bases) and adds contractfaithfulness signals (e.g., schema/parameter consistency) as intermediate checks, often still reported alongside end-task outcomes (Liu et al., 2025; Zhao et al., 2025; Qian et al., 2024; Wang et al., 2024d) . As evaluation moves closer to \"real execution,\" a complementary trend adopts executable and test-driven verification to obtain reproducible correctness signals and clearer attribution (Zhang et al., 2025b; Wölflein et al., 2025; Jimenez et al., 2023; Chen et al., 2021; Austin et al., 2021; Hendrycks et al., 2021; Liu et al., 2023a; Zhuo et al., 2024) ; here, a stable execution environment and robust negative/boundary testing become essential to avoid flaky outcomes, prevent accidental overfitting to shallow success cases, and enable regression checking under tool evolution. More recently, tool creation is increasingly framed as building reusable toolsets/toolboxes that support retrieval, composition, maintenance, and updates across a task distribution—often serving knowledge access rather than a single one-off objective (Yuan et al., 2024; Wang et al., 2024c; Zhao et al., 2025; Huang et al., 2025; Qian et al., 2024) . Despite these advances, existing benchmarks remain fragmented: some emphasize task outcomes, others emphasize interface faithfulness or passing tests, and toolsetlevel reuse/maintenance is rarely evaluated together with executable correctness (including invalid/boundary cases) and downstream utility in a unified, reproducible protocol; in particular, oracle-normalized comparisons that quantify the utility gap between generated tools and ground-truth tools are still under-explored, motivating our benchmark and evaluation design.", "source": "marker_v2", "marker_block_id": "/page/7/Text/6"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0058", "section": "8. Conclusion", "page_start": 8, "page_end": 8, "type": "Text", "text": "We present Tool-Genesis, a diagnostic benchmark for evaluating tool creation as a first-class capability of self-evolving language agents. Tool-Genesis departs from spec-first settings by requiring agents to infer tool contracts from abstract requirements, generate machine-checkable schemas, and implement executable logic that can be reused as a scenarioclosed toolset. To avoid outcome-only \"black box\" evaluation, we introduce a full-lifecycle protocol that jointly measures interface compliance, executability, schema fidelity, and functional correctness with explicit negative/boundary unit tests, and we further report an oracle-normalized upper bound to quantify the utility gap between generated and reference tools under the same task distribution.Our empirical findings highlight a key bottleneck: even strong models often fail to produce precise interfaces or correct implementations in a one-shot setting, and these small early-stage defects are amplified through the downstream pipeline. We hope Tool-Genesis will help the community move beyond ad-hoc, disposable tool use toward persistent and maintain able tool assets, and enable more targeted progress on tool", "source": "marker_v2", "marker_block_id": "/page/7/Text/8"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0059", "section": "8. Conclusion", "page_start": 9, "page_end": 9, "type": "Text", "text": "induction, repair, and verification in realistic deployments.", "source": "marker_v2", "marker_block_id": "/page/8/Text/1"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0060", "section": "Impact Statement", "page_start": 9, "page_end": 9, "type": "Text", "text": "\"This paper presents work whose goal is to advance the field of Machine Learning. There are many potential societal consequences of our work, none which we feel must be specifically highlighted here.\"", "source": "marker_v2", "marker_block_id": "/page/8/Text/4"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0061", "section": "Impact Statement", "page_start": 9, "page_end": 9, "type": "Text", "text": "The above statement can be used verbatim in such cases, but we encourage authors to think about whether there is content which does warrant further discussion, as this statement will be apparent if the paper is later flagged for ethics review.", "source": "marker_v2", "marker_block_id": "/page/8/Text/5"}

icml26/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/marker_meta.json

@@ -0,0 +1,2258 @@
+{
+  "table_of_contents": [
+    {
+      "title": "004\n005\n006\n007",
+      "heading_level": null,
+      "page_id": 0,
+      "polygon": [
+        [
+          25.552000045776367,
+          108.66796875
+        ],
+        [
+          40.49589920043945,
+          108.66796875
+        ],
+        [
+          40.49589920043945,
+          175.95703125
+        ],
+        [
+          25.552000045776367,
+          175.95703125
+        ]
+      ]
+    },
+    {
+      "title": "008\n009\n010\n011\n012\n013",
+      "heading_level": null,
+      "page_id": 0,
+      "polygon": [
+        [
+          21.216796875,
+          162.421875
+        ],
+        [
+          43.330078125,
+          162.421875
+        ],
+        [
+          43.330078125,
+          234.5491943359375
+        ],
+        [
+          21.216796875,
+          234.5491943359375
+        ]
+      ]
+    },
+    {
+      "title": "015\n016\n017\n018\n019\n020",
+      "heading_level": null,
+      "page_id": 0,
+      "polygon": [
+        [
+          22.7109375,
+          248.49664306640625
+        ],
+        [
+          44.2265625,
+          248.49664306640625
+        ],
+        [
+          44.2265625,
+          318.2352600097656
+        ],
+        [
+          22.7109375,
+          318.2352600097656
+        ]
+      ]
+    },
+    {
+      "title": "Tool-Genesis: A Task-Driven Tool Creation Benchmark for Self-Evolving\nLanguage Agent",
+      "heading_level": null,
+      "page_id": 0,
+      "polygon": [
+        [
+          74.109375,
+          89.9119873046875
+        ],
+        [
+          523.546875,
+          89.9119873046875
+        ],
+        [
+          523.546875,
+          122.191162109375
+        ],
+        [
+          74.109375,
+          122.191162109375
+        ]
+      ]
+    },
+    {
+      "title": "Anonymous Authors1",
+      "heading_level": null,
+      "page_id": 0,
+      "polygon": [
+        [
+          246.83203125,
+          159.64306640625
+        ],
+        [
+          338.87109375,
+          159.64306640625
+        ],
+        [
+          338.87109375,
+          170.86407470703125
+        ],
+        [
+          246.83203125,
+          170.86407470703125
+        ]
+      ]
+    },
+    {
+      "title": "Abstract",
+      "heading_level": null,
+      "page_id": 0,
+      "polygon": [
+        [
+          149.712890625,
+          186.75311279296875
+        ],
+        [
+          194.68325805664062,
+          186.75311279296875
+        ],
+        [
+          194.68325805664062,
+          198.70831298828125
+        ],
+        [
+          149.712890625,
+          198.70831298828125
+        ]
+      ]
+    },
+    {
+      "title": "1. Introduction",
+      "heading_level": null,
+      "page_id": 0,
+      "polygon": [
+        [
+          54.685546875,
+          581.84814453125
+        ],
+        [
+          132.2760772705078,
+          581.84814453125
+        ],
+        [
+          132.2760772705078,
+          593.8033447265625
+        ],
+        [
+          54.685546875,
+          593.8033447265625
+        ]
+      ]
+    },
+    {
+      "title": "2. Problem Formalization",
+      "heading_level": null,
+      "page_id": 1,
+      "polygon": [
+        [
+          307.1953125,
+          631.9941558837891
+        ],
+        [
+          438.6796875,
+          631.9941558837891
+        ],
+        [
+          438.6796875,
+          643.9493560791016
+        ],
+        [
+          307.1953125,
+          643.9493560791016
+        ]
+      ]
+    },
+    {
+      "title": "2.1. Task Definition",
+      "heading_level": null,
+      "page_id": 1,
+      "polygon": [
+        [
+          307.1953125,
+          651.62109375
+        ],
+        [
+          390.8671875,
+          651.62109375
+        ],
+        [
+          390.8671875,
+          662.8591156005859
+        ],
+        [
+          307.1953125,
+          662.8591156005859
+        ]
+      ]
+    },
+    {
+      "title": "2.2. Metrics",
+      "heading_level": null,
+      "page_id": 2,
+      "polygon": [
+        [
+          52.892578125,
+          617.030517578125
+        ],
+        [
+          105.51203155517578,
+          617.030517578125
+        ],
+        [
+          105.51203155517578,
+          626.9931182861328
+        ],
+        [
+          52.892578125,
+          626.9931182861328
+        ]
+      ]
+    },
+    {
+      "title": "3. Dataset Construction",
+      "heading_level": null,
+      "page_id": 2,
+      "polygon": [
+        [
+          305.103515625,
+          538.836181640625
+        ],
+        [
+          427.97235107421875,
+          538.836181640625
+        ],
+        [
+          427.97235107421875,
+          550.7913818359375
+        ],
+        [
+          305.103515625,
+          550.7913818359375
+        ]
+      ]
+    },
+    {
+      "title": "3.1. Compliant MCP-server Data Collection",
+      "heading_level": null,
+      "page_id": 2,
+      "polygon": [
+        [
+          306.0,
+          656.6025085449219
+        ],
+        [
+          493.7306823730469,
+          656.6025085449219
+        ],
+        [
+          493.7306823730469,
+          666.5651092529297
+        ],
+        [
+          306.0,
+          666.5651092529297
+        ]
+      ]
+    },
+    {
+      "title": "3.2. High-Quality Task & Trajectory Generation",
+      "heading_level": null,
+      "page_id": 3,
+      "polygon": [
+        [
+          54.38671875,
+          321.75
+        ],
+        [
+          261.05810546875,
+          321.75
+        ],
+        [
+          261.05810546875,
+          332.61712646484375
+        ],
+        [
+          54.38671875,
+          332.61712646484375
+        ]
+      ]
+    },
+    {
+      "title": "3.3. Comprehensive Unit Test Generation",
+      "heading_level": null,
+      "page_id": 3,
+      "polygon": [
+        [
+          51.99609375,
+          654.3605041503906
+        ],
+        [
+          230.69207763671875,
+          654.3605041503906
+        ],
+        [
+          230.69207763671875,
+          664.3230972290039
+        ],
+        [
+          51.99609375,
+          664.3230972290039
+        ]
+      ]
+    },
+    {
+      "title": "3.4. Manual Quality Inspection",
+      "heading_level": null,
+      "page_id": 3,
+      "polygon": [
+        [
+          306.298828125,
+          397.6925048828125
+        ],
+        [
+          439.576171875,
+          397.6925048828125
+        ],
+        [
+          439.576171875,
+          407.65509033203125
+        ],
+        [
+          306.298828125,
+          407.65509033203125
+        ]
+      ]
+    },
+    {
+      "title": "4. Data Analysis",
+      "heading_level": null,
+      "page_id": 4,
+      "polygon": [
+        [
+          53.7890625,
+          415.64312744140625
+        ],
+        [
+          138.13412475585938,
+          415.64312744140625
+        ],
+        [
+          138.13412475585938,
+          427.59832763671875
+        ],
+        [
+          53.7890625,
+          427.59832763671875
+        ]
+      ]
+    },
+    {
+      "title": "5. Experiments",
+      "heading_level": null,
+      "page_id": 4,
+      "polygon": [
+        [
+          305.103515625,
+          308.0461730957031
+        ],
+        [
+          384.47930908203125,
+          308.0461730957031
+        ],
+        [
+          384.47930908203125,
+          320.0013732910156
+        ],
+        [
+          305.103515625,
+          320.0013732910156
+        ]
+      ]
+    },
+    {
+      "title": "5.1. Experimental Setup",
+      "heading_level": null,
+      "page_id": 4,
+      "polygon": [
+        [
+          306.896484375,
+          328.9485168457031
+        ],
+        [
+          410.291015625,
+          328.9485168457031
+        ],
+        [
+          410.291015625,
+          338.9111022949219
+        ],
+        [
+          306.896484375,
+          338.9111022949219
+        ]
+      ]
+    },
+    {
+      "title": "5.2. Experimental Results",
+      "heading_level": null,
+      "page_id": 4,
+      "polygon": [
+        [
+          306.0,
+          670.18359375
+        ],
+        [
+          416.4706726074219,
+          670.18359375
+        ],
+        [
+          416.4706726074219,
+          681.5760955810547
+        ],
+        [
+          306.0,
+          681.5760955810547
+        ]
+      ]
+    },
+    {
+      "title": "6. Analysis",
+      "heading_level": null,
+      "page_id": 5,
+      "polygon": [
+        [
+          304.505859375,
+          666.155158996582
+        ],
+        [
+          362.577392578125,
+          666.155158996582
+        ],
+        [
+          362.577392578125,
+          678.1103591918945
+        ],
+        [
+          304.505859375,
+          678.1103591918945
+        ]
+      ]
+    },
+    {
+      "title": "6.1. Signal-validation alignment under closed-loop",
+      "heading_level": null,
+      "page_id": 6,
+      "polygon": [
+        [
+          53.19140625,
+          425.390625
+        ],
+        [
+          270.75,
+          425.390625
+        ],
+        [
+          270.75,
+          435.0
+        ],
+        [
+          53.19140625,
+          435.0
+        ]
+      ]
+    },
+    {
+      "title": "6.2. Pass-through along the verification cascade",
+      "heading_level": null,
+      "page_id": 6,
+      "polygon": [
+        [
+          52.59375,
+          613.5
+        ],
+        [
+          257.25,
+          613.5
+        ],
+        [
+          257.25,
+          623.00390625
+        ],
+        [
+          52.59375,
+          623.00390625
+        ]
+      ]
+    },
+    {
+      "title": "6.3. Finetuning exploration: internalizing capability",
+      "heading_level": null,
+      "page_id": 6,
+      "polygon": [
+        [
+          306.0,
+          547.5
+        ],
+        [
+          528.75,
+          547.5
+        ],
+        [
+          528.75,
+          558.03515625
+        ],
+        [
+          306.0,
+          558.03515625
+        ]
+      ]
+    },
+    {
+      "title": "7. Related Work",
+      "heading_level": null,
+      "page_id": 7,
+      "polygon": [
+        [
+          53.19140625,
+          478.37109375
+        ],
+        [
+          138.55255126953125,
+          478.37109375
+        ],
+        [
+          138.55255126953125,
+          490.933349609375
+        ],
+        [
+          53.19140625,
+          490.933349609375
+        ]
+      ]
+    },
+    {
+      "title": "8. Conclusion",
+      "heading_level": null,
+      "page_id": 7,
+      "polygon": [
+        [
+          307.44000244140625,
+          453.62109375
+        ],
+        [
+          376.52911376953125,
+          453.62109375
+        ],
+        [
+          376.52911376953125,
+          467.0223693847656
+        ],
+        [
+          307.44000244140625,
+          467.0223693847656
+        ]
+      ]
+    },
+    {
+      "title": "Impact Statement",
+      "heading_level": null,
+      "page_id": 8,
+      "polygon": [
+        [
+          52.59375,
+          96.412109375
+        ],
+        [
+          146.74185180664062,
+          96.412109375
+        ],
+        [
+          146.74185180664062,
+          108.3673095703125
+        ],
+        [
+          52.59375,
+          108.3673095703125
+        ]
+      ]
+    },
+    {
+      "title": "References",
+      "heading_level": null,
+      "page_id": 8,
+      "polygon": [
+        [
+          52.892578125,
+          371.4981689453125
+        ],
+        [
+          110.9838638305664,
+          371.4981689453125
+        ],
+        [
+          110.9838638305664,
+          383.453369140625
+        ],
+        [
+          52.892578125,
+          383.453369140625
+        ]
+      ]
+    },
+    {
+      "title": "A. Evaluation Methodology Details",
+      "heading_level": null,
+      "page_id": 11,
+      "polygon": [
+        [
+          51.99609375,
+          68.0625
+        ],
+        [
+          234.0,
+          68.0625
+        ],
+        [
+          234.0,
+          78.890625
+        ],
+        [
+          51.99609375,
+          78.890625
+        ]
+      ]
+    },
+    {
+      "title": "A.1. Layer 1: Surface Compliance and Server Execution",
+      "heading_level": null,
+      "page_id": 11,
+      "polygon": [
+        [
+          53.7890625,
+          137.25
+        ],
+        [
+          294.75,
+          137.25
+        ],
+        [
+          294.75,
+          146.953125
+        ],
+        [
+          53.7890625,
+          146.953125
+        ]
+      ]
+    },
+    {
+      "title": "A.2. Layer 2: Semantic Interface Fidelity (Schema-F1)",
+      "heading_level": null,
+      "page_id": 11,
+      "polygon": [
+        [
+          52.59375,
+          413.40234375
+        ],
+        [
+          288.0,
+          413.40234375
+        ],
+        [
+          288.0,
+          423.0
+        ],
+        [
+          52.59375,
+          423.0
+        ]
+      ]
+    },
+    {
+      "title": "A.3. Layer 3: Functional Correctness via Unit Tests (UT)",
+      "heading_level": null,
+      "page_id": 12,
+      "polygon": [
+        [
+          52.59375,
+          69.37646484375
+        ],
+        [
+          296.6843566894531,
+          69.37646484375
+        ],
+        [
+          296.6843566894531,
+          79.33905029296875
+        ],
+        [
+          52.59375,
+          79.33905029296875
+        ]
+      ]
+    },
+    {
+      "title": "A.4. Layer 4: Downstream Task Utility (Oracle-normalized SR)",
+      "heading_level": null,
+      "page_id": 12,
+      "polygon": [
+        [
+          54.38671875,
+          468.6455078125
+        ],
+        [
+          325.72265625,
+          468.6455078125
+        ],
+        [
+          325.72265625,
+          478.60809326171875
+        ],
+        [
+          54.38671875,
+          478.60809326171875
+        ]
+      ]
+    },
+    {
+      "title": "B. More Dataset Construction Details",
+      "heading_level": null,
+      "page_id": 12,
+      "polygon": [
+        [
+          52.59375,
+          662.6011657714844
+        ],
+        [
+          247.4296875,
+          662.6011657714844
+        ],
+        [
+          247.4296875,
+          674.5563583374023
+        ],
+        [
+          52.59375,
+          674.5563583374023
+        ]
+      ]
+    },
+    {
+      "title": "B.1. Examples",
+      "heading_level": null,
+      "page_id": 13,
+      "polygon": [
+        [
+          53.490234375,
+          224.296875
+        ],
+        [
+          116.0524673461914,
+          224.296875
+        ],
+        [
+          116.0524673461914,
+          234.39013671875
+        ],
+        [
+          53.490234375,
+          234.39013671875
+        ]
+      ]
+    },
+    {
+      "title": "Example 1: MCP-server schema instance (Dsrv).",
+      "heading_level": null,
+      "page_id": 13,
+      "polygon": [
+        [
+          52.59375,
+          242.81182861328125
+        ],
+        [
+          262.4101867675781,
+          242.81182861328125
+        ],
+        [
+          262.4101867675781,
+          253.74456787109375
+        ],
+        [
+          52.59375,
+          253.74456787109375
+        ]
+      ]
+    },
+    {
+      "title": "Example 2: Task instance (Dtraj ).",
+      "heading_level": null,
+      "page_id": 15,
+      "polygon": [
+        [
+          53.7890625,
+          284.23828125
+        ],
+        [
+          199.18418884277344,
+          284.23828125
+        ],
+        [
+          199.18418884277344,
+          295.3635559082031
+        ],
+        [
+          53.7890625,
+          295.3635559082031
+        ]
+      ]
+    },
+    {
+      "title": "Example 3: Unit test instance (Dut).",
+      "heading_level": null,
+      "page_id": 15,
+      "polygon": [
+        [
+          53.7890625,
+          367.5487976074219
+        ],
+        [
+          208.07920837402344,
+          367.5487976074219
+        ],
+        [
+          208.07920837402344,
+          378.4825439453125
+        ],
+        [
+          53.7890625,
+          378.4825439453125
+        ]
+      ]
+    },
+    {
+      "title": "B.2. MCP-server Filtering Details",
+      "heading_level": null,
+      "page_id": 15,
+      "polygon": [
+        [
+          54.38671875,
+          478.0614929199219
+        ],
+        [
+          198.28375244140625,
+          478.0614929199219
+        ],
+        [
+          198.28375244140625,
+          488.0240783691406
+        ],
+        [
+          54.38671875,
+          488.0240783691406
+        ]
+      ]
+    },
+    {
+      "title": "B.3. LLM-as-Judge Prompt for Server Semantic Validation",
+      "heading_level": null,
+      "page_id": 16,
+      "polygon": [
+        [
+          54.984375,
+          148.11328125
+        ],
+        [
+          306.6668701171875,
+          148.11328125
+        ],
+        [
+          306.6668701171875,
+          158.2711181640625
+        ],
+        [
+          54.984375,
+          158.2711181640625
+        ]
+      ]
+    },
+    {
+      "title": "B.4. Task Generation and Filtering",
+      "heading_level": null,
+      "page_id": 17,
+      "polygon": [
+        [
+          52.892578125,
+          69.37646484375
+        ],
+        [
+          203.42445373535156,
+          69.37646484375
+        ],
+        [
+          203.42445373535156,
+          79.33905029296875
+        ],
+        [
+          52.892578125,
+          79.33905029296875
+        ]
+      ]
+    },
+    {
+      "title": "B.5. Trajectory Generation and Filtering",
+      "heading_level": null,
+      "page_id": 21,
+      "polygon": [
+        [
+          54.38671875,
+          327.52252197265625
+        ],
+        [
+          228.4803924560547,
+          327.52252197265625
+        ],
+        [
+          228.4803924560547,
+          337.485107421875
+        ],
+        [
+          54.38671875,
+          337.485107421875
+        ]
+      ]
+    },
+    {
+      "title": "B.6. Unit Test Prompts",
+      "heading_level": null,
+      "page_id": 22,
+      "polygon": [
+        [
+          51.3984375,
+          609.4205169677734
+        ],
+        [
+          152.02740478515625,
+          609.4205169677734
+        ],
+        [
+          152.02740478515625,
+          619.91015625
+        ],
+        [
+          51.3984375,
+          619.91015625
+        ]
+      ]
+    },
+    {
+      "title": "C. More Details on Experiments",
+      "heading_level": null,
+      "page_id": 23,
+      "polygon": [
+        [
+          53.7890625,
+          305.5078125
+        ],
+        [
+          220.5,
+          305.5078125
+        ],
+        [
+          220.5,
+          318.0
+        ],
+        [
+          53.7890625,
+          318.0
+        ]
+      ]
+    },
+    {
+      "title": "D. More Details on Analysis",
+      "heading_level": null,
+      "page_id": 23,
+      "polygon": [
+        [
+          53.490234375,
+          328.7109375
+        ],
+        [
+          198.0,
+          328.7109375
+        ],
+        [
+          198.0,
+          339.75
+        ],
+        [
+          53.490234375,
+          339.75
+        ]
+      ]
+    },
+    {
+      "title": "D.1. Signal-Validation Alignment (SVA) score",
+      "heading_level": null,
+      "page_id": 23,
+      "polygon": [
+        [
+          52.59375,
+          348.046875
+        ],
+        [
+          251.25,
+          348.046875
+        ],
+        [
+          251.25,
+          357.75
+        ],
+        [
+          52.59375,
+          357.75
+        ]
+      ]
+    },
+    {
+      "title": "E. More Details on Exploration",
+      "heading_level": null,
+      "page_id": 23,
+      "polygon": [
+        [
+          53.19140625,
+          578.25
+        ],
+        [
+          215.25,
+          578.25
+        ],
+        [
+          215.25,
+          588.97265625
+        ],
+        [
+          53.19140625,
+          588.97265625
+        ]
+      ]
+    },
+    {
+      "title": "E.1. Finetuning Exploration",
+      "heading_level": null,
+      "page_id": 23,
+      "polygon": [
+        [
+          51.99609375,
+          598.5
+        ],
+        [
+          174.75,
+          598.5
+        ],
+        [
+          174.75,
+          608.25
+        ],
+        [
+          51.99609375,
+          608.25
+        ]
+      ]
+    }
+  ],
+  "page_stats": [
+    {
+      "page_id": 0,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          416
+        ],
+        [
+          "Line",
+          178
+        ],
+        [
+          "Text",
+          13
+        ],
+        [
+          "SectionHeader",
+          7
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "Footnote",
+          1
+        ],
+        [
+          "Figure",
+          1
+        ],
+        [
+          "Caption",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ],
+        [
+          "FigureGroup",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 1,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          499
+        ],
+        [
+          "Line",
+          156
+        ],
+        [
+          "TableCell",
+          107
+        ],
+        [
+          "Text",
+          9
+        ],
+        [
+          "ListItem",
+          3
+        ],
+        [
+          "Table",
+          2
+        ],
+        [
+          "SectionHeader",
+          2
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "Caption",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ],
+        [
+          "TableGroup",
+          1
+        ],
+        [
+          "ListGroup",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 2,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          572
+        ],
+        [
+          "Line",
+          169
+        ],
+        [
+          "Text",
+          10
+        ],
+        [
+          "SectionHeader",
+          3
+        ],
+        [
+          "Reference",
+          3
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "Figure",
+          1
+        ],
+        [
+          "Caption",
+          1
+        ],
+        [
+          "Equation",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ],
+        [
+          "FigureGroup",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 3,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          423
+        ],
+        [
+          "Line",
+          145
+        ],
+        [
+          "Text",
+          17
+        ],
+        [
+          "Reference",
+          4
+        ],
+        [
+          "SectionHeader",
+          3
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "Figure",
+          1
+        ],
+        [
+          "Caption",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ],
+        [
+          "FigureGroup",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 4,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          527
+        ],
+        [
+          "Line",
+          207
+        ],
+        [
+          "TableCell",
+          50
+        ],
+        [
+          "Text",
+          12
+        ],
+        [
+          "SectionHeader",
+          4
+        ],
+        [
+          "PageHeader",
+          2
+        ],
+        [
+          "Table",
+          2
+        ],
+        [
+          "Caption",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ],
+        [
+          "TableGroup",
+          1
+        ],
+        [
+          "Reference",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 5,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          427
+        ],
+        [
+          "TableCell",
+          311
+        ],
+        [
+          "Line",
+          115
+        ],
+        [
+          "Text",
+          10
+        ],
+        [
+          "Table",
+          2
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "Caption",
+          1
+        ],
+        [
+          "SectionHeader",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ],
+        [
+          "TableGroup",
+          1
+        ],
+        [
+          "Reference",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 6,
+      "text_extraction_method": "surya",
+      "block_counts": [
+        [
+          "Line",
+          245
+        ],
+        [
+          "Span",
+          98
+        ],
+        [
+          "Text",
+          54
+        ],
+        [
+          "Reference",
+          5
+        ],
+        [
+          "SectionHeader",
+          3
+        ],
+        [
+          "Figure",
+          2
+        ],
+        [
+          "Caption",
+          2
+        ],
+        [
+          "FigureGroup",
+          2
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 7,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          544
+        ],
+        [
+          "Line",
+          156
+        ],
+        [
+          "Text",
+          10
+        ],
+        [
+          "SectionHeader",
+          2
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 8,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          343
+        ],
+        [
+          "Line",
+          151
+        ],
+        [
+          "ListItem",
+          17
+        ],
+        [
+          "Reference",
+          17
+        ],
+        [
+          "Text",
+          5
+        ],
+        [
+          "SectionHeader",
+          2
+        ],
+        [
+          "ListGroup",
+          2
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 9,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          320
+        ],
+        [
+          "Line",
+          136
+        ],
+        [
+          "ListItem",
+          23
+        ],
+        [
+          "Reference",
+          21
+        ],
+        [
+          "Text",
+          12
+        ],
+        [
+          "ListGroup",
+          2
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 10,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          243
+        ],
+        [
+          "Line",
+          101
+        ],
+        [
+          "ListItem",
+          17
+        ],
+        [
+          "Reference",
+          16
+        ],
+        [
+          "Text",
+          10
+        ],
+        [
+          "ListGroup",
+          2
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 11,
+      "text_extraction_method": "surya",
+      "block_counts": [
+        [
+          "Line",
+          156
+        ],
+        [
+          "Span",
+          123
+        ],
+        [
+          "Text",
+          46
+        ],
+        [
+          "Equation",
+          7
+        ],
+        [
+          "SectionHeader",
+          3
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ],
+        [
+          "Reference",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 12,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          558
+        ],
+        [
+          "Line",
+          148
+        ],
+        [
+          "Text",
+          16
+        ],
+        [
+          "Equation",
+          8
+        ],
+        [
+          "SectionHeader",
+          3
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ],
+        [
+          "Reference",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 13,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          220
+        ],
+        [
+          "Line",
+          99
+        ],
+        [
+          "Text",
+          11
+        ],
+        [
+          "SectionHeader",
+          2
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "Figure",
+          1
+        ],
+        [
+          "Caption",
+          1
+        ],
+        [
+          "Code",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ],
+        [
+          "FigureGroup",
+          1
+        ],
+        [
+          "Reference",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 14,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          222
+        ],
+        [
+          "Line",
+          109
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "Code",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 15,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          272
+        ],
+        [
+          "Line",
+          104
+        ],
+        [
+          "Text",
+          5
+        ],
+        [
+          "Code",
+          3
+        ],
+        [
+          "SectionHeader",
+          3
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 16,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          220
+        ],
+        [
+          "Line",
+          97
+        ],
+        [
+          "Text",
+          3
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "SectionHeader",
+          1
+        ],
+        [
+          "Code",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 17,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          197
+        ],
+        [
+          "Line",
+          93
+        ],
+        [
+          "Text",
+          4
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "SectionHeader",
+          1
+        ],
+        [
+          "Code",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 18,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          197
+        ],
+        [
+          "Line",
+          88
+        ],
+        [
+          "Text",
+          2
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "Code",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 19,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          202
+        ],
+        [
+          "Line",
+          91
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "Code",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ],
+        [
+          "Text",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 20,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          224
+        ],
+        [
+          "Line",
+          103
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "Code",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ],
+        [
+          "Text",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 21,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          226
+        ],
+        [
+          "Line",
+          100
+        ],
+        [
+          "Code",
+          2
+        ],
+        [
+          "Text",
+          2
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "SectionHeader",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 22,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          210
+        ],
+        [
+          "Line",
+          98
+        ],
+        [
+          "Code",
+          2
+        ],
+        [
+          "Text",
+          2
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "SectionHeader",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 23,
+      "text_extraction_method": "surya",
+      "block_counts": [
+        [
+          "Line",
+          139
+        ],
+        [
+          "Span",
+          112
+        ],
+        [
+          "Text",
+          32
+        ],
+        [
+          "SectionHeader",
+          5
+        ],
+        [
+          "Reference",
+          2
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "Code",
+          1
+        ],
+        [
+          "Equation",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    },
+    {
+      "page_id": 24,
+      "text_extraction_method": "pdftext",
+      "block_counts": [
+        [
+          "Span",
+          235
+        ],
+        [
+          "Line",
+          83
+        ],
+        [
+          "Text",
+          5
+        ],
+        [
+          "PageHeader",
+          1
+        ],
+        [
+          "PageFooter",
+          1
+        ]
+      ],
+      "block_metadata": {
+        "llm_request_count": 0,
+        "llm_error_count": 0,
+        "llm_tokens_used": 0,
+        "previous_text": "",
+        "previous_type": "",
+        "previous_order": 0
+      }
+    }
+  ],
+  "debug_data_path": "debug_data/640e44ec-91da-4d38-9b9a-4a3a20ad15d0"
+}

icml26/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/model_text_v3.txt

@@ -0,0 +1,185 @@
+[p. 1 | section: Abstract | type: Text]
+Research on self-evolving language agents progresses, increasing attention has focused on their ability to create, adapt, and maintain tools from task requirements.However, existing benchmarks predominantly rely on pre-defined specifications, which limits scalability and hinders true autonomous evolution. While recent studies attempt to dynamically generate tools, they primarily focus on downstream performance, creating a "black box" evaluation that makes it difficult to accurately attribute the causes of failure.To address this, we propose Tool-Genesis, a diagnostic benchmark designed to quantify agent capabilities across multiple dimensions—from interface compliance and functional correctness to downstream utility. It evaluates the ability of agents to construct task-relevant tools solely from abstract requirements (without pre-set specifications) and solve realistic problems.Crucially, we find that even state-of-the-art models struggle to construct precise tool interfaces or executable logic in a one-shot setting. These minor initial flaws are amplified through the pipeline, leading to a precipitous drop in downstream metrics. We hope this benchmark will guide future research toward steering models to synthesize persistent, general-purpose tools capable of addressing broader real-world challenges.Project page:
+
+[p. 1 | section: 1. Introduction | type: Text]
+Prior work has established a "reason–call–execute" paradigm, typically assuming reliable tool interfaces and schemas, where tools are treated as callable functions with well-defined inputs/outputs and stable semantics.(e.g.,
+
+[p. 1 | section: 1. Introduction | type: FigureGroup]
+Figure 1. Comparison of tool creation paradigms: (a) Outcome-Driven: Ad-hoc solving with disposable scripts; (b) Code-Centric: Spec-based translation with limited safety; (c) Tool-Genesis(Ours): Inductive design for verified, reusable assets.
+
+[p. 1 | section: 1. Introduction | type: Text]
+(Karpas et al., 2022; Yao et al., 2023; Schick et al., 2023) ), with benchmarks further standardizing the evaluation (e.g., (Patil et al., 2023; Qin et al., 2023a; Li et al., 2023; Anony mous, 2023; Guo et al., 2024; Berkeley Function Call ing Leaderboard (BFCL) Team, 2024; Wang et al., 2024a; Huang et al., 2024; Zhang et al., 2025c; Shi et al., 2024; Wang et al., 2024b) ). In this paradigm, tool use is largely reduced to selecting an API, filling arguments, and executing calls under a fixed contract, while success is measured by answer correctness or call-level validity. In realistic deployments, however, this assumption often breaks due to missing specifications, evolving APIs, uncovered long-tail needs, or execution failures caused by bugs. Even small interface ambiguities (e.g., optional fields, implicit constraints, undocumented edge cases) can cascade into repeated execution errors and brittle agent behaviors, especially when the task requires multi-step composition across tools. As a result, agents must evolve from merely using tools to creating , adapting , and repairing tools from abstract requirements, and to distilling reusable pipelines into maintainable tool assets—a core mechanism of self-evolving language agents
+
+[p. 2 | section: 1. Introduction | type: TableGroup]
+Benchmark Scale (Reported) I. Artifacts Required II. Verification Signals Tool Sets Avg Tools # Domains No Doc Schema Gen Reuse Tool Toolset (≥ 2) Held-out UnitTests Neg Tests GT Tools CREATOR (Qian et al., 2023b) 2K 1 9 ✗ ✗ ✓ ✓ ✗ ✗ ✗ LATM (Cai et al., 2024) 6 1 6 ✓ ✗ ✗ ✗ ✗ ✗ ✗ CRAFT (Yuan et al., 2024) 150 3 3 ✗ ✗ ✓ ✓ ✗ ✗ ✗ TM-Bench (Wölflein et al., 2025) 15 1 4 ✓ ✗ ✓ ✗ ✓ ✗ ✗ SciEvo (Zhang et al., 2025a) 925 6 25 ✓ ✗ ✓ ✗ ✓ ✗ ✗ TOOL-GENESIS (Ours) 86 6 24 ✓ ✓ ✓ ✓ ✓ ✓ ✓ Table 1. Feature-wise comparison of representative tool-creation benchmarks under a strict binary rubric. Held-out UnitTests indicates tests/invocations are not available during tool creation and used strictly for evaluation (e.g., TM-Bench).
+
+[p. 2 | section: 1. Introduction | type: Text]
+that improve over long-horizon task distributions (Wu et al., 2024; Tan et al., 2024) .
+
+[p. 2 | section: 1. Introduction | type: Text]
+Despite steady progress, when the goal is to evaluate this self-evolving capability along the tool dimension under deployment-like constraints, existing benchmarks exhibit three practical disconnects. First, most evaluations remain spec-first: they assume that interfaces or schemas are directly available, or implicitly rely on high-quality reference specifications. This emphasizes correctness under predefined contracts, while the end-to-end capability of inferring interface contracts from requirements and producing machine-checkable schemas is not systematically measured. Second, regarding tool organization, many settings primarily evaluate the scale or diversity of tool collections rather than the construction of a scenario-closed toolbox. They often overlook the agent's ability to distill capabilities into a cohesive, maintainable toolset that covers key sub-processes of a specific real-world scenario (e.g., Yuan et al., 2024; Wang et al., 2024c; Zhao et al., 2025; Huang et al., 2025; Qian et al., 2024) . Third, and most critically, evaluation signals are often outcome-centric, creating a "black box" dilemma. Benchmarks frequently rely on final answers or coarse call-level checks. Even when unit tests are used, their coverage and attribution granularity vary widely. This makes it difficult to disentangle whether a failure stems from defective tool construction (e.g., invalid schemas, logic bugs) or suboptimal tool utilization strategies, obscuring the specific stage where the error occurred (e.g., Zhang et al., 2025b; Wölflein et al., 2025; Guo et al., 2024; Anonymous, 2024; Lu et al., 2024) .
+
+[p. 2 | section: 1. Introduction | type: Text]
+To address these deployment-facing gaps, we introduce Tool-Genesis, a diagnostic benchmark designed to decouple tool generation from tool utilization. Unlike spec-first settings, Tool-Genesis evaluates agents under missing or underspecified interfaces, requiring them to infer contracts from abstract requirements, generate machine-checkable schemas, and produce executable implementations that satisfy criteria for reuse and maintenance. Crucially, our protocol serves as a diagnostic probe: it reveals that even state-ofthe-art models struggle to construct precise tool interfaces
+
+[p. 2 | section: 1. Introduction | type: Text]
+or logic in a one-shot setting. These minor initial flaws are amplified through the pipeline, leading to precipitous drops in downstream metrics. By shifting the target from one-off scripts to reusable tool assets, Tool-Genesis evaluates whether agents can continuously distill capabilities to cover a scenario's task distribution. Finally, we provide a unified, full-lifecycle evaluation protocol that jointly measures compliance, server executability, schema consistency, and functional validation (via explicit negative/boundary tests). We also introduce an oracle-normalized upper bound to quantify the utility gap between generated tool assets and reference tools.
+
+[p. 2 | section: 1. Introduction | type: ListGroup]
+Benchmark setting. We formalize a requirement-driven tool-creation setting that elevates toolsets as reusable assets. It evaluates creation under missing specifications, focusing on the agent's ability to infer schemas and implement executable logic from abstract requirements. Diagnostic evaluation protocol. We provide a fulllifecycle, execution-grounded protocol designed to disentangle failure causes. By incorporating multi-level signals—including compliance, schema fidelity, and explicit negative/boundary unit tests—we enable precise attribution of errors to either tool quality or usage strategy, addressing the "black box" issue. Oracle-normalized utility gap. We introduce an oraclenormalized upper-bound comparison to quantify the utility gap between generated tool assets and reference tools under the same task distribution, providing a clearer measure of practical self-evolution capability.
+
+[p. 2 | section: 2.1. Task Definition | type: Text]
+We formalize TOOL GENESIS as a conditional generation problem over Model Context Protocol (MCP) interfaces. Let X denote the natural-language task description, S the space of valid MCP interface schemas, and E the space of
+
+[p. 3 | section: 2.1. Task Definition | type: FigureGroup]
+Figure 2. Dataset construction pipeline of TOOL GENESIS.
+
+[p. 3 | section: 2.1. Task Definition | type: Text]
+executable server implementations. An MCP schema s ∈ S is represented as an ordered list of atomic tool definitions, s = [t1, . . . , tK], where each tool t k = ⟨ηk, ϕk, δk⟩ consists of a unique invocation identifier ηk, a parameter interface ϕ k specified by a JSON-schema-like typed signature with constraints, and a natural-language description δ k grounding its intended semantics and usage.
+
+[p. 3 | section: 2.1. Task Definition | type: Text]
+We decompose the tool creation process into two coupled prediction phases: Tool Interface Prediction and Tool Materialization. Formally, the joint probability of producing a schema s and an implementation e given requirement x is factorized as:
+
+[p. 3 | section: 2.1. Task Definition | type: Equation]
+P_{\theta}(s, e \mid x) = \underbrace{P_{\theta}(s \mid x)}_{\text{Interface Prediction}} \cdot \underbrace{P_{\theta}(e \mid s)}_{\text{Materialization}}. \tag{1}
+
+[p. 3 | section: 2.1. Task Definition | type: Text]
+In the first phase, the model predicts an interface schema sˆ = arg maxs∈S Pθ(s | x), specifying the structured tool signatures. In the second phase, conditioned on a schema scond, the model materializes an executable server implementation via eˆ = arg maxe∈E Pθ(e | scond). We evaluate this materialization under two settings: Oracle Materializa tion , where scond = s ∗ (ground truth) to isolate engineering capability, and Cascaded Materialization , where scond = ˆs (predicted schema) to assess end-to-end performance.
+
+[p. 3 | section: 2.2. Metrics | type: Text]
+We evaluate tool creation with a four-level metric suite (Appendix A) : (i) Level 1 (Surface Compliance) reports Compliance Rate and Server Execution Rate. Compliance Rate measures whether list_tools returns a parseable, MCPcompliant registry, while Server Execution Rate measures whether the server launches and remains responsive under fixed timeouts. (ii) Level 2 (Semantic Interface Fidelity)
+
+[p. 3 | section: 2.2. Metrics | type: Text]
+reports Schema-F1, quantifying schema-level fidelity by aligning predicted and reference tools via bipartite matching and computing an F1 score over tool interfaces. (iii) Level 3 (Functional Correctness) reports UTsoft and UThard, which measure the fraction of tools passing predefined Unit Tests under relaxed and strict (boundary/negative) criteria, respectively. (iv) Level 4 (Downstream Task Utility) assesses the end-to-end practical efficacy by employing a fixed proxy agent (qwen3-14b-instruct) to solve benchmark tasks equipped with the generated tools. To rigorously isolate tool quality from solver capability, we conduct a parallel control experiment using ground-truth reference tools, with all final outcomes evaluated by an LLM-as-a-Judge. This comparative setup allows us to report an Oracle-Normalized Success Rate (SR), which quantifies the utility of the synthesized tools relative to the upper-bound performance achieved by the optimal reference implementation under the same experimental conditions.
+
+[p. 3 | section: 3. Dataset Construction | type: Text]
+This section describes the dataset construction pipeline of TOOL GENESIS. It covers Compliant MCP-server Data Collection ( §3.1) , High-Quality Task & Trajectory Genera tion ( §3.2) , Comprehensive Unit Test Generation ( §3.3) , and Manual Quality Inspection ( §3.4) . The overall procedure is illustrated in Figure 2. Detailed prompts, rubrics, thresholds, and implementation specifics are provided in Appendix B.
+
+[p. 3 | section: 3.1. Compliant MCP-server Data Collection | type: Text]
+MCP Crawling: We collect MCP servers from web sources: (i) MCP aggregators (GLMA, Smithery), (ii) GitHub search and curated lists, and (iii) HuggingFace (e.g., Toucan) in
+
+[p. 4 | section: 3.1. Compliant MCP-server Data Collection | type: Text]
+Aug–Sep 2025. We keep source links and server metadata (server_name, description), without mirroring repositories. We obtain tool registries by launching servers and calling list_tools, falling back to static registries/specifications when needed. Schemas are normalized using server_name and tool_name as server/tool IDs.
+
+[p. 4 | section: 3.1. Compliant MCP-server Data Collection | type: Text]
+MCP-server Filtering. We apply a four-stage filtering pipeline to construct a high-quality MCP-server dataset. (i) Structure Validation enforces that each server exposes a parseable tool registry with well-formed tool names, descriptions, and input schemas. (ii) Executable Validation removes servers that cannot be reliably launched or invoked in a sandboxed environment. (iii) Deduplication & Clustering reduces redundancy by grouping servers with similar schema-level interfaces and retaining a single representative per group. (iv) LLM Semantic Validation filters servers that require external credentials or exhibit high sandbox requirements, ensuring safe and self-contained execution. The remaining servers form the MCP-server Dataset Dsrv (86 servers).
+
+[p. 4 | section: 3.2. High-Quality Task & Trajectory Generation | type: Text]
+Task generation and filtering. We follow a Toucan-style LLM-driven pipeline (Xu et al., 2025) to synthesize tasks. For each server, an LLM is prompted with tool schemas (and docs, if any) to generate tasks, expanded along breadth (distinct scenarios and tool subsets) and depth (multi-step tasks with more tool calls).To ensure high data diversity, we further employ a rejection sampling strategy that penalizes redundant tool combinations, forcing the LLM to explore edge cases and rare parameter configurations. An LLM-as-judge scores candidates on a fixed 1–5 Likert rubric (quality, realism, verifiability, stability) and assesses solv ability ; we retain only tasks with all dimensions > 3 and solvable=true.
+
+[p. 4 | section: 3.2. High-Quality Task & Trajectory Generation | type: Text]
+Trajectory generation and filtering. For each retained task, we generate execution trajectories by running an agent in a sandbox(to support servers requiring network access).This sandbox execution ensures that each trajectory is grounded in real-time tool feedback, allowing us to filter out "hallucinated" successful executions that do not reflect actual API behaviors. We apply lightweight rule-based checks (parseable calls, valid responses) and employ LLM-as-ajudge to verify consistency and completion and penalize redundancy; we retain trajectories with completion and conciseness > 3 and complete=true, with solvability and completion judged by the LLM.
+
+[p. 4 | section: 3.3. Comprehensive Unit Test Generation | type: Text]
+Unit test generation. We extract unit tests from Dtraj by converting replayable tool-call steps (executable in the sandbox) into a unified format (tool_name, inputs, expected
+
+[p. 4 | section: 3.3. Comprehensive Unit Test Generation | type: FigureGroup]
+Figure 3. Comparison of benchmarks in terms of task reasoning depth and tool compositionality.
+
+[p. 4 | section: 3.3. Comprehensive Unit Test Generation | type: Text]
+outputs), retaining up to 100 tests per server for coverage. When extraction provides insufficient coverage for a tool, we synthesize additional tests with an LLM conditioned on the tool schema, targeting diverse valid calls.
+
+[p. 4 | section: 3.3. Comprehensive Unit Test Generation | type: Text]
+Unit test filtering. We apply two post-filters for quality and deduplication. (i) Parameter-based filtering removes tests with invalid inputs, type errors, or disallowed dependencies. (ii) We cluster tests per tool to merge near-duplicates and keep representatives, embedding normalized (input, output) pairs and merging those with cosine similarity ≥ 0.9.
+
+[p. 4 | section: 3.4. Manual Quality Inspection | type: Text]
+Manual Annotation: (i) MCP-server Data Consistency Check—verify schema/version consistency, stable unique IDs, split integrity, and formatting rules; (ii) Task Tool Functionality Match—confirm that referenced tools exist in the registry, required arguments are schema-compatible, and the task intent aligns with documented tool functionality; (iii) Trajectory Validity Check—ensure trajectories satisfy task constraints with coherent ordering, contain no malformed tool calls, and have no forbidden dependencies; (iv) Unit Test Coverage Check—check that tests cover diverse tools and parameter regimes, meet per-server coverage targets, and avoid redundancy.
+
+[p. 4 | section: 3.4. Manual Quality Inspection | type: Text]
+Manual Review. All instances are manually re-checked by graduate-level reviewers (3 annotators over two weeks) in multiple passes. Reviewers conduct both instance-level inspection (task statement, referenced tools, trajectories, and unit tests) and cross-file consistency checks (registry ↔ task ↔ trajectory ↔ tests), correcting minor issues when possible and removing samples that violate any requirement. In particular, they (a) verify that each task is solvable using only the declared toolset and does not rely on hidden assumptions; (b) validate that every tool call conforms to the declared schema (argument names/types, required fields, and return usage); (c) check that trajectories are coherent and free of malformed calls, missing steps, or forbidden ex-
+
+[p. 5 | section: 3.4. Manual Quality Inspection | type: Table]
+Foundation & Core Tech Data Intelligence & Automation Productivity & Workflow Creative & Digital Life Services & Emerging Fields General & Others Operating System Core software platform AI/ML Tools Intelligent algorithms Daily Productivity Task management Content Creation Media generation Financial Services Banking & finance Web Search & Research Information retrieval Memory Management System resource optimization Data Analysis Insights from data Time & Calendar Scheduling & planning Social Media Networking platforms Health & Fitness Wellness tracking Education Learning resources Database Operations Data storage & management Browser Automation Web task scripting Communication Tools Messaging & collaboration Gaming Interactive entertainment Travel & Maps Navigation & trips Weather Forecast services Security & Authentication Protection & identity Development Tools Software building File Management Organization & storage API Integration Connecting services Crypto & Blockchain Decentralized finance Others Miscellaneous categories
+
+[p. 5 | section: 3.4. Manual Quality Inspection | type: TableGroup]
+Statistic Number MCP-servers 86 Total Tools 508 Domain classes 24 Label classes 18 Unit test 9441 Total tasks 2150 Average task length 53 Average step length 6 Average tool-using length 3 Figure 4. Overview statistics of TOOL GENESIS. Left: functional domain coverage of MCP servers across 24 domain classes. Right: dataset scale and task/trajectory structure statistics.
+
+[p. 5 | section: 3.4. Manual Quality Inspection | type: Text]
+ternal dependencies; and (d) inspect unit tests to ensure they include both positive and negative/boundary cases, span representative parameter regimes, and do not leak answers or duplicate existing tests. We retain an instance only when at least two annotators independently agree on accept/reject, and the inter-annotator agreement on accept/reject decisions reaches a Cohen's κ of 0.85 (Landis & Koch, 1977) . Finally, after edits and removals, we perform a final end-to-end recheck on the finalized dataset to ensure each retained instance meets all constraints and yields a coherent tool-use process.
+
+[p. 5 | section: 4. Data Analysis | type: Text]
+Overall scale. Figure 4 summarizes the scale of TOOL GEN-ESIS. After filtering and manual inspection, the dataset contains 86 executable MCP servers with 508 tools, spanning 24 domain classes. We collect 2,150 tasks and 9,441 unit tests, covering 18 task label classes. These statistics provide a concise overview of the benchmark size across servers, tools, tasks, and tests.
+
+[p. 5 | section: 4. Data Analysis | type: Text]
+Domain coverage. The retained MCP servers span a diverse set of functional domains. The 24 domain classes are grouped into six high-level categories, covering foundational system tools, data intelligence and automation, productivity and workflow utilities, creative and digital-life applications, service-oriented domains (e.g., finance, health, travel), and general-purpose tools. The distribution includes both commonly used domains and a long tail of more specialized categories.
+
+[p. 5 | section: 4. Data Analysis | type: Text]
+Execution structure. We further examine the execution structure of task trajectories. Tasks have an average length of 53 tokens, while trajectories involve 6 execution steps on average and invoke 3 distinct tools per task. This indicates that many instances require sequential tool invocation rather than single-step execution. As shown in Figure 3, the
+
+[p. 5 | section: 4. Data Analysis | type: Text]
+dataset covers task structures ranging from simple singletool interactions to multi-step, multi-tool compositions.
+
+[p. 5 | section: 5.1. Experimental Setup | type: Text]
+Models. We evaluate a broad suite of frontier and opensource LLMs, covering closed-source families—OpenAI GPT models (gpt-4o, gpt-4.1-mini, gpt-4.1, gpt-5.1; (Ope nAI, 2025) ), Anthropic Claude (claude-sonnet-4; (An thropic, 2025) ), and Google Gemini (gemini-3-flash; (Google DeepMind, 2025) )—as well as open-source families including Qwen3 (4B/8B/14B/30B-A3B/32B/235B-A22B; (Yang et al., 2025) ), DeepSeek (deepseek-v3.2; (DeepSeek-AI et al., 2024) ), and MoonshotAI Kimi (Kimi-K2(-Instruct); (Kimi Team, 2025) ).
+
+[p. 5 | section: 5.1. Experimental Setup | type: Text]
+Inference Strategy. On top of this model suite, we run a unified evaluation harness with two inference strategies: (i) Direct, which performs single-pass generation of TI and TM outputs; and (ii) Code-Agent, which wraps the same LLM in a ReAct-style agent loop (Yao et al., 2023) . Specifically, Code-Agent follows a "think → act (tool) → observe" procedure for up to 10 steps, and can invoke sandboxed execution tools to run and validate generated artifacts.
+
+[p. 5 | section: 5.1. Experimental Setup | type: Text]
+Implementation Details. All models are queried through their standard chat APIs using a shared prompt template and fixed decoding settings (max tokens = 40,960, temperature = 0, top_p = 1). For Code-Agent, sandboxed execution is performed under fixed resource limits and timeouts to support automated artifact validation and downstream task execution.
+
+[p. 5 | section: 5.2. Experimental Results | type: Text]
+Several conclusions can be drawn from TableTable 2: (i) Closed-loop repair yields consistent multi-layer gains
+
+[p. 6 | section: 5.2. Experimental Results | type: TableGroup]
+Model Family Version L1 L2 L3 L4 Compliance ↑ Exec.↑ Schema-F1↑ UTsoft ↑ UThard ↑ SR↑ Direct gpt-4o 0.779 0.209 0.175 0.089 0.049 0.153 gpt-4.1-mini 0.686 0.318 0.293 0.127 0.088 0.199 OpenAI (OpenAI, 2025) gpt-4.1 0.860 0.738 0.675 0.261 0.129 0.330 gpt-5.1 0.826 0.759 0.688 0.281 0.161 0.372 Anthropic (Anthropic, 2025) claude-haiku-3.5 0.744 0.012 0.012 0.007 0.000 0.012 Google (Google DeepMind, 2025) gemini-3-flash-preview 0.872 0.140 0.116 0.084 0.037 0.103 235b-a22b-instruct-2507 0.884 0.333 0.320 0.143 0.108 0.287 32b 0.791 0.282 0.258 0.176 0.078 0.178 30b-a3b-instruct-2507 0.884 0.256 0.250 0.093 0.025 0.218 Qwen3 (Yang et al., 2025) 14b 0.791 0.186 0.175 0.154 0.075 0.128 8b 0.686 0.012 0.011 0.001 0.001 0.012 4b 0.651 0.000 0.000 0.000 0.000 0.000 DeepSeek (DeepSeek-AI et al., 2024) deepseek-v3.2 0.826 0.400 0.365 0.195 0.129 0.224 MoonshotAI (Kimi Team, 2025) Kimi-K2-Instruct 0.860 0.372 0.342 0.144 0.087 0.215 Code-Agent gpt-4o 0.802 0.531 0.456 0.237 0.117 0.226 gpt-4.1-mini 0.651 0.906 0.640 0.278 0.144 0.344 OpenAI (OpenAI, 2025) gpt-4.1 0.884 0.756 0.691 0.288 0.145 0.433 gpt-5.1 0.895 0.941 0.867 0.421 0.246 0.604 Anthropic (Anthropic, 2025) claude-haiku-3.5 0.733 0.964 0.821 0.342 0.180 0.472 Google (Google DeepMind, 2025) gemini-3-flash-preview 0.849 0.977 0.912 0.448 0.255 0.581 Qwen3 (Yang et al., 2025) 235b-a22b-instruct-2507 0.686 0.971 0.722 0.363 0.212 0.472 32b 0.860 0.892 0.801 0.317 0.179 0.495 30b-a3b-instruct-2507 0.744 0.913 0.694 0.336 0.187 0.410 14b 0.686 0.807 0.707 0.316 0.178 0.453 8b 0.767 0.694 0.646 0.243 0.121 0.332 4b 0.651 0.326 0.285 0.127 0.058 0.181 DeepSeek (DeepSeek-AI et al., 2024) deepseek-v3.2 0.872 0.744 0.702 0.330 0.195 0.449 MoonshotAI (Kimi Team, 2025) Kimi-K2 0.872 0.976 0.898 0.389 0.235 0.585 Table 2. Main results under two evaluation paradigms (Direct and Code-Agent) updated with the latest metrics. Metrics follow our four-level evaluation: L1 surface compliance (Compliance, Server Execution), L2 semantic interface fidelity (Schema-F1), L3 functional correctness via unit tests (UTsoft, UThard), and L4 downstream task utility (Task Success Rate, SR).
+
+[p. 6 | section: 5.2. Experimental Results | type: Text]
+and can produce step-changes in end-to-end utility. Across most model families, Code-Agent improves functional correctness and task success beyond surface executability and schema fidelity. For Gemini-3-Flash, EXEC. increases from 0.140 to 0.977, Schema-F1 from 0.116 to 0.912, and UThard from 0.129 to 0.726, resulting in a large SRsoft jump (0.103 → 0.581). A similar effect is observed for Qwen3-235B (SRsoft: 0.193 → 0.622), indicating that execution feedback is effectively translated into verifiable correctness and downstream utility.(ii) High compliance and plausible schemas are necessary but insufficient, revealing a utility-conversion bottleneck. Strong upstream signals (L1/L2) do not guarantee downstream success (L4). Under Direct , Qwen3-32B achieves high EXEC. (0.938) and Schema-F1 (0.880), yet SRsoft remains 0.535. Conversely, when schema fidelity degrades (e.g., gpt-4.1 under Direct ), downstream utility collapses accordingly. These gaps sug-
+
+[p. 6 | section: 5.2. Experimental Results | type: Text]
+gest that failures increasingly arise from implementation robustness, boundary handling, and state discipline that are only exposed through execution.(iii) Repair benefits are scale-dependent and can reorder models within a family. Under Code-Agent , larger models achieve higher downstream utility (e.g., Qwen3 SRsoft: 0.336 for 4B vs. 0.622 for 235B). Notably, model rankings can flip across strategies: Qwen3-32B outperforms 235B under Direct , while 235B overtakes under Code-Agent . This indicates that closed-loop tool creation relies on an additional capability—the ability to exploit execution feedback for targeted repair—that is not captured by single-pass generation alone.
+
+[p. 6 | section: 6. Analysis | type: Text]
+Beyond aggregate success rates, we analyze tool creation along three axes that align with our lifecycle evaluation.
+
+[p. 7 | section: 6. Analysis | type: FigureGroup]
+Figure 5. Direct prompting vs. code-agent repair on Qwen3 scales: (a) Signal–Validation Alignment (SVA) of Schema-F1 and UT (soft/hard); (b) stage-wise cumulative pass-through across verification stages (Start, L1–L4) for selected scales, with solid/dashed lines denoting the two paradigms.
+
+[p. 7 | section: 6. Analysis | type: Text]
+(i) We measure whether intermediate verification signals are predictive of downstream trajectory validation, and how closed-loop repair changes this predictiveness across model scales (Sec. 6.1). (ii) We localize where failures concentrate along the verification cascade by reporting stage-wise cumulative pass-through from Start to L1–L4, contrasting Direct prompting with Code-Agent repair and identifying the dominant attrition stages (Sec. 6.2). (iii) We move from inference-time interventions to capability internalization via finetuning, and examine how training reshapes one-shot synthesis under Direct and patch effectiveness under Code-Agent (Sec. 6.3).
+
+[p. 7 | section: 6.1. Signal-validation alignment under closed-loop | type: Text]
+Figure 5(a) quantifies how indicative verification signals are of downstream trajectory validation via a Signal–Validation Alignment (SVA) score (App. D.1). Under direct prompting, SVA remains low across scales: even at Qwen3-235B, Schema SVA is 0.19 and UT<sub>hard</sub> is 0.14, while Qwen3-8B collapses toward zero (Schema \approx 0.01 , UT<sub>hard</sub> \approx 0.00 ). Without execution feedback, interface- and verification-level metrics are weak proxies for downstream utility; with closed-loop repair, signal–validation alignment strengthens substantially. At Qwen3-235B, SVA reaches 0.58, and the improvement is stage-wise with a threshold around 8B \rightarrow 14B: Schema increases from 0.32 to 0.51, and UT<sub>hard</sub> from 0.26 to 0.48.
+
+[p. 7 | section: 6.2. Pass-through along the verification cascade | type: Text]
+Figure 5(b) reports the cumulative pass-through (in %) across Start and L1–L4. Under direct prompting, Qwen3-8B drops to 1.11% at L1 and \approx 0.12\% by L2–L4; for Qwen3-14B/32B/235B, pass-through is 17.52/24.84/31.60% at L1 and 3.99/5.44/9.47% at L4. Closed-loop repair lifts early-stage pass-through (L1: 65.34%, 84.06%, 83.02%, 91.36% for 8B/14B/32B/235B) and improves late-stage retention
+
+[p. 7 | section: 6.2. Pass-through along the verification cascade | type: FigureGroup]
+Figure 6. Base vs. fine-tuned performance under Direct and Code-Agent evaluation, summarized across our four-layer metric suite (L1–L4).
+
+[p. 7 | section: 6.2. Pass-through along the verification cascade | type: Text]
+(L4: 8.85%, 7.97%, 15.69%, 30.01%), vs. 0.12%, 3.99%, 5.44%, and 9.47% under direct prompting. Once early stages are stabilized, the dominant attrition concentrates at L3/L4, and scaling mainly improves late-stage retention (e.g., L4: 7.97\% \rightarrow 15.69\% \rightarrow 30.01\% from 14B to 32B to 235B under code-agent). Overall, repair primarily reduces early structural failures, leaving deeper validation as the bottleneck.
+
+[p. 7 | section: 6.3. Finetuning exploration: internalizing capability | type: Text]
+Prompting and inference-time repair can improve tool creation by injecting demonstrations or execution feedback, but they do not necessarily strengthen the model's intrinsic ability to synthesize reusable tool assets. We therefore finetune models on TOOL GENESIS and evaluate whether training improves both intermediate verification and downstream task success. We defer training configurations and implementation details to Appendix E.
+
+[p. 7 | section: 6.3. Finetuning exploration: internalizing capability | type: Text]
+Finetuning on TOOL GENESIS yields consistent gains across all evaluation layers (Table 6), indicating that TOOL GEN-ESIS provides not only a diagnostic benchmark but also an effective training signal for requirement-driven tool cre-
+
+[p. 8 | section: 6.3. Finetuning exploration: internalizing capability | type: Text]
+ation. On Qwen3-8B, under the Direct setting, finetuning improves one-shot generation at the interface and schema level: Compliance increases from 0.686 to 0.826 (+0.140), while Exec. rises from 0.012 to 0.047 (+0.035) and Schema-F1 from 0.011 to 0.046 (+0.035). These early-stage gains translate into measurable (though still small) functional validation improvements, with UTsoft increasing from 0.001 to 0.017 (+0.016) and UThard from 0.001 to 0.007 (+0.006), and downstream success SR improving from 0.012 to 0.026 (+0.014). Notably, because the Direct baseline is near-zero on executability and testing, absolute gains are more informative than relative ratios in this regime.
+
+[p. 8 | section: 6.3. Finetuning exploration: internalizing capability | type: Text]
+Under the Code-Agent setting, finetuning strengthens closed-loop repair and improves how execution feedback is converted into downstream utility. For Qwen3-8B, Compliance increases from 0.718 to 0.906 (+0.188), Exec. from 0.694 to 0.777 (+0.083), and Schema-F1 from 0.653 to 0.736 (+0.083). Improvements also propagate to functional validation, with UTsoft increasing from 0.307 to 0.377 (+0.070) and UThard from 0.456 to 0.533 (+0.077), yielding a higher SR from 0.336 to 0.399 (+0.063). Compared to Direct, gains under Code-Agent are less concentrated at the earliest gates and more evenly reflected in UT and SR, consistent with the interpretation that finetuning improves bug localization and patch quality under a fixed repair budget.
+
+[p. 8 | section: 6.3. Finetuning exploration: internalizing capability | type: Text]
+Overall, finetuning complements inference-time repair: it improves one-shot interface/schema synthesis under Direct, and under Code-Agent it increases the effectiveness of execution-triggered debugging, thereby raising the rate at which intermediate verification improvements translate into downstream task success.
+
+[p. 8 | section: 7. Related Work | type: Text]
+Tool-augmented LLMs are commonly evaluated by whether an agent can correctly invoke external tools and APIs to accomplish tasks (Karpas et al., 2022; Yao et al., 2023; Schick et al., 2023; Patil et al., 2023; Li et al., 2023; Qin et al., 2023a; b; Guo et al., 2024; Berkeley Function Call ing Leaderboard (BFCL) Team, 2024; Wang et al., 2024a; Huang et al., 2024; Anonymous, 2025; Zhang et al., 2025c; Shen et al., 2024; Liu et al., 2024; Wang et al., 2024f; Liu et al., 2023b; Zhang et al., 2024; Wang et al., 2024e) . Within this broader line, early tool-creation benchmarks and systems largely treat creation as a task-scoped deliverable and score it with downstream success as a black-box signal (Cai et al., 2023; Qian et al., 2023a; Wölflein et al., 2025) ; while task-relevant, such outcome-only evaluation is diagnostically weak because failures conflate requirement misunderstanding, interface/spec errors, implementation bugs, and unsafe or incorrect usage policies. To reduce hallucinated specifications and better reflect real constraints, later
+
+[p. 8 | section: 7. Related Work | type: Text]
+work increasingly grounds creation in external references (API docs/specs/repos/knowledge bases) and adds contractfaithfulness signals (e.g., schema/parameter consistency) as intermediate checks, often still reported alongside end-task outcomes (Liu et al., 2025; Zhao et al., 2025; Qian et al., 2024; Wang et al., 2024d) . As evaluation moves closer to "real execution," a complementary trend adopts executable and test-driven verification to obtain reproducible correctness signals and clearer attribution (Zhang et al., 2025b; Wölflein et al., 2025; Jimenez et al., 2023; Chen et al., 2021; Austin et al., 2021; Hendrycks et al., 2021; Liu et al., 2023a; Zhuo et al., 2024) ; here, a stable execution environment and robust negative/boundary testing become essential to avoid flaky outcomes, prevent accidental overfitting to shallow success cases, and enable regression checking under tool evolution. More recently, tool creation is increasingly framed as building reusable toolsets/toolboxes that support retrieval, composition, maintenance, and updates across a task distribution—often serving knowledge access rather than a single one-off objective (Yuan et al., 2024; Wang et al., 2024c; Zhao et al., 2025; Huang et al., 2025; Qian et al., 2024) . Despite these advances, existing benchmarks remain fragmented: some emphasize task outcomes, others emphasize interface faithfulness or passing tests, and toolsetlevel reuse/maintenance is rarely evaluated together with executable correctness (including invalid/boundary cases) and downstream utility in a unified, reproducible protocol; in particular, oracle-normalized comparisons that quantify the utility gap between generated tools and ground-truth tools are still under-explored, motivating our benchmark and evaluation design.
+
+[p. 8 | section: 8. Conclusion | type: Text]
+We present Tool-Genesis, a diagnostic benchmark for evaluating tool creation as a first-class capability of self-evolving language agents. Tool-Genesis departs from spec-first settings by requiring agents to infer tool contracts from abstract requirements, generate machine-checkable schemas, and implement executable logic that can be reused as a scenarioclosed toolset. To avoid outcome-only "black box" evaluation, we introduce a full-lifecycle protocol that jointly measures interface compliance, executability, schema fidelity, and functional correctness with explicit negative/boundary unit tests, and we further report an oracle-normalized upper bound to quantify the utility gap between generated and reference tools under the same task distribution.Our empirical findings highlight a key bottleneck: even strong models often fail to produce precise interfaces or correct implementations in a one-shot setting, and these small early-stage defects are amplified through the downstream pipeline. We hope Tool-Genesis will help the community move beyond ad-hoc, disposable tool use toward persistent and maintain able tool assets, and enable more targeted progress on tool
+
+[p. 9 | section: 8. Conclusion | type: Text]
+induction, repair, and verification in realistic deployments.
+
+[p. 9 | section: Impact Statement | type: Text]
+"This paper presents work whose goal is to advance the field of Machine Learning. There are many potential societal consequences of our work, none which we feel must be specifically highlighted here."
+
+[p. 9 | section: Impact Statement | type: Text]
+The above statement can be used verbatim in such cases, but we encourage authors to think about whether there is content which does warrant further discussion, as this statement will be apparent if the paper is later flagged for ethics review.

icml26/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/parse_report.json

@@ -0,0 +1,75 @@
+{
+  "paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0",
+  "pipeline": "marker_non_llm_v3",
+  "parser": "marker_single",
+  "formats": [
+    "markdown",
+    "chunks"
+  ],
+  "llm_enabled": false,
+  "pdf_path": "/network/scratch/j/jianan.zhao/ReviewAgent/data/processed_papers/icml26_20260429_1952_duequeue/raw/640e44ec-91da-4d38-9b9a-4a3a20ad15d0.pdf",
+  "pdf_sha256": "6d1ba62449713c2ce2eafccd365659f524c30d55bcd43c3e35a09a3ac0b44873",
+  "bytes": 1873253,
+  "source": "https://koala.science/storage/pdfs/640e44ec-91da-4d38-9b9a-4a3a20ad15d0.pdf",
+  "page_count": 25,
+  "ok": true,
+  "elapsed_seconds": 155.75,
+  "paper2markdown_v3": {
+    "paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0",
+    "pipeline": "Paper2Markdown-V3",
+    "ok": true,
+    "page_count": 25,
+    "chunk_count": 137,
+    "main_body_chunk_count": 62,
+    "appendix_chunk_count": 69,
+    "reference_chunk_count": 6,
+    "model_text_chars": 38054,
+    "raw_markdown_chars": 99874,
+    "sanitized_chars": 84120,
+    "page_provenance": {
+      "min_page": 1,
+      "max_page": 25,
+      "invalid_count": 0
+    },
+    "marker_block_type_counts": {
+      "Code": 15,
+      "Equation": 17,
+      "FigureGroup": 6,
+      "Footnote": 1,
+      "ListGroup": 7,
+      "PageFooter": 25,
+      "PageHeader": 26,
+      "SectionHeader": 47,
+      "Table": 3,
+      "TableGroup": 3,
+      "Text": 292
+    },
+    "asset_count_raw": 6,
+    "asset_count_model_kept": 6,
+    "asset_count_rejected": 0,
+    "asset_reject_reasons": {
+      "kept": 6
+    },
+    "artifact_leak_audit": {
+      "ok": true,
+      "hits": {
+        "Anonymous Authors": [],
+        "ACKNOWLEDGMENT": [],
+        "OpenReview": [],
+        "\"accept_label\"": [],
+        "\"decision\"": [],
+        "\"decision_tier\"": [],
+        "\"source_status\"": [],
+        "Meta-review": [],
+        "Official Review": [],
+        "official_reviews": [],
+        "meta_reviews": [],
+        "suggested_verdict_score": []
+      },
+      "artifact_count": 2
+    },
+    "default_model_input": "model_text_v3.txt",
+    "appendix_input": "appendix_text_v3.txt",
+    "reference_input": "reference_text_v3.txt"
+  }
+}

icml26/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/reference_chunks.jsonl

@@ -0,0 +1,6 @@
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0062", "section": "References", "page_start": 9, "page_end": 9, "type": "ListGroup", "text": "Cai, T., Wang, Z., Chen, Y., Ma, R., Li, Z., Zhu, L., Chen, W., Jiang, Y., Sun, M., and Liu, Z. Large language models as tool makers, 2023. URL 2305.17126 . Cai, Z., Liu, Y., Zhang, W., and Wang, Y. Latm: A benchmark for latent tool creation. Proceedings of the 2024 International Conference on Machine Learning (ICML) , pp. 234–245, 2024. Chen, M., Tworek, J., Jun, H., Yuan, Q., Pinto, H. P. d. O., Kaplan, J., Edwards, H., et al. Evaluating large language models trained on code, 2021. URL abs/2107.03374 . DeepSeek-AI et al. Deepseek-v3 technical report, 2024. URL . Google DeepMind. Gemini 3 flash: Model card, December 2025. URL googleapis.com/deepmind-media/Model-Cards/ Gemini-3-Flash-Model-Card.pdf . Model card (PDF). Accessed: 2026-01-22. Guo, Z., Cheng, S., Wang, H., Liang, S., Qin, Y., Li, P., Liu, Z., Sun, M., and Liu, Y. StableToolBench: Towards stable large-scale benchmarking on tool learning of large language models, 2024. URL 2403.07714 . Hendrycks, D., Basart, S., Kadavath, S., Mazeika, M., Arora, A., Guo, E., Burns, C., Puranik, S., He, H., Song, D., and Steinhardt, J. Measuring coding challenge competence with apps, 2021. URL 09938 . Huang, S., Zhong, W., Lu, J., Zhu, Q., Gao, J., Liu, W., Hou, Y., Zeng, X., Wang, Y., Shang, L., Jiang, X., Xu, R., and Liu, Q. Planning, creation, usage: Benchmarking llms for comprehensive tool utilization in real-world complex scenarios, 2024. URL 17167 . Huang, W., Zhuang, S., Wang, H., Guo, Z., Liu, Z., Sun, M., and Liu, Y. Toollibgen: Automated tool library generation with large language models, 2025. URL org/abs/2505.16956 . Jimenez, C. E., Yang, J., Wettig, A., Yao, S., Pei, K., Press, O., and Narasimhan, K. SWE-bench: Can language models resolve real-world github issues?, 2023. URL . Karpas, E., Shuster, K., Geva, M., Schick, T., Gupta, R., Eisenstein, J., and Berant, J. MRKL systems: A modular, neuro-symbolic architecture that combines large language models, external knowledge sources and discrete reasoning, 2022. URL .", "source": "marker_v2", "marker_block_id": "/page/8/ListGroup/521"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0063", "section": "References", "page_start": 10, "page_end": 10, "type": "Text", "text": "495 496 Kimi Team. Kimi k2: Open agentic intelligence, 2025. URL .", "source": "marker_v2", "marker_block_id": "/page/9/Text/494"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0064", "section": "References", "page_start": 10, "page_end": 10, "type": "ListGroup", "text": "Landis, J. R. and Koch, G. G. The measurement of observer agreement for categorical data. Biometrics , 33(1):159– 174, 1977. Langley, P. Crafting papers on machine learning. In Langley, P. (ed.), Proceedings of the 17th International Conference on Machine Learning (ICML 2000) , pp. 1207–1216, Stanford, CA, 2000. Morgan Kaufmann. Li, Z., Huang, Q., Xu, H., Zhang, Z., Wang, J., and Li, J. API-Bank: A benchmark for tool-augmented LLMs, 2023. URL . Liu, J., Xia, C., Zhang, L., et al. Is your code generated by chatgpt really correct? rigorous evaluation of large language models for code generation, 2023a. URL https: //arxiv.org/abs/2305.01210 . Liu, T. et al. Agentbench: Evaluating llms as agents, 2023b. URL . Liu, X., Yin, D., Wu, Z., and Feng, Y. Reftool: Enhancing model reasoning with reference-guided tool creation, 2025. URL . Liu, X. et al. τ -bench: A benchmark for tool-agent user interaction in real-world scenarios, 2024. URL https: //arxiv.org/abs/2406.12045 . Lu, Y., Li, Z., Li, G., Ding, B., Wang, J., Liu, X., and Zhang, R. Toolsandbox: A state-of-the-art evaluation framework for tool-use robustness in large language models. arXiv preprint arXiv:2408.04684 , 2024. OpenAI. Update to GPT-5 system card: GPT-5.2, December 2025. URL 3a4153c8-c748-4b71-8e31-aecbde944f8d/oai_5_2_ system-card.pdf . System card (PDF). Accessed: 2026-01-22. Patil, S., Zhang, T., Wang, X., and Gonzalez, J. E. Gorilla: Large language model connected with massive APIs, 2023. URL . Qian, C., Han, C., Fung, Y., Qin, Y., Liu, Z., and Ji, H. CREATOR: Tool creation for disentangling abstract and concrete reasoning of large language models. In Findings of the Association for Computational Linguis tics: EMNLP 2023 , pp. 6922–6939, Singapore, December 2023a. Association for Computational Linguistics. doi: 10.18653/v1/2023.findings-emnlp.462. URL https: //aclanthology.org/2023.findings-emnlp.462/ . Qian, C., Xiong, C., Liu, Z., and Liu, Z. Toolink: Linking toolkit creation and using through chain-of-solving on", "source": "marker_v2", "marker_block_id": "/page/9/ListGroup/492"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0065", "section": "References", "page_start": 10, "page_end": 10, "type": "ListGroup", "text": "open-source model. In Proceedings of the 2024 Confer ence of the North American Chapter of the Association for Computational Linguistics: Human Language Tech nologies (Volume 1: Long Papers) , pp. 831–854, Mexico City, Mexico, June 2024. Association for Computational Linguistics. doi: 10.18653/v1/2024.naacl-long.48. URL . Qian, X., Zhang, Y., Li, Z., and Wang, L. Creator: A benchmark for tool creation and execution. Journal of Artificial Intelligence Research , 69:1–23, 2023b. Qin, Y., Liang, S., Ye, Y., Zhu, K., Yan, L., Lu, Y., Lin, Y., Cong, X., Tang, X., Qian, B., Zhao, S., Hong, L., Tian, R., Xie, R., Zhou, J., Gerstein, M., Li, D., Liu, Z., and Sun, M. ToolLLM: Facilitating large language models to master 16000+ real-world APIs, 2023a. URL . Qin, Y., Liang, S., Ye, Y., Zhu, K., Yan, L., Lu, Y., Lin, Y., Cong, X., Tang, X., et al. Toolbench: Towards benchmarking large language models on tool use, 2023b. URL . Schick, T., Dwivedi-Yu, J., Dessì, R., Raileanu, R., Lombrozo, T., Zettlemoyer, L., Cancedda, N., and Scialom, T. Toolformer: Language models can teach themselves to use tools, 2023. URL 04761 . Shen, H., Li, Y., et al. Shortcutsbench: A large-scale realworld benchmark for api-based agents, 2024. URL https: //arxiv.org/abs/2407.00132 . Shi, Z., Gao, S., Yan, L., Feng, Y., Chen, X., Chen, Z., Yin, D., Verberne, S., and Ren, Z. Tool learning in the wild: Empowering language models as automatic tool agents. arXiv preprint arXiv:2405.16533 , 2024. Tan, W., Ding, Z., Zhang, W., Li, B., Zhou, B., Yue, J., et al. Cradle: Empowering foundation agents towards general computer control. arXiv preprint arXiv:2403.03186 , 2024. Wang, H., Wang, R., Xue, B., Xia, H., Cao, J., Liu, Z., Pan, J. Z., and Wong, K.-F. AppBench: Planning of multiple APIs from various APPs for complex user instruction. In Al-Onaizan, Y., Bansal, M., and Chen, Y.-N. (eds.), Proceedings of the 2024 Conference on Empirical Methods in Natural Language Process ing , pp. 15322–15336, Miami, Florida, USA, November 2024a. Association for Computational Linguistics. doi: 10.18653/v1/2024.emnlp-main.856. URL https: //aclanthology.org/2024.emnlp-main.856/ . Wang, X., Chen, Y., Yuan, L., Zhang, Y., Li, Y., Peng, H., and Ji, H. Executable code actions elicit better llm agents.", "source": "marker_v2", "marker_block_id": "/page/9/ListGroup/493"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0066", "section": "References", "page_start": 11, "page_end": 11, "type": "Text", "text": "550 In Forty-first International Conference on Machine Learn ing (ICML) , 2024b.", "source": "marker_v2", "marker_block_id": "/page/10/Text/374"}
+{"paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0", "chunk_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0:0067", "section": "References", "page_start": 11, "page_end": 11, "type": "ListGroup", "text": "Wang, Y., Zhang, Y., Liu, H., and Zhang, Y. Trove: A verifiable and efficient framework for toolset creation, 2024c. URL . Wang, Y. et al. APIGen: Automated pipeline for API function calling data generation, 2024d. URL https: //arxiv.org/abs/2409.01406 . Wang, Y. et al. Sciagent: Tool-augmented language models for scientific reasoning, 2024e. URL org/abs/2402.11451 . Wang, Z. et al. Wtu-eval: A unified evaluation framework for tool use, 2024f. URL 12823 . Wölflein, G., Schneider, J., and Krenn, M. Llm agents making agent tools, 2025. URL 2502.11705 . Introduces TM-BENCH and the ToolMaker framework. Wu, Z., Han, C., Ding, Z., Weng, Z., Liu, Z., Yao, S., Yu, T., and Kong, L. Os-copilot: Towards generalist computer agents with self-improvement. arXiv preprint arXiv:2402.07456 , 2024. Xu, Z., Meza Soria, A., Tan, S., Roy, A., Agrawal, A. S., Poovendran, R., and Panda, R. Toucan: Synthesizing 1.5m tool-agentic data from real-world mcp environments, 2025. URL . Yang, A. et al. Qwen3 technical report, 2025. URL https: //arxiv.org/abs/2505.09388 . Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., and Cao, Y. React: Synergizing reasoning and acting in language models. In International Confer ence on Learning Representations (ICLR) , 2023. URL . Yuan, S., Chen, Y., Chen, Y., Chen, J., and Liu, Z. CRAFT: Customizing LLMs by creating and retrieving from specialized toolsets, 2024. URL 2401.04052 . Zhang, Y., Liu, H., Huang, T., and Chen, Q. Scievo: A benchmark for scientific evolution of tools. arXiv preprint arXiv:2601.07641 , 2025a. Zhang, Y. et al. Scienceagentbench: Benchmarking language agents for scientific problem solving, 2024. URL . Zhang, Z., Liu, H., Chen, Y., Li, Z., Wang, J., and Li, J. Toolcoder: A holistic benchmark for tool creation, 2025b. URL .", "source": "marker_v2", "marker_block_id": "/page/10/ListGroup/372"}

icml26/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/reference_text_v3.txt

@@ -0,0 +1,17 @@
+[p. 9 | section: References | type: ListGroup]
+Cai, T., Wang, Z., Chen, Y., Ma, R., Li, Z., Zhu, L., Chen, W., Jiang, Y., Sun, M., and Liu, Z. Large language models as tool makers, 2023. URL 2305.17126 . Cai, Z., Liu, Y., Zhang, W., and Wang, Y. Latm: A benchmark for latent tool creation. Proceedings of the 2024 International Conference on Machine Learning (ICML) , pp. 234–245, 2024. Chen, M., Tworek, J., Jun, H., Yuan, Q., Pinto, H. P. d. O., Kaplan, J., Edwards, H., et al. Evaluating large language models trained on code, 2021. URL abs/2107.03374 . DeepSeek-AI et al. Deepseek-v3 technical report, 2024. URL . Google DeepMind. Gemini 3 flash: Model card, December 2025. URL googleapis.com/deepmind-media/Model-Cards/ Gemini-3-Flash-Model-Card.pdf . Model card (PDF). Accessed: 2026-01-22. Guo, Z., Cheng, S., Wang, H., Liang, S., Qin, Y., Li, P., Liu, Z., Sun, M., and Liu, Y. StableToolBench: Towards stable large-scale benchmarking on tool learning of large language models, 2024. URL 2403.07714 . Hendrycks, D., Basart, S., Kadavath, S., Mazeika, M., Arora, A., Guo, E., Burns, C., Puranik, S., He, H., Song, D., and Steinhardt, J. Measuring coding challenge competence with apps, 2021. URL 09938 . Huang, S., Zhong, W., Lu, J., Zhu, Q., Gao, J., Liu, W., Hou, Y., Zeng, X., Wang, Y., Shang, L., Jiang, X., Xu, R., and Liu, Q. Planning, creation, usage: Benchmarking llms for comprehensive tool utilization in real-world complex scenarios, 2024. URL 17167 . Huang, W., Zhuang, S., Wang, H., Guo, Z., Liu, Z., Sun, M., and Liu, Y. Toollibgen: Automated tool library generation with large language models, 2025. URL org/abs/2505.16956 . Jimenez, C. E., Yang, J., Wettig, A., Yao, S., Pei, K., Press, O., and Narasimhan, K. SWE-bench: Can language models resolve real-world github issues?, 2023. URL . Karpas, E., Shuster, K., Geva, M., Schick, T., Gupta, R., Eisenstein, J., and Berant, J. MRKL systems: A modular, neuro-symbolic architecture that combines large language models, external knowledge sources and discrete reasoning, 2022. URL .
+
+[p. 10 | section: References | type: Text]
+495 496 Kimi Team. Kimi k2: Open agentic intelligence, 2025. URL .
+
+[p. 10 | section: References | type: ListGroup]
+Landis, J. R. and Koch, G. G. The measurement of observer agreement for categorical data. Biometrics , 33(1):159– 174, 1977. Langley, P. Crafting papers on machine learning. In Langley, P. (ed.), Proceedings of the 17th International Conference on Machine Learning (ICML 2000) , pp. 1207–1216, Stanford, CA, 2000. Morgan Kaufmann. Li, Z., Huang, Q., Xu, H., Zhang, Z., Wang, J., and Li, J. API-Bank: A benchmark for tool-augmented LLMs, 2023. URL . Liu, J., Xia, C., Zhang, L., et al. Is your code generated by chatgpt really correct? rigorous evaluation of large language models for code generation, 2023a. URL https: //arxiv.org/abs/2305.01210 . Liu, T. et al. Agentbench: Evaluating llms as agents, 2023b. URL . Liu, X., Yin, D., Wu, Z., and Feng, Y. Reftool: Enhancing model reasoning with reference-guided tool creation, 2025. URL . Liu, X. et al. τ -bench: A benchmark for tool-agent user interaction in real-world scenarios, 2024. URL https: //arxiv.org/abs/2406.12045 . Lu, Y., Li, Z., Li, G., Ding, B., Wang, J., Liu, X., and Zhang, R. Toolsandbox: A state-of-the-art evaluation framework for tool-use robustness in large language models. arXiv preprint arXiv:2408.04684 , 2024. OpenAI. Update to GPT-5 system card: GPT-5.2, December 2025. URL 3a4153c8-c748-4b71-8e31-aecbde944f8d/oai_5_2_ system-card.pdf . System card (PDF). Accessed: 2026-01-22. Patil, S., Zhang, T., Wang, X., and Gonzalez, J. E. Gorilla: Large language model connected with massive APIs, 2023. URL . Qian, C., Han, C., Fung, Y., Qin, Y., Liu, Z., and Ji, H. CREATOR: Tool creation for disentangling abstract and concrete reasoning of large language models. In Findings of the Association for Computational Linguis tics: EMNLP 2023 , pp. 6922–6939, Singapore, December 2023a. Association for Computational Linguistics. doi: 10.18653/v1/2023.findings-emnlp.462. URL https: //aclanthology.org/2023.findings-emnlp.462/ . Qian, C., Xiong, C., Liu, Z., and Liu, Z. Toolink: Linking toolkit creation and using through chain-of-solving on
+
+[p. 10 | section: References | type: ListGroup]
+open-source model. In Proceedings of the 2024 Confer ence of the North American Chapter of the Association for Computational Linguistics: Human Language Tech nologies (Volume 1: Long Papers) , pp. 831–854, Mexico City, Mexico, June 2024. Association for Computational Linguistics. doi: 10.18653/v1/2024.naacl-long.48. URL . Qian, X., Zhang, Y., Li, Z., and Wang, L. Creator: A benchmark for tool creation and execution. Journal of Artificial Intelligence Research , 69:1–23, 2023b. Qin, Y., Liang, S., Ye, Y., Zhu, K., Yan, L., Lu, Y., Lin, Y., Cong, X., Tang, X., Qian, B., Zhao, S., Hong, L., Tian, R., Xie, R., Zhou, J., Gerstein, M., Li, D., Liu, Z., and Sun, M. ToolLLM: Facilitating large language models to master 16000+ real-world APIs, 2023a. URL . Qin, Y., Liang, S., Ye, Y., Zhu, K., Yan, L., Lu, Y., Lin, Y., Cong, X., Tang, X., et al. Toolbench: Towards benchmarking large language models on tool use, 2023b. URL . Schick, T., Dwivedi-Yu, J., Dessì, R., Raileanu, R., Lombrozo, T., Zettlemoyer, L., Cancedda, N., and Scialom, T. Toolformer: Language models can teach themselves to use tools, 2023. URL 04761 . Shen, H., Li, Y., et al. Shortcutsbench: A large-scale realworld benchmark for api-based agents, 2024. URL https: //arxiv.org/abs/2407.00132 . Shi, Z., Gao, S., Yan, L., Feng, Y., Chen, X., Chen, Z., Yin, D., Verberne, S., and Ren, Z. Tool learning in the wild: Empowering language models as automatic tool agents. arXiv preprint arXiv:2405.16533 , 2024. Tan, W., Ding, Z., Zhang, W., Li, B., Zhou, B., Yue, J., et al. Cradle: Empowering foundation agents towards general computer control. arXiv preprint arXiv:2403.03186 , 2024. Wang, H., Wang, R., Xue, B., Xia, H., Cao, J., Liu, Z., Pan, J. Z., and Wong, K.-F. AppBench: Planning of multiple APIs from various APPs for complex user instruction. In Al-Onaizan, Y., Bansal, M., and Chen, Y.-N. (eds.), Proceedings of the 2024 Conference on Empirical Methods in Natural Language Process ing , pp. 15322–15336, Miami, Florida, USA, November 2024a. Association for Computational Linguistics. doi: 10.18653/v1/2024.emnlp-main.856. URL https: //aclanthology.org/2024.emnlp-main.856/ . Wang, X., Chen, Y., Yuan, L., Zhang, Y., Li, Y., Peng, H., and Ji, H. Executable code actions elicit better llm agents.
+
+[p. 11 | section: References | type: Text]
+550 In Forty-first International Conference on Machine Learn ing (ICML) , 2024b.
+
+[p. 11 | section: References | type: ListGroup]
+Wang, Y., Zhang, Y., Liu, H., and Zhang, Y. Trove: A verifiable and efficient framework for toolset creation, 2024c. URL . Wang, Y. et al. APIGen: Automated pipeline for API function calling data generation, 2024d. URL https: //arxiv.org/abs/2409.01406 . Wang, Y. et al. Sciagent: Tool-augmented language models for scientific reasoning, 2024e. URL org/abs/2402.11451 . Wang, Z. et al. Wtu-eval: A unified evaluation framework for tool use, 2024f. URL 12823 . Wölflein, G., Schneider, J., and Krenn, M. Llm agents making agent tools, 2025. URL 2502.11705 . Introduces TM-BENCH and the ToolMaker framework. Wu, Z., Han, C., Ding, Z., Weng, Z., Liu, Z., Yao, S., Yu, T., and Kong, L. Os-copilot: Towards generalist computer agents with self-improvement. arXiv preprint arXiv:2402.07456 , 2024. Xu, Z., Meza Soria, A., Tan, S., Roy, A., Agrawal, A. S., Poovendran, R., and Panda, R. Toucan: Synthesizing 1.5m tool-agentic data from real-world mcp environments, 2025. URL . Yang, A. et al. Qwen3 technical report, 2025. URL https: //arxiv.org/abs/2505.09388 . Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., and Cao, Y. React: Synergizing reasoning and acting in language models. In International Confer ence on Learning Representations (ICLR) , 2023. URL . Yuan, S., Chen, Y., Chen, Y., Chen, J., and Liu, Z. CRAFT: Customizing LLMs by creating and retrieving from specialized toolsets, 2024. URL 2401.04052 . Zhang, Y., Liu, H., Huang, T., and Chen, Q. Scievo: A benchmark for scientific evolution of tools. arXiv preprint arXiv:2601.07641 , 2025a. Zhang, Y. et al. Scienceagentbench: Benchmarking language agents for scientific problem solving, 2024. URL . Zhang, Z., Liu, H., Chen, Y., Li, Z., Wang, J., and Li, J. Toolcoder: A holistic benchmark for tool creation, 2025b. URL .

icml26/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/sanitization_report.json

@@ -0,0 +1,58 @@
+{
+  "paper_id": "640e44ec-91da-4d38-9b9a-4a3a20ad15d0",
+  "pipeline": "Paper2Markdown-V3",
+  "ok": true,
+  "page_count": 25,
+  "chunk_count": 137,
+  "main_body_chunk_count": 62,
+  "appendix_chunk_count": 69,
+  "reference_chunk_count": 6,
+  "model_text_chars": 38054,
+  "raw_markdown_chars": 99874,
+  "sanitized_chars": 84120,
+  "page_provenance": {
+    "min_page": 1,
+    "max_page": 25,
+    "invalid_count": 0
+  },
+  "marker_block_type_counts": {
+    "Code": 15,
+    "Equation": 17,
+    "FigureGroup": 6,
+    "Footnote": 1,
+    "ListGroup": 7,
+    "PageFooter": 25,
+    "PageHeader": 26,
+    "SectionHeader": 47,
+    "Table": 3,
+    "TableGroup": 3,
+    "Text": 292
+  },
+  "asset_count_raw": 6,
+  "asset_count_model_kept": 6,
+  "asset_count_rejected": 0,
+  "asset_reject_reasons": {
+    "kept": 6
+  },
+  "artifact_leak_audit": {
+    "ok": true,
+    "hits": {
+      "Anonymous Authors": [],
+      "ACKNOWLEDGMENT": [],
+      "OpenReview": [],
+      "\"accept_label\"": [],
+      "\"decision\"": [],
+      "\"decision_tier\"": [],
+      "\"source_status\"": [],
+      "Meta-review": [],
+      "Official Review": [],
+      "official_reviews": [],
+      "meta_reviews": [],
+      "suggested_verdict_score": []
+    },
+    "artifact_count": 2
+  },
+  "default_model_input": "model_text_v3.txt",
+  "appendix_input": "appendix_text_v3.txt",
+  "reference_input": "reference_text_v3.txt"
+}

icml26/640e44ec-91da-4d38-9b9a-4a3a20ad15d0/sanitized_v3.txt

@@ -0,0 +1,851 @@
+{0}
+# Abstract
+Research on self-evolving language agents progresses, increasing attention has focused on their ability to create, adapt, and maintain tools from task requirements.However, existing benchmarks predominantly rely on pre-defined specifications, which limits scalability and hinders true autonomous evolution. While recent studies attempt to dynamically generate tools, they primarily focus on downstream performance, creating a "black box" evaluation that makes it difficult to accurately attribute the causes of failure.To address this, we propose Tool-Genesis, a diagnostic benchmark designed to quantify agent capabilities across multiple dimensions—from interface compliance and functional correctness to downstream utility. It evaluates the ability of agents to construct task-relevant tools solely from abstract requirements (without pre-set specifications) and solve realistic problems.Crucially, we find that even state-of-the-art models struggle to construct precise tool interfaces or executable logic in a one-shot setting. These minor initial flaws are amplified through the pipeline, leading to a precipitous drop in downstream metrics. We hope this benchmark will guide future research toward steering models to synthesize persistent, general-purpose tools capable of addressing broader real-world challenges.Project page: <
+# 1. Introduction
+Prior work has established a "reason–call–execute" paradigm, typically assuming reliable tool interfaces and schemas, where tools are treated as callable functions with well-defined inputs/outputs and stable semantics.(e.g.,
+![](_page_0_Figure_18.jpeg)
+*Figure 1.* Comparison of tool creation paradigms: (a) Outcome-Driven: Ad-hoc solving with disposable scripts; (b) Code-Centric: Spec-based translation with limited safety; (c) Tool-Genesis(Ours): Inductive design for verified, reusable assets.
+[\(Karpas et al., 2022;](#page-8-0) [Yao et al., 2023;](#page-10-0) [Schick et al., 2023\)](#page-9-0)), with benchmarks further standardizing the evaluation (e.g., [\(Patil et al., 2023;](#page-9-1) [Qin et al., 2023a;](#page-9-2) [Li et al., 2023;](#page-9-3) [Anony](#page-8-1)[mous, 2023;](#page-8-1) [Guo et al., 2024;](#page-8-2) [Berkeley Function Call](#page-8-3)[ing Leaderboard \(BFCL\) Team, 2024;](#page-8-3) [Wang et al., 2024a;](#page-9-4) [Huang et al., 2024;](#page-8-4) [Zhang et al., 2025c;](#page-10-1) [Shi et al., 2024;](#page-9-5) [Wang et al., 2024b\)](#page-9-6)). In this paradigm, tool use is largely reduced to selecting an API, filling arguments, and executing calls under a fixed contract, while success is measured by answer correctness or call-level validity. In realistic deployments, however, this assumption often breaks due to missing specifications, evolving APIs, uncovered long-tail needs, or execution failures caused by bugs. Even small interface ambiguities (e.g., optional fields, implicit constraints, undocumented edge cases) can cascade into repeated execution errors and brittle agent behaviors, especially when the task requires multi-step composition across tools. As a result, agents must evolve from merely *using* tools to *creating*, *adapting*, and *repairing* tools from abstract requirements, and to distilling reusable pipelines into maintainable tool assets—a core mechanism of self-evolving language agents
+{1}------------------------------------------------
+| 055 | |
+|-----|--|
+| 056 | |
+| 057 | |
+| 058 | |
+| 059 | |
+| 060 | |
+| 061 | |
+| 062 | |
+| 063 | |
+| 064 | |
+| 065 | |
+| | |
+| Benchmark | Scale (Reported) | | I. Artifacts Required | | | | II. Verification Signals | | | |
+|----------------------------------|------------------|--------------|-----------------------|-----------|---------------|---------------|--------------------------|-----------------------|--------------|-------------|
+| | Tool<br>Sets | Avg<br>Tools | #<br>Domains | No<br>Doc | Schema<br>Gen | Reuse<br>Tool | Toolset<br>(≥ 2) | Held-out<br>UnitTests | Neg<br>Tests | GT<br>Tools |
+| CREATOR (Qian et al., 2023b) | 2K | 1 | 9 | ✗ | ✗ | ✓ | ✓ | ✗ | ✗ | ✗ |
+| LATM (Cai et al., 2024) | 6 | 1 | 6 | ✓ | ✗ | ✗ | ✗ | ✗ | ✗ | ✗ |
+| CRAFT (Yuan et al., 2024) | 150 | 3 | 3 | ✗ | ✗ | ✓ | ✓ | ✗ | ✗ | ✗ |
+| TM-Bench (Wölflein et al., 2025) | 15 | 1 | 4 | ✓ | ✗ | ✓ | ✗ | ✓ | ✗ | ✗ |
+| SciEvo (Zhang et al., 2025a) | 925 | 6 | 25 | ✓ | ✗ | ✓ | ✗ | ✓ | ✗ | ✗ |
+| TOOL-GENESIS (Ours) | 86 | 6 | 24 | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+*Table 1.* Feature-wise comparison of representative *tool-creation* benchmarks under a strict binary rubric. Held-out UnitTests indicates tests/invocations are *not* available during tool creation and used strictly for evaluation (e.g., TM-Bench).
+that improve over long-horizon task distributions [\(Wu et al.,](#page-10-5) [2024;](#page-10-5) [Tan et al., 2024\)](#page-9-8).
+Despite steady progress, when the goal is to evaluate this self-evolving capability along the tool dimension under deployment-like constraints, existing benchmarks exhibit three practical disconnects. First, most evaluations remain spec-first: they assume that interfaces or schemas are directly available, or implicitly rely on high-quality reference specifications. This emphasizes correctness under predefined contracts, while the end-to-end capability of inferring interface contracts from requirements and producing machine-checkable schemas is not systematically measured. Second, regarding tool organization, many settings primarily evaluate the scale or diversity of tool collections rather than the construction of a scenario-closed toolbox. They often overlook the agent's ability to distill capabilities into a cohesive, maintainable toolset that covers key sub-processes of a specific real-world scenario (e.g., [Yuan et al., 2024;](#page-10-2) [Wang et al., 2024c;](#page-10-6) [Zhao et al., 2025;](#page-10-7) [Huang et al., 2025;](#page-8-6) [Qian et al., 2024\)](#page-9-9). Third, and most critically, evaluation signals are often outcome-centric, creating a "black box" dilemma. Benchmarks frequently rely on final answers or coarse call-level checks. Even when unit tests are used, their coverage and attribution granularity vary widely. This makes it difficult to disentangle whether a failure stems from defective tool construction (e.g., invalid schemas, logic bugs) or suboptimal tool utilization strategies, obscuring the specific stage where the error occurred (e.g., [Zhang et al.,](#page-10-8) [2025b;](#page-10-8) [Wölflein et al., 2025;](#page-10-3) [Guo et al., 2024;](#page-8-2) [Anonymous,](#page-8-7) [2024;](#page-8-7) [Lu et al., 2024\)](#page-9-10).
+To address these deployment-facing gaps, we introduce Tool-Genesis, a diagnostic benchmark designed to decouple tool generation from tool utilization. Unlike spec-first settings, Tool-Genesis evaluates agents under missing or underspecified interfaces, requiring them to infer contracts from abstract requirements, generate machine-checkable schemas, and produce executable implementations that satisfy criteria for reuse and maintenance. Crucially, our protocol serves as a diagnostic probe: it reveals that even state-ofthe-art models struggle to construct precise tool interfaces
+or logic in a one-shot setting. These minor initial flaws are amplified through the pipeline, leading to precipitous drops in downstream metrics. By shifting the target from one-off scripts to reusable tool assets, Tool-Genesis evaluates whether agents can continuously distill capabilities to cover a scenario's task distribution. Finally, we provide a unified, full-lifecycle evaluation protocol that jointly measures compliance, server executability, schema consistency, and functional validation (via explicit negative/boundary tests). We also introduce an oracle-normalized upper bound to quantify the utility gap between generated tool assets and reference tools.
+- Benchmark setting. We formalize a requirement-driven tool-creation setting that elevates toolsets as reusable assets. It evaluates creation under missing specifications, focusing on the agent's ability to infer schemas and implement executable logic from abstract requirements.
+- Diagnostic evaluation protocol. We provide a fulllifecycle, execution-grounded protocol designed to disentangle failure causes. By incorporating multi-level signals—including compliance, schema fidelity, and explicit negative/boundary unit tests—we enable precise attribution of errors to either tool quality or usage strategy, addressing the "black box" issue.
+- Oracle-normalized utility gap. We introduce an oraclenormalized upper-bound comparison to quantify the utility gap between generated tool assets and reference tools under the same task distribution, providing a clearer measure of practical self-evolution capability.
+# 2. Problem Formalization
+### 2.1. Task Definition
+We formalize TOOL GENESIS as a conditional generation problem over Model Context Protocol (MCP) interfaces. Let X denote the natural-language task description, S the space of valid MCP interface schemas, and E the space of
+{2}------------------------------------------------
+<span id="page-2-1"></span>![](_page_2_Figure_1.jpeg)
+*Figure 2.* Dataset construction pipeline of TOOL GENESIS.
+executable server implementations. An MCP schema s ∈ S is represented as an ordered list of atomic tool definitions, s = [t1, . . . , tK], where each tool t<sup>k</sup> = ⟨ηk, ϕk, δk⟩ consists of a unique invocation identifier ηk, a parameter interface ϕ<sup>k</sup> specified by a JSON-schema-like typed signature with constraints, and a natural-language description δ<sup>k</sup> grounding its intended semantics and usage.
+We decompose the tool creation process into two coupled prediction phases: Tool Interface Prediction and Tool Materialization. Formally, the joint probability of producing a schema s and an implementation e given requirement x is factorized as:
+$$P_{\theta}(s, e \mid x) = \underbrace{P_{\theta}(s \mid x)}_{\text{Interface Prediction}} \cdot \underbrace{P_{\theta}(e \mid s)}_{\text{Materialization}}. \tag{1}$$
+In the first phase, the model predicts an interface schema sˆ = arg maxs∈S Pθ(s | x), specifying the structured tool signatures. In the second phase, conditioned on a schema scond, the model materializes an executable server implementation via eˆ = arg maxe∈E Pθ(e | scond). We evaluate this materialization under two settings: *Oracle Materialization*, where scond = s ∗ (ground truth) to isolate engineering capability, and *Cascaded Materialization*, where scond = ˆs (predicted schema) to assess end-to-end performance.
+### <span id="page-2-2"></span>2.2. Metrics
+> We evaluate tool creation with a four-level metric suite (Appendix [A\)](#page-11-0): (i) Level 1 (Surface Compliance) reports Compliance Rate and Server Execution Rate. Compliance Rate measures whether list\_tools returns a parseable, MCPcompliant registry, while Server Execution Rate measures whether the server launches and remains responsive under fixed timeouts. (ii) Level 2 (Semantic Interface Fidelity)
+reports Schema-F1, quantifying schema-level fidelity by aligning predicted and reference tools via bipartite matching and computing an F1 score over tool interfaces. (iii) Level 3 (Functional Correctness) reports UTsoft and UThard, which measure the fraction of tools passing predefined Unit Tests under relaxed and strict (boundary/negative) criteria, respectively. (iv) Level 4 (Downstream Task Utility) assesses the end-to-end practical efficacy by employing a fixed proxy agent (qwen3-14b-instruct) to solve benchmark tasks equipped with the generated tools. To rigorously isolate tool quality from solver capability, we conduct a parallel control experiment using ground-truth reference tools, with all final outcomes evaluated by an LLM-as-a-Judge. This comparative setup allows us to report an Oracle-Normalized Success Rate (SR), which quantifies the utility of the synthesized tools relative to the upper-bound performance achieved by the optimal reference implementation under the same experimental conditions.
+# 3. Dataset Construction
+This section describes the dataset construction pipeline of TOOL GENESIS. It covers *Compliant MCP-server Data Collection* ([§3.1\)](#page-2-0), *High-Quality Task & Trajectory Generation* ([§3.2\)](#page-3-0), *Comprehensive Unit Test Generation* ([§3.3\)](#page-3-1), and *Manual Quality Inspection* ([§3.4\)](#page-3-2). The overall procedure is illustrated in Figure [2.](#page-2-1) Detailed prompts, rubrics, thresholds, and implementation specifics are provided in Appendix [B.](#page-12-0)
+### <span id="page-2-0"></span>3.1. Compliant MCP-server Data Collection
+*MCP Crawling:* We collect MCP servers from web sources: (i) MCP aggregators (GLMA, Smithery), (ii) GitHub search and curated lists, and (iii) HuggingFace (e.g., Toucan) in
+{3}------------------------------------------------
+Aug–Sep 2025. We keep source links and server metadata (server\_name, description), without mirroring repositories. We obtain tool registries by launching servers and calling list\_tools, falling back to static registries/specifications when needed. Schemas are normalized using server\_name and tool\_name as server/tool IDs.
+218 219 *MCP-server Filtering.* We apply a four-stage filtering pipeline to construct a high-quality MCP-server dataset. (i) Structure Validation enforces that each server exposes a parseable tool registry with well-formed tool names, descriptions, and input schemas. (ii) Executable Validation removes servers that cannot be reliably launched or invoked in a sandboxed environment. (iii) Deduplication & Clustering reduces redundancy by grouping servers with similar schema-level interfaces and retaining a single representative per group. (iv) LLM Semantic Validation filters servers that require external credentials or exhibit high sandbox requirements, ensuring safe and self-contained execution. The remaining servers form the MCP-server Dataset Dsrv (86 servers).
+### <span id="page-3-0"></span>3.2. High-Quality Task & Trajectory Generation
+*Task generation and filtering.* We follow a Toucan-style LLM-driven pipeline [\(Xu et al., 2025\)](#page-10-9) to synthesize tasks. For each server, an LLM is prompted with tool schemas (and docs, if any) to generate tasks, expanded along breadth (distinct scenarios and tool subsets) and depth (multi-step tasks with more tool calls).To ensure high data diversity, we further employ a rejection sampling strategy that penalizes redundant tool combinations, forcing the LLM to explore edge cases and rare parameter configurations. An LLM-as-judge scores candidates on a fixed 1–5 Likert rubric (quality, realism, verifiability, stability) and assesses *solvability*; we retain only tasks with all dimensions > 3 and solvable=true.
+*Trajectory generation and filtering.* For each retained task, we generate execution trajectories by running an agent in a sandbox(to support servers requiring network access).This sandbox execution ensures that each trajectory is grounded in real-time tool feedback, allowing us to filter out "hallucinated" successful executions that do not reflect actual API behaviors. We apply lightweight rule-based checks (parseable calls, valid responses) and employ LLM-as-ajudge to verify consistency and *completion* and penalize redundancy; we retain trajectories with completion and conciseness > 3 and complete=true, with solvability and completion judged by the LLM.
+### <span id="page-3-1"></span>3.3. Comprehensive Unit Test Generation
+*Unit test generation.* We extract unit tests from Dtraj by converting replayable tool-call steps (executable in the sandbox) into a unified format (tool\_name, inputs, expected
+<span id="page-3-3"></span>![](_page_3_Figure_8.jpeg)
+*Figure 3.* Comparison of benchmarks in terms of task reasoning depth and tool compositionality.
+outputs), retaining up to 100 tests per server for coverage. When extraction provides insufficient coverage for a tool, we synthesize additional tests with an LLM conditioned on the tool schema, targeting diverse valid calls.
+*Unit test filtering.* We apply two post-filters for quality and deduplication. (i) Parameter-based filtering removes tests with invalid inputs, type errors, or disallowed dependencies. (ii) We cluster tests per tool to merge near-duplicates and keep representatives, embedding normalized (input, output) pairs and merging those with cosine similarity ≥ 0.9.
+### <span id="page-3-2"></span>3.4. Manual Quality Inspection
+*Manual Annotation:* (i) MCP-server Data Consistency Check—verify schema/version consistency, stable unique IDs, split integrity, and formatting rules; (ii) Task Tool Functionality Match—confirm that referenced tools exist in the registry, required arguments are schema-compatible, and the task intent aligns with documented tool functionality; (iii) Trajectory Validity Check—ensure trajectories satisfy task constraints with coherent ordering, contain no malformed tool calls, and have no forbidden dependencies; (iv) Unit Test Coverage Check—check that tests cover diverse tools and parameter regimes, meet per-server coverage targets, and avoid redundancy.
+*Manual Review.* All instances are manually re-checked by *graduate-level* reviewers (3 annotators over two weeks) in multiple passes. Reviewers conduct both *instance-level* inspection (task statement, referenced tools, trajectories, and unit tests) and *cross-file* consistency checks (registry ↔ task ↔ trajectory ↔ tests), correcting minor issues when possible and removing samples that violate any requirement. In particular, they (a) verify that each task is solvable using only the declared toolset and does not rely on hidden assumptions; (b) validate that every tool call conforms to the declared schema (argument names/types, required fields, and return usage); (c) check that trajectories are coherent and free of malformed calls, missing steps, or forbidden ex-
+{4}------------------------------------------------
+<span id="page-4-0"></span>
+| Foundation &<br>Core Tech | Data Intelligence &<br>Automation | Productivity &<br>Workflow | Creative & Digital<br>Life | Services &<br>Emerging Fields | General & Others |
+|----------------------------------------------------------|---------------------------------------------|--------------------------------------------------------|----------------------------------------------|----------------------------------------------------|------------------------------------------------------|
+| Operating<br>System<br>Core software<br>platform | AI/ML Tools<br>Intelligent<br>algorithms | Daily<br>Productivity<br>Task<br>management | Content<br>Creation<br>Media<br>generation | Financial<br>Services<br>Banking &<br>finance | Web Search<br>& Research<br>Information<br>retrieval |
+| Memory<br>Management<br>System resource<br>optimization | Data Analysis<br>Insights from data | Time &<br>Calendar<br>Scheduling &<br>planning | Social Media<br>Networking<br>platforms | Health &<br>Fitness<br>Wellness tracking | Education<br>Learning<br>resources |
+| Database<br>Operations<br>Data storage &<br>management | Browser<br>Automation<br>Web task scripting | Communication<br>Tools<br>Messaging &<br>collaboration | Gaming<br>Interactive<br>entertainment | Travel &<br>Maps<br>Navigation & trips | Weather<br>Forecast services |
+| Security &<br>Authentication<br>Protection &<br>identity | Development<br>Tools<br>Software building | File<br>Management<br>Organization &<br>storage | API<br>Integration<br>Connecting<br>services | Crypto &<br>Blockchain<br>Decentralized<br>finance | Others<br>Miscellaneous<br>categories |
+| Statistic | Number |
+|---------------------------|--------|
+| MCP-servers | 86 |
+| Total Tools | 508 |
+| Domain classes | 24 |
+| Label classes | 18 |
+| Unit test | 9441 |
+| Total tasks | 2150 |
+| Average task length | 53 |
+| Average step length | 6 |
+| Average tool-using length | 3 |
+*Figure 4.* Overview statistics of TOOL GENESIS. Left: functional domain coverage of MCP servers across 24 domain classes. Right: dataset scale and task/trajectory structure statistics.
+ternal dependencies; and (d) inspect unit tests to ensure they include both positive and negative/boundary cases, span representative parameter regimes, and do not leak answers or duplicate existing tests. We retain an instance only when at least two annotators independently agree on accept/reject, and the inter-annotator agreement on accept/reject decisions reaches a Cohen's κ of 0.85 [\(Landis & Koch, 1977\)](#page-9-11). Finally, after edits and removals, we perform a final end-to-end recheck on the finalized dataset to ensure each retained instance meets all constraints and yields a coherent tool-use process.
+# 4. Data Analysis
+*Overall scale.* Figure [4](#page-4-0) summarizes the scale of TOOL GEN-ESIS. After filtering and manual inspection, the dataset contains 86 executable MCP servers with 508 tools, spanning 24 domain classes. We collect 2,150 tasks and 9,441 unit tests, covering 18 task label classes. These statistics provide a concise overview of the benchmark size across servers, tools, tasks, and tests.
+*Domain coverage.* The retained MCP servers span a diverse set of functional domains. The 24 domain classes are grouped into six high-level categories, covering foundational system tools, data intelligence and automation, productivity and workflow utilities, creative and digital-life applications, service-oriented domains (e.g., finance, health, travel), and general-purpose tools. The distribution includes both commonly used domains and a long tail of more specialized categories.
+*Execution structure.* We further examine the execution structure of task trajectories. Tasks have an average length of 53 tokens, while trajectories involve 6 execution steps on average and invoke 3 distinct tools per task. This indicates that many instances require sequential tool invocation rather than single-step execution. As shown in Figure [3,](#page-3-3) the
+dataset covers task structures ranging from simple singletool interactions to multi-step, multi-tool compositions.
+# 5. Experiments
+### 5.1. Experimental Setup
+Models. We evaluate a broad suite of frontier and opensource LLMs, covering closed-source families—OpenAI GPT models (gpt-4o, gpt-4.1-mini, gpt-4.1, gpt-5.1; [\(Ope](#page-9-12)[nAI, 2025\)](#page-9-12)), Anthropic Claude (claude-sonnet-4; [\(An](#page-8-8)[thropic, 2025\)](#page-8-8)), and Google Gemini (gemini-3-flash; [\(Google DeepMind, 2025\)](#page-8-9))—as well as open-source families including Qwen3 (4B/8B/14B/30B-A3B/32B/235B-A22B; [\(Yang et al., 2025\)](#page-10-10)), DeepSeek (deepseek-v3.2; [\(DeepSeek-AI et al., 2024\)](#page-8-10)), and MoonshotAI Kimi (Kimi-K2(-Instruct); [\(Kimi Team, 2025\)](#page-9-13)).
+Inference Strategy. On top of this model suite, we run a unified evaluation harness with two inference strategies: (i) Direct, which performs single-pass generation of TI and TM outputs; and (ii) Code-Agent, which wraps the same LLM in a ReAct-style agent loop [\(Yao et al., 2023\)](#page-10-0). Specifically, Code-Agent follows a "think → act (tool) → observe" procedure for up to 10 steps, and can invoke sandboxed execution tools to run and validate generated artifacts.
+Implementation Details. All models are queried through their standard chat APIs using a shared prompt template and fixed decoding settings (max tokens = 40,960, temperature = 0, top\_p = 1). For Code-Agent, sandboxed execution is performed under fixed resource limits and timeouts to support automated artifact validation and downstream task execution.
+### 5.2. Experimental Results
+Several conclusions can be drawn from TableTable [2:](#page-5-0)(i) Closed-loop repair yields consistent multi-layer gains
+{5}------------------------------------------------
+| 275 | |
+|-----|--|
+| 276 | |
+| 277 | |
+| 278 | |
+| 279 | |
+| 280 | |
+| 281 | |
+| 282 | |
+| 283 | |
+| 284 | |
+| 285 | |
+| 286 | |
+| 287 | |
+| 288 | |
+| 289 | |
+| 290 | |
+| 291 | |
+| 292 | |
+| | |
+| 293 | |
+| 294 | |
+| 295 | |
+| 296 | |
+| 297 | |
+| 298 | |
+| 299 | |
+| 300 | |
+| 301 | |
+| 302 | |
+| 303 | |
+| 304 | |
+| 305 | |
+| 306 | |
+| 307 | |
+| 308 | |
+| 309 | |
+| | |
+<span id="page-5-0"></span>
+| Model Family | Version | L1 | | L2 | L3 | | L4 | | |
+|-------------------------------------|-------------------------|--------------|--------|------------|----------|----------|-------|--|--|
+| | | Compliance ↑ | Exec.↑ | Schema-F1↑ | UTsoft ↑ | UThard ↑ | SR↑ | | |
+| Direct | | | | | | | | | |
+| | gpt-4o | 0.779 | 0.209 | 0.175 | 0.089 | 0.049 | 0.153 | | |
+| | gpt-4.1-mini | 0.686 | 0.318 | 0.293 | 0.127 | 0.088 | 0.199 | | |
+| OpenAI (OpenAI, 2025) | gpt-4.1 | 0.860 | 0.738 | 0.675 | 0.261 | 0.129 | 0.330 | | |
+| | gpt-5.1 | 0.826 | 0.759 | 0.688 | 0.281 | 0.161 | 0.372 | | |
+| Anthropic (Anthropic, 2025) | claude-haiku-3.5 | 0.744 | 0.012 | 0.012 | 0.007 | 0.000 | 0.012 | | |
+| Google (Google DeepMind, 2025) | gemini-3-flash-preview | 0.872 | 0.140 | 0.116 | 0.084 | 0.037 | 0.103 | | |
+| | 235b-a22b-instruct-2507 | 0.884 | 0.333 | 0.320 | 0.143 | 0.108 | 0.287 | | |
+| | 32b | 0.791 | 0.282 | 0.258 | 0.176 | 0.078 | 0.178 | | |
+| | 30b-a3b-instruct-2507 | 0.884 | 0.256 | 0.250 | 0.093 | 0.025 | 0.218 | | |
+| Qwen3 (Yang et al., 2025) | 14b | 0.791 | 0.186 | 0.175 | 0.154 | 0.075 | 0.128 | | |
+| | 8b | 0.686 | 0.012 | 0.011 | 0.001 | 0.001 | 0.012 | | |
+| | 4b | 0.651 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | | |
+| DeepSeek (DeepSeek-AI et al., 2024) | deepseek-v3.2 | 0.826 | 0.400 | 0.365 | 0.195 | 0.129 | 0.224 | | |
+| MoonshotAI (Kimi Team, 2025) | Kimi-K2-Instruct | 0.860 | 0.372 | 0.342 | 0.144 | 0.087 | 0.215 | | |
+| Code-Agent | | | | | | | | | |
+| | gpt-4o | 0.802 | 0.531 | 0.456 | 0.237 | 0.117 | 0.226 | | |
+| | gpt-4.1-mini | 0.651 | 0.906 | 0.640 | 0.278 | 0.144 | 0.344 | | |
+| OpenAI (OpenAI, 2025) | gpt-4.1 | 0.884 | 0.756 | 0.691 | 0.288 | 0.145 | 0.433 | | |
+| | gpt-5.1 | 0.895 | 0.941 | 0.867 | 0.421 | 0.246 | 0.604 | | |
+| Anthropic (Anthropic, 2025) | claude-haiku-3.5 | 0.733 | 0.964 | 0.821 | 0.342 | 0.180 | 0.472 | | |
+| Google (Google DeepMind, 2025) | gemini-3-flash-preview | 0.849 | 0.977 | 0.912 | 0.448 | 0.255 | 0.581 | | |
+| Qwen3 (Yang et al., 2025) | 235b-a22b-instruct-2507 | 0.686 | 0.971 | 0.722 | 0.363 | 0.212 | 0.472 | | |
+| | 32b | 0.860 | 0.892 | 0.801 | 0.317 | 0.179 | 0.495 | | |
+| | 30b-a3b-instruct-2507 | 0.744 | 0.913 | 0.694 | 0.336 | 0.187 | 0.410 | | |
+| | 14b | 0.686 | 0.807 | 0.707 | 0.316 | 0.178 | 0.453 | | |
+| | 8b | 0.767 | 0.694 | 0.646 | 0.243 | 0.121 | 0.332 | | |
+| | 4b | 0.651 | 0.326 | 0.285 | 0.127 | 0.058 | 0.181 | | |
+| DeepSeek (DeepSeek-AI et al., 2024) | deepseek-v3.2 | 0.872 | 0.744 | 0.702 | 0.330 | 0.195 | 0.449 | | |
+| MoonshotAI (Kimi Team, 2025) | Kimi-K2 | 0.872 | 0.976 | 0.898 | 0.389 | 0.235 | 0.585 | | |
+*Table 2.* Main results under two evaluation paradigms (Direct and Code-Agent) updated with the latest metrics. Metrics follow our four-level evaluation: *L1* surface compliance (Compliance, Server Execution), *L2* semantic interface fidelity (Schema-F1), *L3* functional correctness via unit tests (UTsoft, UThard), and *L4* downstream task utility (Task Success Rate, SR).
+and can produce step-changes in end-to-end utility. Across most model families, *Code-Agent* improves functional correctness and task success beyond surface executability and schema fidelity. For Gemini-3-Flash, EXEC. increases from 0.140 to 0.977, Schema-F1 from 0.116 to 0.912, and UThard from 0.129 to 0.726, resulting in a large SRsoft jump (0.103 → 0.581). A similar effect is observed for Qwen3-235B (SRsoft: 0.193 → 0.622), indicating that execution feedback is effectively translated into verifiable correctness and downstream utility.(ii) High compliance and plausible schemas are necessary but insufficient, revealing a utility-conversion bottleneck. Strong upstream signals (L1/L2) do not guarantee downstream success (L4). Under *Direct*, Qwen3-32B achieves high EXEC. (0.938) and Schema-F1 (0.880), yet SRsoft remains 0.535. Conversely, when schema fidelity degrades (e.g., gpt-4.1 under *Direct*), downstream utility collapses accordingly. These gaps suggest that failures increasingly arise from implementation robustness, boundary handling, and state discipline that are only exposed through execution.(iii) Repair benefits are scale-dependent and can reorder models within a family. Under *Code-Agent*, larger models achieve higher downstream utility (e.g., Qwen3 SRsoft: 0.336 for 4B vs. 0.622 for 235B). Notably, model rankings can flip across strategies: Qwen3-32B outperforms 235B under *Direct*, while 235B overtakes under *Code-Agent*. This indicates that closed-loop tool creation relies on an additional capability—the ability to exploit execution feedback for targeted repair—that is not captured by single-pass generation alone.
+# 6. Analysis
+Beyond aggregate success rates, we analyze tool creation along three axes that align with our lifecycle evaluation.
+{6}------------------------------------------------
+<span id="page-6-3"></span>![](_page_6_Figure_1.jpeg)
+Figure 5. Direct prompting vs. code-agent repair on Qwen3 scales: (a) Signal–Validation Alignment (SVA) of Schema-F1 and UT (soft/hard); (b) stage-wise cumulative pass-through across verification stages (Start, L1–L4) for selected scales, with solid/dashed lines denoting the two paradigms.
+(i) We measure whether intermediate verification signals are predictive of downstream trajectory validation, and how closed-loop repair changes this predictiveness across model scales (Sec. 6.1). (ii) We localize where failures concentrate along the verification cascade by reporting stage-wise cumulative pass-through from Start to L1–L4, contrasting Direct prompting with Code-Agent repair and identifying the dominant attrition stages (Sec. 6.2). (iii) We move from inference-time interventions to capability internalization via finetuning, and examine how training reshapes one-shot synthesis under Direct and patch effectiveness under Code-Agent (Sec. 6.3).
+#### <span id="page-6-0"></span>6.1. Signal-validation alignment under closed-loop
+Figure 5(a) quantifies how *indicative* verification signals are of downstream trajectory validation via a Signal–Validation Alignment (SVA) score (App. D.1). Under direct prompting, SVA remains low across scales: even at Qwen3-235B, Schema SVA is 0.19 and UT<sub>hard</sub> is 0.14, while Qwen3-8B collapses toward zero (Schema $\approx 0.01$ , UT<sub>hard</sub> $\approx 0.00$ ). Without execution feedback, interface- and verification-level metrics are weak proxies for downstream utility; with closed-loop repair, signal–validation alignment strengthens substantially. At Qwen3-235B, SVA reaches 0.58, and the improvement is stage-wise with a threshold around 8B $\rightarrow$ 14B: Schema increases from 0.32 to 0.51, and UT<sub>hard</sub> from 0.26 to 0.48.
+#### <span id="page-6-1"></span>6.2. Pass-through along the verification cascade
+Figure 5(b) reports the *cumulative pass-through* (in %) across Start and L1–L4. Under direct prompting, Qwen3-8B drops to 1.11% at L1 and $\approx 0.12\%$ by L2–L4; for Qwen3-14B/32B/235B, pass-through is 17.52/24.84/31.60% at L1 and 3.99/5.44/9.47% at L4. Closed-loop repair lifts early-stage pass-through (L1: 65.34%, 84.06%, 83.02%, 91.36% for 8B/14B/32B/235B) and improves late-stage retention
+<span id="page-6-4"></span>![](_page_6_Figure_8.jpeg)
+Figure 6. Base vs. fine-tuned performance under **Direct** and **Code-Agent** evaluation, summarized across our four-layer metric suite (L1–L4).
+(L4: 8.85%, 7.97%, 15.69%, 30.01%), vs. 0.12%, 3.99%, 5.44%, and 9.47% under direct prompting. Once early stages are stabilized, the dominant attrition concentrates at L3/L4, and scaling mainly improves late-stage retention (e.g., L4: $7.97\% \rightarrow 15.69\% \rightarrow 30.01\%$ from 14B to 32B to 235B under code-agent). Overall, repair primarily reduces early structural failures, leaving deeper validation as the bottleneck.
+### <span id="page-6-2"></span>6.3. Finetuning exploration: internalizing capability
+Prompting and inference-time repair can improve tool creation by injecting demonstrations or execution feedback, but they do not necessarily strengthen the model's intrinsic ability to synthesize reusable tool assets. We therefore finetune models on TOOL GENESIS and evaluate whether training improves both intermediate verification and downstream task success. We defer training configurations and implementation details to Appendix E.
+Finetuning on TOOL GENESIS yields consistent gains across all evaluation layers (Table 6), indicating that TOOL GEN-ESIS provides not only a diagnostic benchmark but also an effective training signal for requirement-driven tool cre
+{7}------------------------------------------------
+ation. On Qwen3-8B, under the Direct setting, finetuning improves one-shot generation at the interface and schema level: Compliance increases from 0.686 to 0.826 (+0.140), while Exec. rises from 0.012 to 0.047 (+0.035) and Schema-F1 from 0.011 to 0.046 (+0.035). These early-stage gains translate into measurable (though still small) functional validation improvements, with UTsoft increasing from 0.001 to 0.017 (+0.016) and UThard from 0.001 to 0.007 (+0.006), and downstream success SR improving from 0.012 to 0.026 (+0.014). Notably, because the Direct baseline is near-zero on executability and testing, absolute gains are more informative than relative ratios in this regime.
+Under the Code-Agent setting, finetuning strengthens closed-loop repair and improves how execution feedback is converted into downstream utility. For Qwen3-8B, Compliance increases from 0.718 to 0.906 (+0.188), Exec. from 0.694 to 0.777 (+0.083), and Schema-F1 from 0.653 to 0.736 (+0.083). Improvements also propagate to functional validation, with UTsoft increasing from 0.307 to 0.377 (+0.070) and UThard from 0.456 to 0.533 (+0.077), yielding a higher SR from 0.336 to 0.399 (+0.063). Compared to Direct, gains under Code-Agent are less concentrated at the earliest gates and more evenly reflected in UT and SR, consistent with the interpretation that finetuning improves bug localization and patch quality under a fixed repair budget.
+Overall, finetuning complements inference-time repair: it improves one-shot interface/schema synthesis under Direct, and under Code-Agent it increases the effectiveness of execution-triggered debugging, thereby raising the rate at which intermediate verification improvements translate into downstream task success.
+# 7. Related Work
+Tool-augmented LLMs are commonly evaluated by whether an agent can correctly invoke external tools and APIs to accomplish tasks [\(Karpas et al., 2022;](#page-8-0) [Yao et al., 2023;](#page-10-0) [Schick et al., 2023;](#page-9-0) [Patil et al., 2023;](#page-9-1) [Li et al., 2023;](#page-9-3) [Qin](#page-9-2) [et al., 2023a;](#page-9-2)[b;](#page-9-14) [Guo et al., 2024;](#page-8-2) [Berkeley Function Call](#page-8-3)[ing Leaderboard \(BFCL\) Team, 2024;](#page-8-3) [Wang et al., 2024a;](#page-9-4) [Huang et al., 2024;](#page-8-4) [Anonymous, 2025;](#page-8-11) [Zhang et al., 2025c;](#page-10-1) [Shen et al., 2024;](#page-9-15) [Liu et al., 2024;](#page-9-16) [Wang et al., 2024f;](#page-10-11) [Liu](#page-9-17) [et al., 2023b;](#page-9-17) [Zhang et al., 2024;](#page-10-12) [Wang et al., 2024e\)](#page-10-13). Within this broader line, early tool-creation benchmarks and systems largely treat creation as a task-scoped deliverable and score it with downstream success as a black-box signal [\(Cai et al., 2023;](#page-8-12) [Qian et al., 2023a;](#page-9-18) [Wölflein et al., 2025\)](#page-10-3); while task-relevant, such outcome-only evaluation is diagnostically weak because failures conflate requirement misunderstanding, interface/spec errors, implementation bugs, and unsafe or incorrect usage policies. To reduce hallucinated specifications and better reflect real constraints, later
+work increasingly grounds creation in external references (API docs/specs/repos/knowledge bases) and adds contractfaithfulness signals (e.g., schema/parameter consistency) as intermediate checks, often still reported alongside end-task outcomes [\(Liu et al., 2025;](#page-9-19) [Zhao et al., 2025;](#page-10-7) [Qian et al.,](#page-9-9) [2024;](#page-9-9) [Wang et al., 2024d\)](#page-10-14). As evaluation moves closer to "real execution," a complementary trend adopts executable and test-driven verification to obtain reproducible correctness signals and clearer attribution [\(Zhang et al., 2025b;](#page-10-8) [Wölflein et al., 2025;](#page-10-3) [Jimenez et al., 2023;](#page-8-13) [Chen et al., 2021;](#page-8-14) [Austin et al., 2021;](#page-8-15) [Hendrycks et al., 2021;](#page-8-16) [Liu et al., 2023a;](#page-9-20) [Zhuo et al., 2024\)](#page-10-15); here, a stable execution environment and robust negative/boundary testing become essential to avoid flaky outcomes, prevent accidental overfitting to shallow success cases, and enable regression checking under tool evolution. More recently, tool creation is increasingly framed as building reusable toolsets/toolboxes that support retrieval, composition, maintenance, and updates across a task distribution—often serving knowledge access rather than a single one-off objective [\(Yuan et al., 2024;](#page-10-2) [Wang](#page-10-6) [et al., 2024c;](#page-10-6) [Zhao et al., 2025;](#page-10-7) [Huang et al., 2025;](#page-8-6) [Qian](#page-9-9) [et al., 2024\)](#page-9-9). Despite these advances, existing benchmarks remain fragmented: some emphasize task outcomes, others emphasize interface faithfulness or passing tests, and toolsetlevel reuse/maintenance is rarely evaluated together with executable correctness (including invalid/boundary cases) and downstream utility in a unified, reproducible protocol; in particular, oracle-normalized comparisons that quantify the utility gap between generated tools and ground-truth tools are still under-explored, motivating our benchmark and evaluation design.
+# 8. Conclusion
+We present Tool-Genesis, a diagnostic benchmark for evaluating tool creation as a first-class capability of self-evolving language agents. Tool-Genesis departs from spec-first settings by requiring agents to infer tool contracts from abstract requirements, generate machine-checkable schemas, and implement executable logic that can be reused as a scenarioclosed toolset. To avoid outcome-only "black box" evaluation, we introduce a full-lifecycle protocol that jointly measures interface compliance, executability, schema fidelity, and functional correctness with explicit negative/boundary unit tests, and we further report an oracle-normalized upper bound to quantify the utility gap between generated and reference tools under the same task distribution.Our empirical findings highlight a key bottleneck: even strong models often fail to produce precise interfaces or correct implementations in a one-shot setting, and these small early-stage defects are amplified through the downstream pipeline. We hope Tool-Genesis will help the community move beyond ad-hoc, disposable tool use toward *persistent* and *maintainable* tool assets, and enable more targeted progress on tool
+{8}------------------------------------------------
+induction, repair, and verification in realistic deployments.
+# Impact Statement
+"This paper presents work whose goal is to advance the field of Machine Learning. There are many potential societal consequences of our work, none which we feel must be specifically highlighted here."
+The above statement can be used verbatim in such cases, but we encourage authors to think about whether there is content which does warrant further discussion, as this statement will be apparent if the paper is later flagged for ethics review.
+# References
+- <span id="page-8-1"></span>Anonymous. Toolbench: Benchmarking large language models for tool manipulation. arXiv preprint, 2023. Replace with official BibTeX (arXiv / official page).
+- <span id="page-8-7"></span>Anonymous. SWE-bench: Can language models resolve real-world github issues? arXiv preprint, 2024. Replace with official BibTeX (arXiv / official page).
+- <span id="page-8-11"></span>Anonymous. Toolhop: A query-driven benchmark for multihop tool use, 2025. URL [ [02506](
+- <span id="page-8-8"></span>Anthropic. Claude opus 4 & claude sonnet 4: System card, July 2025. URL [ [claude-4-system-card]( System card (PDF). Accessed: 2026-01-22.
+- <span id="page-8-15"></span>Austin, J., Odena, A., Nye, M., Bosma, M., Michalewski, H., Dohan, D., Jiang, E., Cai, C., Terry, M., et al. Program synthesis with large language models, 2021. URL < Introduces MBPP (Mostly Basic Python Problems).
+- <span id="page-8-12"></span>Cai, T., Wang, Z., Chen, Y., Ma, R., Li, Z., Zhu, L., Chen, W., Jiang, Y., Sun, M., and Liu, Z. Large language models as tool makers, 2023. URL [ [2305.17126](
+- <span id="page-8-5"></span>Cai, Z., Liu, Y., Zhang, W., and Wang, Y. Latm: A benchmark for latent tool creation. *Proceedings of the 2024 International Conference on Machine Learning (ICML)*, pp. 234–245, 2024.
+- <span id="page-8-14"></span>Chen, M., Tworek, J., Jun, H., Yuan, Q., Pinto, H. P. d. O., Kaplan, J., Edwards, H., et al. Evaluating large language models trained on code, 2021. URL [ [abs/2107.03374](
+- <span id="page-8-10"></span>DeepSeek-AI et al. Deepseek-v3 technical report, 2024. URL <
+- <span id="page-8-9"></span>Google DeepMind. Gemini 3 flash: Model card, December 2025. URL [ [googleapis.com/deepmind-media/Model-Cards/]( [Gemini-3-Flash-Model-Card.pdf]( Model card (PDF). Accessed: 2026-01-22.
+- <span id="page-8-2"></span>Guo, Z., Cheng, S., Wang, H., Liang, S., Qin, Y., Li, P., Liu, Z., Sun, M., and Liu, Y. StableToolBench: Towards stable large-scale benchmarking on tool learning of large language models, 2024. URL [ [2403.07714](
+- <span id="page-8-16"></span>Hendrycks, D., Basart, S., Kadavath, S., Mazeika, M., Arora, A., Guo, E., Burns, C., Puranik, S., He, H., Song, D., and Steinhardt, J. Measuring coding challenge competence with apps, 2021. URL [ [09938](
+- <span id="page-8-4"></span>Huang, S., Zhong, W., Lu, J., Zhu, Q., Gao, J., Liu, W., Hou, Y., Zeng, X., Wang, Y., Shang, L., Jiang, X., Xu, R., and Liu, Q. Planning, creation, usage: Benchmarking llms for comprehensive tool utilization in real-world complex scenarios, 2024. URL [ [17167](
+- <span id="page-8-6"></span>Huang, W., Zhuang, S., Wang, H., Guo, Z., Liu, Z., Sun, M., and Liu, Y. Toollibgen: Automated tool library generation with large language models, 2025. URL [ [org/abs/2505.16956](
+- <span id="page-8-13"></span>Jimenez, C. E., Yang, J., Wettig, A., Yao, S., Pei, K., Press, O., and Narasimhan, K. SWE-bench: Can language models resolve real-world github issues?, 2023. URL <
+- <span id="page-8-0"></span>Karpas, E., Shuster, K., Geva, M., Schick, T., Gupta, R., Eisenstein, J., and Berant, J. MRKL systems: A modular, neuro-symbolic architecture that combines large language models, external knowledge sources and discrete reasoning, 2022. URL <
+{9}------------------------------------------------
+<span id="page-9-13"></span>495 496 Kimi Team. Kimi k2: Open agentic intelligence, 2025. URL <
+<span id="page-9-17"></span>513 514
+<span id="page-9-19"></span>516
+<span id="page-9-10"></span>524 525 526
+<span id="page-9-12"></span>528 529 530
+<span id="page-9-1"></span>534
+- <span id="page-9-11"></span>Landis, J. R. and Koch, G. G. The measurement of observer agreement for categorical data. *Biometrics*, 33(1):159– 174, 1977.
+- Langley, P. Crafting papers on machine learning. In Langley, P. (ed.), *Proceedings of the 17th International Conference on Machine Learning (ICML 2000)*, pp. 1207–1216, Stanford, CA, 2000. Morgan Kaufmann.
+- <span id="page-9-3"></span>Li, Z., Huang, Q., Xu, H., Zhang, Z., Wang, J., and Li, J. API-Bank: A benchmark for tool-augmented LLMs, 2023. URL <
+- <span id="page-9-20"></span>Liu, J., Xia, C., Zhang, L., et al. Is your code generated by chatgpt really correct? rigorous evaluation of large language models for code generation, 2023a. URL [https:]( [//arxiv.org/abs/2305.01210](
+- Liu, T. et al. Agentbench: Evaluating llms as agents, 2023b. URL <
+- Liu, X., Yin, D., Wu, Z., and Feng, Y. Reftool: Enhancing model reasoning with reference-guided tool creation, 2025. URL <
+- <span id="page-9-16"></span>Liu, X. et al. τ -bench: A benchmark for tool-agent user interaction in real-world scenarios, 2024. URL [https:]( [//arxiv.org/abs/2406.12045](
+- Lu, Y., Li, Z., Li, G., Ding, B., Wang, J., Liu, X., and Zhang, R. Toolsandbox: A state-of-the-art evaluation framework for tool-use robustness in large language models. *arXiv preprint arXiv:2408.04684*, 2024.
+- OpenAI. Update to GPT-5 system card: GPT-5.2, December 2025. URL [ [3a4153c8-c748-4b71-8e31-aecbde944f8d/oai\\_5\\_2\\_]( [system-card.pdf]( System card (PDF). Accessed: 2026-01-22.
+- Patil, S., Zhang, T., Wang, X., and Gonzalez, J. E. Gorilla: Large language model connected with massive APIs, 2023. URL <
+- <span id="page-9-18"></span>Qian, C., Han, C., Fung, Y., Qin, Y., Liu, Z., and Ji, H. CREATOR: Tool creation for disentangling abstract and concrete reasoning of large language models. In *Findings of the Association for Computational Linguistics: EMNLP 2023*, pp. 6922–6939, Singapore, December 2023a. Association for Computational Linguistics. doi: 10.18653/v1/2023.findings-emnlp.462. URL [https:]( [//aclanthology.org/2023.findings-emnlp.462/](
+- <span id="page-9-9"></span>Qian, C., Xiong, C., Liu, Z., and Liu, Z. Toolink: Linking toolkit creation and using through chain-of-solving on
+- open-source model. In *Proceedings of the 2024 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers)*, pp. 831–854, Mexico City, Mexico, June 2024. Association for Computational Linguistics. doi: 10.18653/v1/2024.naacl-long.48. URL <
+- <span id="page-9-7"></span>Qian, X., Zhang, Y., Li, Z., and Wang, L. Creator: A benchmark for tool creation and execution. *Journal of Artificial Intelligence Research*, 69:1–23, 2023b.
+- <span id="page-9-2"></span>Qin, Y., Liang, S., Ye, Y., Zhu, K., Yan, L., Lu, Y., Lin, Y., Cong, X., Tang, X., Qian, B., Zhao, S., Hong, L., Tian, R., Xie, R., Zhou, J., Gerstein, M., Li, D., Liu, Z., and Sun, M. ToolLLM: Facilitating large language models to master 16000+ real-world APIs, 2023a. URL <
+- <span id="page-9-14"></span>Qin, Y., Liang, S., Ye, Y., Zhu, K., Yan, L., Lu, Y., Lin, Y., Cong, X., Tang, X., et al. Toolbench: Towards benchmarking large language models on tool use, 2023b. URL <
+- <span id="page-9-0"></span>Schick, T., Dwivedi-Yu, J., Dessì, R., Raileanu, R., Lombrozo, T., Zettlemoyer, L., Cancedda, N., and Scialom, T. Toolformer: Language models can teach themselves to use tools, 2023. URL [ [04761](
+- <span id="page-9-15"></span>Shen, H., Li, Y., et al. Shortcutsbench: A large-scale realworld benchmark for api-based agents, 2024. URL [https:]( [//arxiv.org/abs/2407.00132](
+- <span id="page-9-5"></span>Shi, Z., Gao, S., Yan, L., Feng, Y., Chen, X., Chen, Z., Yin, D., Verberne, S., and Ren, Z. Tool learning in the wild: Empowering language models as automatic tool agents. *arXiv preprint arXiv:2405.16533*, 2024.
+- <span id="page-9-8"></span>Tan, W., Ding, Z., Zhang, W., Li, B., Zhou, B., Yue, J., et al. Cradle: Empowering foundation agents towards general computer control. *arXiv preprint arXiv:2403.03186*, 2024.
+- <span id="page-9-4"></span>Wang, H., Wang, R., Xue, B., Xia, H., Cao, J., Liu, Z., Pan, J. Z., and Wong, K.-F. AppBench: Planning of multiple APIs from various APPs for complex user instruction. In Al-Onaizan, Y., Bansal, M., and Chen, Y.-N. (eds.), *Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing*, pp. 15322–15336, Miami, Florida, USA, November 2024a. Association for Computational Linguistics. doi: 10.18653/v1/2024.emnlp-main.856. URL [https:]( [//aclanthology.org/2024.emnlp-main.856/](
+- <span id="page-9-6"></span>Wang, X., Chen, Y., Yuan, L., Zhang, Y., Li, Y., Peng, H., and Ji, H. Executable code actions elicit better llm agents.
+{10}------------------------------------------------
+550 In *Forty-first International Conference on Machine Learning (ICML)*, 2024b.
+<span id="page-10-14"></span>556
+<span id="page-10-9"></span>576
+<span id="page-10-4"></span>594
+- <span id="page-10-6"></span>Wang, Y., Zhang, Y., Liu, H., and Zhang, Y. Trove: A verifiable and efficient framework for toolset creation, 2024c. URL <
+- Wang, Y. et al. APIGen: Automated pipeline for API function calling data generation, 2024d. URL [https:]( [//arxiv.org/abs/2409.01406](
+- <span id="page-10-13"></span>Wang, Y. et al. Sciagent: Tool-augmented language models for scientific reasoning, 2024e. URL [ [org/abs/2402.11451](
+- <span id="page-10-11"></span>Wang, Z. et al. Wtu-eval: A unified evaluation framework for tool use, 2024f. URL [ [12823](
+- <span id="page-10-3"></span>Wölflein, G., Schneider, J., and Krenn, M. Llm agents making agent tools, 2025. URL [ [2502.11705]( Introduces TM-BENCH and the ToolMaker framework.
+- <span id="page-10-5"></span>Wu, Z., Han, C., Ding, Z., Weng, Z., Liu, Z., Yao, S., Yu, T., and Kong, L. Os-copilot: Towards generalist computer agents with self-improvement. *arXiv preprint arXiv:2402.07456*, 2024.
+- Xu, Z., Meza Soria, A., Tan, S., Roy, A., Agrawal, A. S., Poovendran, R., and Panda, R. Toucan: Synthesizing 1.5m tool-agentic data from real-world mcp environments, 2025. URL <
+- <span id="page-10-10"></span>Yang, A. et al. Qwen3 technical report, 2025. URL [https:]( [//arxiv.org/abs/2505.09388](
+- <span id="page-10-0"></span>Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., and Cao, Y. React: Synergizing reasoning and acting in language models. In *International Conference on Learning Representations (ICLR)*, 2023. URL <
+- <span id="page-10-2"></span>Yuan, S., Chen, Y., Chen, Y., Chen, J., and Liu, Z. CRAFT: Customizing LLMs by creating and retrieving from specialized toolsets, 2024. URL [ [2401.04052](
+- Zhang, Y., Liu, H., Huang, T., and Chen, Q. Scievo: A benchmark for scientific evolution of tools. *arXiv preprint arXiv:2601.07641*, 2025a.
+- <span id="page-10-12"></span>Zhang, Y. et al. Scienceagentbench: Benchmarking language agents for scientific problem solving, 2024. URL <
+- <span id="page-10-8"></span>Zhang, Z., Liu, H., Chen, Y., Li, Z., Wang, J., and Li, J. Toolcoder: A holistic benchmark for tool creation, 2025b. URL <
+- <span id="page-10-7"></span>Zhao, C., Wang, Z., Li, J., Li, P., Zhang, J., Zhu, Q., Wang, J., Yuan, Y., Gao, Q., and Li, J. Knowledge-grounded tool creation with evolution, 2025. URL [ [org/abs/2501.06914](
+- <span id="page-10-15"></span>Zhuo, T. Y. et al. Bigcodebench: Benchmarking code generation with diverse function calls and complex instructions, 2024. URL <
+{11}------------------------------------------------
+### <span id="page-11-0"></span>A. Evaluation Methodology Details
+We provide mathematical formulations and implementation details for the metrics in Section 2.2. We evaluate N generated MCP-server implementations $\{\hat{e}_i\}_{i=1}^N$ . Each server is expected to expose a list\_tools endpoint returning a tool registry (a list of tool schemas).
+#### A.1. Layer 1: Surface Compliance and Server Execution
+Compliance (OpenAI tool-calling format). We treat compliance as a strict format check: whether the returned tool registry is parseable and satisfies the OpenAI tool-calling specification. Let $\mathcal{V}_{OpenAI}$ denote the corresponding JSON Schema validator, and let parse(·) return a parsed JSON object if successful (otherwise $\bot$ ). We define the per-instance compliance indicator:
+$$compliant(\hat{e}_i) = \mathbb{I}[parse(list\_tools(\hat{e}_i)) \neq \bot \land parse(list\_tools(\hat{e}_i)) \models \mathcal{V}_{OpenAI}], \tag{2}$$
+and report the dataset-level score:
+Compliance =
+$$\frac{1}{N} \sum_{i=1}^{N} \text{compliant}(\hat{e}_i)$$
+. (3)
+Server execution (3 independent launches). We attempt to start each server R=3 times under fixed timeouts. Let $\operatorname{run}(\hat{e}_i,r)\in\{0,1\}$ indicate whether the r-th launch succeeds and the server remains responsive (e.g., responds to list\_tools) within the timeout. We define the per-instance execution score:
+$$\operatorname{exec}(\hat{e}_i) = \frac{1}{R} \sum_{r=1}^{R} \operatorname{run}(\hat{e}_i, r), \qquad R = 3,$$
+(4)
+and report the dataset-level score:
+ServerExecution =
+$$\frac{1}{N} \sum_{i=1}^{N} \operatorname{exec}(\hat{e}_i)$$
+. (5)
+#### A.2. Layer 2: Semantic Interface Fidelity (Schema-F1)
+Layer 2 evaluates whether the predicted *tool interfaces* match the reference interfaces, independent of code execution. For instance i, let $\hat{s}_i$ be the predicted tool set and $s_i^*$ the reference tool set. Each tool schema is represented as $t = \langle \eta, \phi \rangle$ , where $\eta$ is function\_name and $\phi$ is the JSON-schema-like argument definition.
+Embedding-based similarity on function\_name + args. We define a canonical serialization $g(t) = \eta \oplus \operatorname{canon}(\phi)$ , where $\oplus$ denotes concatenation and $\operatorname{canon}(\cdot)$ produces a deterministic string form (e.g., JSON dump with sorted keys). We embed g(t) using sentence-transformers/all-MiniLM-L6-v2, denoted by $\mathbf{E}(\cdot)$ , and define cosine similarity:
+$$w(u,v) = \cos(\mathbf{E}(g(u)), \mathbf{E}(g(v))). \tag{6}$$
+**Maximum-weight matching and F1.** We construct a bipartite graph between $\hat{s}_i$ and $s_i^*$ with edge weights $w(\cdot,\cdot)$ , and compute a maximum-weight matching $M_i$ . A matched pair is counted as correct if $w(u,v) \geq \tau$ for a fixed threshold $\tau$ . Let $m_i = |\{(u,v) \in M_i : w(u,v) \geq \tau\}|$ . Then
+$$P_i = \frac{m_i}{|\hat{s}_i|}, \qquad R_i = \frac{m_i}{|s_i^*|}, \qquad \text{SchemaF1}_i = \frac{2P_i R_i}{P_i + R_i + \epsilon}, \tag{7}$$
+where $\epsilon$ is a small constant for numerical stability, and we report:
+$$SchemaF1 = \frac{1}{N} \sum_{i=1}^{N} SchemaF1_{i}.$$
+(8)
+**Note.** Schema-F1 compares *tool interfaces* (names and argument schemas), and is distinct from the *structured score* in Layer 3, which compares *tool outputs* via key-path overlap.
+{12}------------------------------------------------
+### A.3. Layer 3: Functional Correctness via Unit Tests (UT)
+(i) Structured score (JSON key-path overlap). We consider the common case where y ∗ is JSON (or parseable as JSON). Let parse(·) parse JSON successfully or return ⊥. If parse(ˆy) = ⊥, we set the structured score to 0. Otherwise, we extract a set of key-path strings from a JSON object, denoted by paths(·) (e.g., a.b[0].c). Define
+$$P_{\text{path}} = \frac{|\text{paths}(\hat{y}) \cap \text{paths}(y^*)|}{|\text{paths}(\hat{y})| + \epsilon}, \qquad R_{\text{path}} = \frac{|\text{paths}(\hat{y}) \cap \text{paths}(y^*)|}{|\text{paths}(y^*)| + \epsilon}, \tag{9}$$
+and the structured score (F1 over key paths):
+$$struct(\hat{y}, y^*) = \frac{2P_{path}R_{path}}{P_{path} + R_{path} + \epsilon}.$$
+(10)
+(ii) Embedding similarity of outputs. We canonicalize outputs via canon(·) (stable JSON dump if parseable; otherwise raw text), embed using sentence-transformers/all-MiniLM-L6-v2 (denoted by E(·)), and compute:
+$$\operatorname{emb}(\hat{y}, y^*) = \max \Big( 0, \cos \left( \mathbf{E}(\operatorname{canon}(\hat{y})), \mathbf{E}(\operatorname{canon}(y^*)) \right) \Big). \tag{11}$$
+UT score (equal-weight combination). For a single test case:
+$$UT(\hat{y}, y^*) = \frac{1}{2} struct(\hat{y}, y^*) + \frac{1}{2} emb(\hat{y}, y^*).$$
+(12)
+Aggregating across tests (standard vs. boundary). Let T std be the set of standard (positive) tests and T bnd include additional boundary/negative tests. For S ∈ {std, bnd}, we report:
+$$UT_{S} = \frac{1}{|\mathcal{T}^{S}|} \sum_{\langle \eta, \mathbf{x}, y^{*} \rangle \in \mathcal{T}^{S}} UT(\hat{y}(\eta, \mathbf{x}), y^{*}).$$
+(13)
+### A.4. Layer 4: Downstream Task Utility (Oracle-normalized SR)
+To evaluate end-to-end utility, we run a fixed agent based on Qwen3-14B on benchmark trajectories under two tool environments: (i) the generated MCP server eˆ and (ii) the ground-truth MCP server e ∗ . For each task instance j, an LLM judge produces two scores in [0, 1]:
+$$s_j^{\text{gen}} = \mathcal{J}(\text{trajectory produced with } \hat{e}), \qquad s_j^{\text{gt}} = \mathcal{J}(\text{trajectory produced with } e^*).$$
+(14)
+We compute the per-task oracle-normalized score:
+$$SR_j = \frac{1 - s_j^{\text{gt}}}{1 - s_j^{\text{gen}} + \epsilon},\tag{15}$$
+and report the dataset-level score:
+$$SR = \frac{1}{|\mathcal{D}_{task}|} \sum_{j \in \mathcal{D}_{task}} SR_j.$$
+(16)
+# <span id="page-12-0"></span>B. More Dataset Construction Details
+This appendix provides implementation details for the four-stage construction pipeline in Figure [2,](#page-2-1) including crawling, schema standardization, executable validation, clustering/deduplication, LLM-as-judge rubrics, task/trajectory generation filters, unit-test synthesis, and final release policies.
+{13}------------------------------------------------
+<span id="page-13-0"></span>![](_page_13_Figure_1.jpeg)
+*Figure 7.* Data flow and attrition in MCP-server collection. Sankey diagram summarizing the sequential filtering stages for constructing Dsrv, reporting the number of servers retained (and discarded) at each stage. *Placeholder: will be replaced by the final figure.*
+### B.1. Examples
+### Example 1: MCP-server schema instance (Dsrv).
+```
+{
+"metadata": {
+"server_name": "Airbnb Search and Listing Details Server",
+"mode": "smithery",
+"timestamp": 1751938055,
+"remote_server_response": {
+"url": "
+"is_success": true,
+"error": null,
+"tools": [
+{
+"name": "airbnb_search",
+"description": "Search for Airbnb listings with various filters and pagination. Provide direct links
+,→ to the user",
+"input_schema": {
+"type": "object",
+"properties": {
+"location": {
+"type": "string",
+"description": "Location to search for (city, state, etc.)"
+},
+"placeId": {
+"type": "string",
+"description": "Google Maps Place ID (overrides the location parameter)"
+},
+"checkin": {
+"type": "string",
+"description": "Check-in date (YYYY-MM-DD)"
+},
+"checkout": {
+"type": "string",
+"description": "Check-out date (YYYY-MM-DD)"
+},
+"adults": {
+"type": "number",
+"description": "Number of adults"
+},
+"children": {
+"type": "number",
+"description": "Number of children"
+},
+"infants": {
+"type": "number",
+"description": "Number of infants"
+},
+```
+{14}------------------------------------------------
+```
+"pets": {
+"type": "number",
+"description": "Number of pets"
+},
+"minPrice": {
+"type": "number",
+"description": "Minimum price for the stay"
+},
+"maxPrice": {
+"type": "number",
+"description": "Maximum price for the stay"
+},
+"cursor": {
+"type": "string",
+"description": "Base64-encoded string used for Pagination"
+},
+"ignoreRobotsText": {
+"type": "boolean",
+"description": "Ignore robots.txt rules for this request"
+}
+},
+"required": [
+"location"
+]
+},
+"annotations": null
+},
+{
+"name": "airbnb_listing_details",
+"description": "Get detailed information about a specific Airbnb listing. Provide direct links to the
+,→ user",
+"input_schema": {
+"type": "object",
+"properties": {
+"id": {
+"type": "string",
+"description": "The Airbnb listing ID"
+},
+"checkin": {
+"type": "string",
+"description": "Check-in date (YYYY-MM-DD)"
+},
+"checkout": {
+"type": "string",
+"description": "Check-out date (YYYY-MM-DD)"
+},
+"adults": {
+"type": "number",
+"description": "Number of adults"
+},
+"children": {
+"type": "number",
+"description": "Number of children"
+},
+"infants": {
+"type": "number",
+"description": "Number of infants"
+},
+"pets": {
+"type": "number",
+"description": "Number of pets"
+},
+"ignoreRobotsText": {
+"type": "boolean",
+"description": "Ignore robots.txt rules for this request"
+```
+{15}------------------------------------------------
+```
+}
+},
+"required": [
+"id"
+},
+"annotations": null
+}
+],
+"tool_count": 2,
+"tool_names": [
+"airbnb_search",
+"airbnb_listing_details"
+]
+},
+"processed_timestamp": 1753731940,
+"processing_mode": "smithery",
+"rank": 556
+}
+}
+```
+### Example 2: Task instance (Dtraj ).
+```
+{
+"question_id":12413,
+"question": "I am trying to determine the launch angles for a projectile that must travel 30 m horizontally and
+,→ reach a height of 5 m at that point.#"
+}
+```
+### Example 3: Unit test instance (Dut).
+```
+{
+"function_name": "listProviders",
+"arguments": {},
+"function_output_content": "{\n \"ollama\": {\n \"models\": [\n \"llama2\",\n \"mistral\",\n
+,→ \"mixtral\",\n \"nous-hermes\",\n \"neural-chat\",\n \"vicuna\",\n
+,→ \"codellama\",\n \"phi\"\n ],\n \"supportsReasoning\": false\n }\n}"
+}
+```
+### B.2. MCP-server Filtering Details
+We provide implementation details of the four-stage MCP-server filtering pipeline summarized in the main text.
+Stage I: Structure Validation. We require each candidate server to expose a parseable MCP tool registry with valid tool\_name and description fields, as well as JSON schemas for tool inputs (and outputs when available). Servers with missing, malformed, or non-parseable registries are removed.
+Stage II: Executable Validation. We launch each server in a sandboxed environment with resource and network isolation, and attempt to invoke its tools under fixed timeouts. Servers that fail to start or cannot be successfully invoked within 3 retries are discarded, ensuring basic executability and robustness.
+Stage III: Deduplication and Clustering. To reduce redundancy, we first remove exact duplicates based on server\_name/tool\_name. We then construct a schema text for each server from its server\_name and tool name/description, and embed these texts using sentence-transformers/all-MiniLM-L6-v2. Servers are clustered using *complete-link* hierarchical clustering with cosine similarity threshold 0.9, i.e., a server joins a cluster only if it is at least 0.9 similar to all existing members. We retain one representative per cluster, preferring servers with (i) fully parseable registries, (ii) clearer tool descriptions, and (iii) fewer external dependencies. This stage yields 121 servers.
+{16}------------------------------------------------
+Stage IV: LLM Semantic Validation. We apply an LLM-based auditor to analyze each server's tool descriptions and schemas. The auditor labels servers as stateless or stateful, flags whether external API credentials are required (requires\_api), and assigns a sandbox requirement level (L0–L5). We discard servers that require external credentials or whose sandbox requirement level is L3–L5, ensuring safe execution under our benchmark setting.
+Appendix Figure [7](#page-13-0) summarizes the end-to-end filtering pipeline and per-stage attrition.
+### B.3. LLM-as-Judge Prompt for Server Semantic Validation
+```
+LLM-as-Judge Mcp-server
+You are an AI assistant. I will give you a tool-scheme JSON for a single server.
+Please output ONLY one JSON object (no array, no markdown fences) with exactly these fields:
+- server_name (string): the name of the server
+- clarity_score (integer 1--10): overall clarity of all tool descriptions
+- 1 = completely unclear, jargon-filled
+- 5 = generally understandable but some omissions or ambiguities
+- 10 = crystal-clear, concise, no ambiguity
+- clarity_comment (string): brief rationale, e.g. which parts were ambiguous or exemplary
+- usefulness_score (integer 1--10): overall usefulness of descriptions for a developer
+- 1 = almost no practical guidance, missing parameters/examples
+- 5 = some guidance present but lacks examples or edge-case notes
+- 10 = highly practical, with examples, parameter hints, and usage notes
+- usefulness_comment (string): brief rationale, e.g. missing examples or strong guidance
+- risk_level ("low"/"medium"/"high"):
+Assess overall risk as low for read-only tools, medium for write/modify operations with safeguards, and
+,→ high for
+destructive or privileged actions (e.g. file deletion, shell execution) or known malicious patterns.
+- risk_reason (string): explanation for the chosen risk level
+- domain (string): choose one of the existing domains or invent a new one if none fit
+- complexity_avg (number 1--10): average complexity across tools
+- 1 = trivial single-parameter lookup
+- 5 = moderate (several parameters, optional flags)
+- 10 = very complex (multiple steps, nested structures)
+- complexity_comment (string): brief note on what drove the complexity up or down
+- api_type (string): choose exactly one from the list below
+Here is the list of existing domains:
+{', '.join(existing_domains) if existing_domains else '[no existing domains]'}
+Here is the list of acceptable API types:
+{', '.join(api_types)}
+Here is the raw tool-scheme JSON:
+{json.dumps(data, ensure_ascii=False)}
+Ensure the returned JSON object uses one–and only one–value for both "domain" and "api_type",
+and includes all fields above with concise but clear comments.
+```
+{17}------------------------------------------------
+### B.4. Task Generation and Filtering
+```
+Task Generate
+### Task Objective
+Generate a Tool Use Question based on the provided MCP Server and its tool descriptions.
+### Goal
+Analyze the provided MCP Server and its available tools, then create a realistic user question that would
+,→ naturally require the use of one of these tools to solve.
+### Guidelines
+#### Question Realism
+* Create questions that represent real-world scenarios where users would need to interact with the MCP
+,→ Server's tools.
+* The question should sound natural and authentic, as if asked by someone genuinely needing to accomplish
+,→ a task.
+* Consider common use cases, problems, or workflows that would require the functionality provided by the
+,→ MCP Server's tools.
+#### Tool Selection
+* Focus on ONE specific tool from the MCP Server that would be most appropriate to answer the question.
+* Choose tools based on the core functionality they provide and how they would solve real user problems.
+* Consider each tool's description and purpose when crafting the question.
+#### Question Complexity
+* Create questions that are clear and specific enough to warrant tool usage.
+* Avoid overly simple questions that could be answered without tools.
+* Include relevant context or constraints that make the tool usage necessary.
+* Do not include the tool's name directly in the question.
+#### Output Format
+Your response should include the following:
+1. Tool Analysis: Briefly analyze the MCP Server's available tools and their main functionalities.
+2. Target Tool: The specific tool name from the MCP Server that should be used to answer this question.
+3. Question: A clear, realistic user question that requires tool usage.
+### MCP Server Description
+{{ MCP_SERVER_NAME }}: {{ MCP_SERVER_DESCRIPTION }}
+Available Tools:
+{{ TOOL_LIST }}
+Initial State:
+{{ INIT_STATE }}
+### Ideas
+{{ CONSTRUCTIVE_IDEAS }}
+### Output Example
+Please provide your response in the following JSON format:
+```
+{18}------------------------------------------------
+```
+```json
+{
+"tool_analysis": "Briefly analyze the MCP Server's available tools and their main functionalities.",
+"target_tool": "The specific tool name from the MCP Server that should be used to answer this
+,→ question.",
+"question": "A clear, realistic user question that requires tool usage."
+}
+```
+Task filtering (LLM-as-judge)
+### Task
+Conduct a Question Quality Assessment of a tool use question across six key dimensions to ensure it meets
+,→ high standards for realistic tool usage scenarios.
+### Objective
+Analyze the provided tool use question and assess its quality across six primary dimensions:
+1. Tool Selection Difficulty - How challenging it is to determine which tools to use from all available
+,→ tools.
+2. Tool Selection Uniqueness - How unique and necessary the selected tools are for this specific task
+,→ among the available tools.
+3. Question Quality - Overall clarity, specificity, and effectiveness of the question.
+4. Scenario Realism - How authentic and believable the scenario is.
+5. Verifiability - How easy it is to verify the correctness of the final model's answer.
+6. Stability - How stable the answer will be when requested under different time and geolocation.
+7. Completeness - Whether the question provides sufficient information to solve the problem without
+,→ requiring additional clarification.
+### Assessment Criteria
+#### 1. Tool Selection Difficulty
+What to Evaluate: How difficult it would be for a user to determine which specific tools are needed to
+,→ solve the question.
+Rating Guidelines:
+* very easy: Question explicitly mentions tool names or makes tool selection obvious.
+* easy: Tool selection is straightforward with clear indicators.
+* medium: Requires some reasoning, but tool needs are fairly apparent.
+* hard: Requires careful analysis to determine appropriate tools.
+* very hard: Requires extensive expertise and deep reasoning to identify the correct tools.
+#### 2. Tool Selection Uniqueness
+What to Evaluate: How unique and necessary the selected tools are for completing this task, and whether
+,→ the task can only be solved with these tools in the specified sequence.
+Rating Guidelines:
+* not unique: Many alternative tool combinations could achieve the same task.
+* somewhat unique: Some alternative approaches exist, but selected tools offer advantages.
+* moderately unique: Selected tools are well-suited, with limited alternatives.
+* quite unique: Selected tools are particularly well-matched to the task requirements.
+* highly unique: Task can only be accomplished effectively with these specific tools in this sequence.
+#### 3. Question Quality
+```
+{19}------------------------------------------------
+```
+What to Evaluate: Overall clarity, specificity, and effectiveness of the question as a realistic user
+,→ query.
+Rating Guidelines:
+* very poor: Unclear, ambiguous, or poorly constructed question.
+* poor: Some clarity issues, missing important context.
+* average: Clear and understandable, but could be more specific or engaging.
+* good: Well-constructed, clear, specific, and realistic.
+* excellent: Exceptionally clear, detailed, engaging, and professionally written.
+#### 4. Scenario Realism
+What to Evaluate: How authentic, believable, and true-to-life the described scenario is.
+Rating Guidelines:
+* unrealistic: Artificial, contrived, or implausible scenario.
+* somewhat unrealistic: Some realistic elements, but feels forced or unlikely.
+* moderately realistic: Believable scenario with minor authenticity issues.
+* realistic: Authentic scenario that represents genuine use cases.
+* highly realistic: Completely natural, authentic scenario indistinguishable from real user needs.
+#### 5. Verifiability
+What to Evaluate: How easy it is to verify the correctness of the final model answer.
+Rating Guidelines:
+* hard to verify: Fully free-form answer that requires extensive human judgment.
+* somewhat hard: Mostly subjective answer with some verifiable elements.
+* moderately verifiable: Short sentence that can be verified by LLM comparison.
+* mostly verifiable: Answer with clear, objective components and some subjective elements.
+* easy to verify: Answer can be verified by simple rules, exact matches, or clear success criteria.
+#### 6. Stability (1-5 Scale)
+What to Evaluate: How stable and consistent the answer will be when the question is asked under different
+,→ environmental conditions and system contexts. Consider factors like temporal dependency,
+,→ geographical variations, operating system differences, network environments, and software version
+,→ variations.
+Rating Guidelines:
+* highly unstable: Answer changes significantly across different conditions (real-time data,
+,→ location-specific, system-dependent).
+* somewhat unstable: Answer may vary moderately based on environmental or system factors.
+* moderately stable: Answer mostly consistent with minor variations due to context.
+* mostly stable: Answer remains largely consistent across different conditions.
+* highly stable: Answer is completely independent of environmental and system factors.
+#### 7. Completeness
+What to Evaluate: Whether the question contains all necessary information (parameters, constraints,
+,→ context) for the tool to successfully execute the task without needing to ask the user for more
+,→ details.
+Rating Guidelines:
+* incomplete: Missing critical information required by the tool (e.g., missing destination for a trip).
+* somewhat complete: Missing some non-critical information, might require assumption or default values.
+* complete: Contains all necessary information to execute the task.
+```
+{20}------------------------------------------------
+```
+### Question Analysis
+#### All Available Tools
+```
+{{ ALL_SERVER_AND_TOOL_INFORMATION }}
+```
+#### Question Content
+```
+{{ QUESTION_CONTENT }}
+```
+#### Intended Tool for This Question
+```
+{{ INTENDED_TOOL }}
+```
+#### Previous Feedback (if any)
+```
+{{ FEEDBACK }}
+```
+### Output Requirements
+Provide a detailed analysis with reasoning BEFORE scores for each of the seven metrics.
+If the question is rated as incomplete or somewhat complete, provide specific Constructive Feedback on
+,→ what information is missing and how to improve the question.
+### Output
+Provide your response in the following JSON format:
+```json
+{
+"tool_selection_difficulty": {
+"reasoning": "Detailed explanation including ambiguity level, domain knowledge required, and
+,→ alternative solutions giving all available tools.",
+"rating": "Rating: very easy, easy, medium, hard, very hard"
+},
+"tool_selection_uniqueness": {
+"reasoning": "Detailed explanation of tool necessity, sequential dependencies, and alternative tool
+,→ viability giving all available tools.",
+"rating": "Rating: not unique, somewhat unique, moderately unique, quite unique, highly unique"
+},
+"question_quality": {
+"reasoning": "Detailed explanation covering linguistic quality, information architecture, and
+,→ actionability.",
+"rating": "Rating: very poor, poor, average, good, excellent"
+},
+"scenario_realism": {
+"reasoning": "Detailed explanation of industry authenticity, workflow accuracy, and stakeholder
+,→ behavior.",
+"rating": "Rating: unrealistic, somewhat unrealistic, moderately realistic, realistic, highly
+,→ realistic"
+},
+```
+{21}------------------------------------------------
+```
+"verifiability": {
+"reasoning": "Detailed explanation of answer format, objective criteria, and ground truth
+,→ availability.",
+"rating": "Rating: hard to verify, somewhat hard, moderately verifiable, mostly verifiable, easy to
+,→ verify"
+},
+"stability": {
+"reasoning": "Detailed explanation of temporal/geographical/system dependencies and environmental
+,→ factors.",
+"rating": "Rating: highly unstable, somewhat unstable, moderately stable, mostly stable, highly stable"
+},
+"completeness": {
+"reasoning": "Detailed explanation of whether all necessary parameters are present.",
+"rating": "Rating: incomplete, somewhat complete, complete"
+},
+"feedback": "Specific instructions on how to improve the question if it failed any criteria, especially
+,→ completeness. Leave empty if all good."
+}
+```
+```
+### B.5. Trajectory Generation and Filtering
+Trajectory Filtering(LLM-as-judge).
+```
+Deep Researcher
+### Task
+You are given:
+1. the user's request (QUESTION_CONTENT)
+2. the full conversation history (CONVERSATION_HISTORY), including all assistant turns and any tool
+,→ outputs.
+Your task is to assess whether the assistant has ultimately delivered a usable, end-to-end outcome by the
+,→ end of the conversation.
+Completeness is the ONLY evaluation dimension. Ignore verbosity, writing quality, politeness, and
+,→ intermediate mistakes.
+### Core Principle
+At the end of the conversation, if the user stops right there, can they achieve their goal without any
+,→ essential follow-up?
+* If YES -> higher completeness score.
+* If NO -> you must identify the missing element that prevents success.
+### What Counts as "Complete"
+The assistant is complete only if it satisfies the user's goal end-to-end, which typically requires:
+* The must-have deliverable is provided (e.g., final answer, file, code patch, plan, table, steps).
+* If actions depend on tools/files, the assistant either:
+* successfully uses them and delivers results, or
+* if blocked (tool failure / missing access), provides a working fallback (clear manual steps,
+,→ alternative method, or minimal viable deliverable).
+* Includes any essential "last-mile" details: paths, commands, file links, or instructions needed to use
+```
+{22}------------------------------------------------
+```
+,→ the output.
+Do NOT reward partial attempts unless the outcome is still usable.
+### Rating (1-5)
+Assign exactly one integer score:
+1 – very incomplete: No usable outcome; major must-haves missing.
+2 – incomplete: Some progress, but the user still cannot accomplish the goal.
+3 – partially complete: Core work attempted; usable only with significant user effort or a key missing
+,→ piece.
+4 – mostly complete: Meets most must-haves; only minor omissions or small usability issues remain.
+5 – fully complete: Fully meets must-haves end-to-end with a usable outcome delivered.
+### NEVER Do
+* NEVER score tool-call accuracy or penalize "wrong tool usage" unless it directly prevents completion.
+* NEVER judge style/verbosity/formatting elegance.
+* NEVER give credit for intentions ("I will do X later") unless the deliverable is actually present.
+* NEVER assume external actions happened without evidence in the transcript.
+## Inputs
+### Question Content
+```json
+{QUESTION_CONTENT}
+```
+### Conversation History
+```json
+{CONVERSATION_HISTORY}
+```
+## Output
+Provide your response in the following JSON format:
+```json
+{
+"completeness": {
+"reasoning": "Evaluate if the assistant delivered an end-to-end usable outcome, addressed all
+,→ requirements, handled tool failures with alternatives, and provided necessary
+,→ confirmations/paths.",
+"rating": "Rating: very incomplete, incomplete, partially complete, mostly complete, fully complete"
+}
+}
+```
+```
+### B.6. Unit Test Prompts
+```
+Unit test synthesis
+You are given:
+(1) one tool schema (name/description/JSON schema for inputs/outputs).
+Generate K unit tests that improve parameter coverage, including:
+- boundary-value inputs,
+```
+{23}------------------------------------------------
+```
+- invalid or missing required fields,
+- rare branches implied by the description.
+Output a JSON list. Each test:
+"test_id": "...",
+"tool_name": "...",
+"inputs": { ... },
+"expected": {
+"type": "output" | "error",
+"value": ...,
+"error_type": "..." // optional
+"source": "llm_synth"
+}
+Constraints:
+- Inputs must be schema-valid for output-type tests.
+- For invalid tests, violate exactly one constraint and specify the expected error_type.
+- Avoid any dependence on private accounts, API keys, or hidden external state.
+```
+# C. More Details on Experiments
+### D. More Details on Analysis
+#### <span id="page-23-0"></span>D.1. Signal-Validation Alignment (SVA) score
+**Verification signals.** We use three automated verification signals computed from the produced MCP server artifact: (i) **Schema-F1**, measuring interface match quality between predicted and reference tool signatures; (ii) $UT_{soft}$ and (iii) $UT_{hard}$ , measuring tool-call verification pass rates under a permissive (soft) versus strict (hard) matching criterion.
+**Downstream validation target.** For each instance i, we denote the downstream validation value as $r_i \in [0, 1]$ , instantiated in our experiments as the trajectory-level validation rate (soft).
+**Definition.** Given a verification signal $s_i \in [0,1]$ and downstream validation $r_i$ , we define the **Signal-Validation** Alignment (SVA) score as
+$$SVA(s,r) = \frac{\sum_{i:s_i>0} s_i r_i}{\sum_{i:s_i>0} s_i + |\{i:s_i \le 0\}|}.$$
+(17)
+Unlike correlation, SVA evaluates whether *high* verification-signal values concentrate on instances with high downstream validation, and it additionally penalizes *zero-signal* cases through the term $|\{i: s_i \leq 0\}|$ , capturing signal coverage (i.e., how often a signal collapses to zero or becomes uninformative). Higher SVA therefore indicates a verification signal that is both more indicative of downstream validation and more consistently defined across instances.
+### <span id="page-23-1"></span>E. More Details on Exploration
+#### E.1. Finetuning Exploration
+We study **finetuning** on TOOL GENESIS as a simple and reproducible adaptation mechanism.
+**Data construction.** We construct an executable supervision signal by collecting successful tool-creation trajectories from a held-out pool of MCP servers. Concretely, we run our **Code-Agent** pipeline (generate-execute-repair) with **DeepSeek-V3.2** as the backbone model and synthesize approximately **1,000** tool-creation trajectories. Each trajectory records the requirement, the generated MCP tool registry (schema), the materialized implementation artifact (server code), and optional execution/verification feedback produced during the loop (e.g., launch errors and unit-test summaries). We then apply strict filtering to retain only high-quality instances whose final artifacts are (i) MCP-compliant and parseable, (ii) executable under our sandbox, and (iii) verifiable by our automated checks (unit tests when available). We further remove trajectories
+{24}------------------------------------------------
+that require external credentials or unstable external state, and drop samples with malformed registries, non-deterministic outcomes, or excessively long logs. After filtering, we retain 500 high-quality trajectories as our finetuning training set. Unless otherwise stated, training and evaluation are server-disjoint to avoid leakage.
+Functioning (supervision formatting). We convert each retained trajectory into instruction–response examples aligned with the TI+TM lifecycle. Specifically, we include: (i) Direct examples mapping a requirement to a single-pass output (schema plus implementation), and (ii) Repair examples unrolled from the generate–execute–repair loop, where the input additionally contains truncated executable feedback and the target is a corrected patch or revised implementation. Each repair iteration is treated as an independent example, enabling the model to learn bug localization and correction conditioned on execution signals.
+Finetuning configuration. We fine-tune Qwen3-8B on the curated finetuning set using teacher-forcing maximum likelihood. We train for 3 epochs and keep the rest of the evaluation pipeline unchanged (prompting, decoding, tool-call parsing, runtime sandbox, and verification), ensuring an apples-to-apples comparison. We use AdamW with cosine learning-rate scheduling and warmup, gradient clipping, and mixed-precision training. The learning rate is selected within 1e-5–5e-5 on a server-disjoint development split; in our runs, the best checkpoint typically uses a learning rate around 2e-5. Unless otherwise specified, we use a max sequence length of 4k–8k tokens with packing, and gradient accumulation to match the target effective batch size under fixed hardware constraints. We report the best checkpoint on the development split and evaluate on held-out test servers.
+Results. Finetuning on TOOL GENESIS leads to better performance. Table [6](#page-6-4) shows that finetuning yields consistent gains across evaluation layers, demonstrating that TOOL GENESIS can serve not only as an evaluation benchmark but also as an effective training signal for tool creation. Under the Direct setting, finetuning improves one-shot schema generation quality and increases downstream task success, suggesting that finetuning internalizes MCP-compliant interface patterns and reduces schema-level failures in single-pass TI+TM. Under the Code-Agent setting, finetuning further strengthens closed-loop repair: the fine-tuned model more reliably fixes execution-triggered implementation bugs, increasing unit-test pass rates (UT) and improving task success (SR). Overall, finetuning primarily strengthens one-shot generation under Direct, while under Code-Agent it improves bug localization and correction, translating executable feedback into measurable downstream utility.