Standardized interfaces such as the Model Context Protocol (MCP) make it easier to connect tools to agents, but connection alone is not orchestration. When many related tools are exposed as a flat callable palette, agents must identify relevant tools, resolve substitutes, pass intermediate outputs, and decide when a workflow is complete. We introduce RealFin, a finance-domain diagnostic benchmark for evaluating workflow construction under MCP-style flat tool exposure. RealFin contains 1524 tasks generated from 108 author-designed financial workflow templates over real market, macroeconomic, and company-data APIs. Each task is paired with an executable reference program that specifies one verified solution path, while the 85 agent-callable tools include explicit alternative, dependency, and related-tool metadata to represent non-unique paths, prerequisite tools, and near-neighbor ambiguity. This design supports path-independent answer scoring together with process-level evaluation of tool selection, ordering, parameter planning, entity grounding, temporal grounding, orchestration success, and error recovery. Across ReAct-style flat exposure, retrieval-based exposure, oracle-controlled variants, and progressive tool disclosure, current agents often achieve nonzero answer accuracy while failing to construct reliable workflows. These results suggest that MCP-style tool connectivity needs structured disclosure and workflow-aware evaluation, especially in finance where temporal constraints and overlapping tools are intrinsic.

Existing Text-to-SQL benchmarks remain idealized compared with enterprise scenarios, which require massive query scopes, complex schemas, and scattered external knowledge. We present BIRD-Ent and Spider-Ent, two enterprise-oriented benchmarks constructed via a refinement framework, together with Dual-Retrieval-Augmented-Generation (DRAG) Text-to-SQL, which formalizes table-schema and knowledge retrieval before SQL generation. The benchmarks feature over 4,000 columns per query and, for BIRD-Ent, documents totaling 1.5M tokens. Evaluation on state-of-the-art models shows sharp drops, with only 39.1% EX on BIRD-Ent and 60.5% EX on Spider-Ent. These results establish the Ent-series as a discriminative testbed for structurally robust and retrieval-aware Text-to-SQL.

Code agents are increasingly used in debugging workflows, where fault localization (FL) is often evaluated as endpoint retrieval: whether a model names the faulty code location. This view is inadequate for Linux kernel debugging, where failure logs may expose downstream symptoms while the erroneous state is introduced earlier and propagates through various dependences. We introduce KernelPath, a 200-instance Linux 5.10 function-level FL benchmark that pairs each root cause function with a source-grounded state propagation path and a dependence layer. KernelPath evaluates both endpoint localization and ordered diagnostic process recovery. Experiments with SOTA agents show that agents often retrieve plausible candidates but remain unreliable at recovering the diagnostic process, with performance degrading sharply under complex dependence relations. Further diagnostic probes show that agents can use explicit state-transition evidence, yet fail to infer how functions affect the erroneous state, drifting toward neighboring objectives such as repair-site selection, or up stream suspicious function retrieval. These findings reveal an unstable task model for kernel FL in current code agents.

Insurance claims adjudication demands not only accurate decisions but also interpretable reasoning grounded in policy clauses. However, existing benchmarks are limited to information retrieval or simple multiple-choice setups, which fail to require step-by-step inferences from facts to conclusions. To address this gap, we introduce InsLogicBench, a benchmark providing complete reasoning traces that link factual inputs, relevant policy clauses, and final verdicts. We construct the dataset using a controllable synthesis framework based on the Nested Toulmin Model. By capturing the defeasible logic of insurance policies through hierarchical truth assignment and enforcing validity via consistency verification, we ensure interpretability and logical rigor across generated examples. We evaluate eight Large Language Models (LLMs) on InsLogicBench. Results show significant difficulties in handling exception clauses and verifying missing conditions. Notably, models often produce correct final decisions but fail to provide precise justifications, highlighting a critical discrepancy between their decision accuracy and logical reasoning capabilities.

The task of translating natural language questions into query languages has long been a central focus in semantic parsing. Recent advancements in Large Language Models (LLMs) have significantly accelerated progress in this field. However, existing studies typically focus on a single query language, resulting in methods with limited generalizability across different languages. In this paper, we formally define the Text-to-Query task paradigm, unifying semantic parsing tasks across various query languages. We identify query skeletons as a shared optimization target of Text-to-Query tasks, and propose a general dynamic data augmentation framework that explicitly diagnoses model-specific weaknesses in handling these skeletons to synthesize targeted training data. Experiments on four Text-to-Query benchmarks demonstrate that our method achieves state-of-the-art performance using only a small amount of synthesized data, highlighting the efficiency and generality of our approach and laying a solid foundation for unified research on Text-to-Query tasks. We release our code at https://github.com/jjjycaptain/Skeletron

Text-to-SQL is the task of translating natural language questions into SQL queries based on relational databases. Different databases implement their own SQL dialects, leading to variations in syntax. As a result, SQL queries designed for one database may not execute properly in another, creating a dialect gap. Existing Text-to-SQL research primarily focuses on specific database systems, limiting adaptability to different dialects. This paper proposes a novel adaptive framework called Dialect-SQL, which employs Object Relational Mapping (ORM) code as an intermediate language to bridge this gap. Given a question, we guide Large Language Models (LLMs) to first generate ORM code, which is then parsed into SQL queries targeted for specific databases. However, there is a lack of high-quality Text-to-Code datasets that enable LLMs to effectively generate ORM code. To address this issue, we propose a bootstrapping approach to synthesize ORM code, where verified ORM code is iteratively integrated into a demonstration pool that serves as in-context examples for ORM code generation. Our experiments demonstrate that Dialect-SQL significantly enhances dialect adaptability, outperforming traditional methods that generate SQL queries directly. Our code and data are released at https://github.com/jieshi10/orm-sql.

With the prevalence of Large Language Models (LLMs), recent studies have shifted paradigms and leveraged LLMs to tackle the challenging task of Text-to-SQL. Because of the complexity of real world databases, previous works adopt the retrieve-then-generate framework to retrieve relevant database schema and then to generate the SQL query. However, efficient embedding-based retriever suffers from lower retrieval accuracy, and more accurate LLM-based retriever is far more expensive to use, which hinders their applicability for broader applications. To overcome this issue, this paper proposes Gen-SQL, a novel generate-ground-regenerate framework, where we exploit prior knowledge from the LLM to enhance embedding-based retriever and reduce cost. Experiments on several datasets are conducted to demonstrate the effectiveness and scalability of our proposed method. We release our code and data at https://github.com/jieshi10/gensql.