acceptodds
Under review as a conference paper at ICLR 2027

AppSci-Bench: Can LLMs Build AI Agents and Make Them Better?

Abstract

Large language models (LLMs) are increasingly used not only to power AI agents but also to build them. While many benchmarks assess the quality of LLM-powered agents, few ascertain how good LLMs are at _building_ them. To this end, we introduce AppSci-Bench, where we construct a setting akin to how human **App**lied **Sci**entists build agents for businesses - through eliciting task requirements from stakeholders, exploring the business's infrastructure, and scientifically improve the target agent by designing experiments and internal benchmarks. AppSci-Bench features seven realistic domains - five new ones (Slides Generation, Order-to-Cash, Compliance Review, Customer Call Insights, and CRM Insights) and two domains recasted from -bench (Airline and Banking) - each with a held-out evaluation suite customized for that task. We evaluate seven frontier models and find AppSci-Bench challenging: the best model, Claude Opus 5.0, only reaches a mean-minimum score of **59.1%** across 3 build attempts; other models do significantly worse. Models struggle with eliciting task requirements (only 64% for Opus 5.0), build representative internal evaluations (models saturate their own evaluation 65% of the time but fail to solve the held-out task), presenting challenges for future research.

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM-powered-agents, AI Agents, Agent-Building, Benchmarking, Coding Agents, Meta-agents, Large Language Models

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_SeRqOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes AppSci-Bench, which aims to evaluate the ability to build a runnable agent from scratch. The benchmark covers seven types of real-world business tasks, requiring models to deliver executable agent systems, and evaluates their task performance and reliability via a hidden test set. Experiments reveal that the best-performing model achieves an overall score of only 59.1%, and that models generally suffer from insufficient requirement acquisition, distorted internal evaluation, and limited self-optimization effectiveness, indicating a substantial gap between current LLMs and reliable end-to-end agent development.

Critical strengths
  1. The benchmark includes the evaluation process overlooked by prior benchmarks, including requirement elicitation and self-optimization.
  2. The shortcomings the authors identify in existing LLMs' agent construction can inspire future related work.
Critical weaknesses

The authors explicitly state in Lines 455–456 that their benchmark's advantage over ττ\tau^\tau-Bench lies in "adopting this paradigm in a broader applied-science setting." However, the newly added domain covers only seven task scenarios, which focus on relatively narrow areas such as "Customer Call Insights" and "CRM Insights," making it insufficient to fully evaluate LLMs' agent construction capabilities.

If the authors could release the benchmark via an anonymous repository during the rebuttal period, and I can confirm that the data quality is good, I would be happy to raise my score.

Questions for authors
  1. During the review period, the authors did not release the benchmark through an anonymous repository, which limits the assessment of this benchmark's validity.
  2. Pages 8–9 look somewhat sparse overall. It would be better to add content to make these pages more substantial.
2 comments
AuthorsOpenReview ↗

W, Q1, Q2: Benchmark Release, Adding more analysis to the paper

Thanks for your comment! We fully agree with the questions and provide explanations for the weakness below.

  • W1: We wanted to sample our task domains from realistic business scenarios and came up with these seven diverse domains as our initial candidates. We will support newer agentic use-cases in future releases as we come across more of them, to make the benchmark useful to the community.

  • Q1: You can find the entire benchmark along with the datasets here. All task related data can be found in the tasks/ directory: https://anonymous.4open.science/r/appsci-bench-CD3F.

  • Q2: We added another study Section 3.5: statistical significance studies on the effect of enabling optimization into the main paper. Please feel free to take a look! We also have ablation studies comparing a no-business user setting with the default setting (with user simulator) in Appendix I, that we can move into the main paper when we get the larger page limit. Some other analysis pointed out by reviewers, like benchmark's LLM-judge-human alignment and reasons for performance gap between native harnesses v/s AppSciAgent will also be moved up into the main paper.

Thanks for your response. I have checked that the benchmark is okay and have increased my score.

Reviewer_KVKNOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

AppSci-Bench evaluates whether LLMs can build agents end to end rather than merely act as agents. A builder LLM acting as an Applied Scientist must elicit under-specified requirements from a simulated business user, explore a containerized task environment, implement and deploy an artifact agent, author its own internal benchmark, and hill-climb on it before submission. Submitted artifacts are scored on held-out data and scenarios. The suite comprises 7 tasks, five new ones (Slides, Order-to-Cash, Compliance, Call Insights, CRM Insights) and two recast from τ-bench (Airline, Banking). The primary metric MMS@k takes the per-sample minimum over k = 3 independent builds to capture reliability. Seven frontier and open models are evaluated, and Claude Opus 5 with Claude Code reaches 59.1% MMS@3. The analyses show that models elicit at most 64% of withheld requirements versus 88% for humans, that self-authored internal benchmarks saturate within roughly 2.5 rounds in 65% of builds and overstate gains by a factor of five (16.9 versus 3.3 held-out points), that the optimization loop does not reliably help strong models, and that harness choice affects scores as much as model choice. The paper also provides human baselines, an adversarial persona safety study, and a 287-build failure taxonomy.

Critical strengths
  1. A well-motivated and genuinely new measurement target with process-level instrumentation. Moving evaluation from the agent as artifact to the agent as builder fills a real gap between agent benchmarks such as τ-bench and CRMArena on one side and automated agent design work such as ADAS and prompt optimizers on the other. Crucially, the paper makes intermediate objects of the build process, namely requirement elicitation quality and the fidelity of self-authored internal benchmarks, first-class measured quantities. The resulting findings are the most consequential contribution of the paper. Internal evals saturate within roughly 2.5 rounds in 65% of builds with an average suite size of only 8 examples. The self-grader is directionally correct on 11 of 12 changing steps yet overstates gains fivefold, 16.9 versus 3.3 points, and 5 of 24 optimization steps are false accepts where the self-grade rises while the held-out score stays flat. This is direct quantitative evidence about why agentic self-improvement loops fail, and it matters to anyone building such pipelines.

  2. Evaluation hygiene and engineering rigor are well above the norm for benchmark papers. The work includes build and eval phase isolation with ordered container teardown, allowlist-based spec redaction with a fail-closed write, a four-gate leakage review in which 348 automated hits were adjudicated down to zero real leaks, a reliability-aware primary metric, human baselines matched to agent conditions which remain rare among agentic benchmarks, a red team protocol with careful accounting of fired versus unmeasurable pressures, and a 287-build manual failure analysis with a documented counting procedure. This substantially raises confidence that the reported numbers measure what they claim to measure.

Critical weaknesses
  1. The headline quantitative claims rest on limited statistical support. Each model-task cell has only k = 3 builds and T = 3 trials, and since MMS@3 is an order statistic a single broken build zeroes a task, so the main rankings carry high variance and no confidence intervals are reported. In addition, the 59.1% headline number comes from Claude Code with roughly 2 to 5 times the token budget of the AppSciAgent runs, so the harness comparison is not budget-matched. Reporting uncertainty and a budget-matched control would make these results much more convincing.

  2. Judge validation and contamination controls are thinner than the rest of the evaluation hygiene. The CRM score is entirely LLM-judge-carried and no human-judge agreement study is reported, while 2 of 7 tasks reuse τ-bench data directly and CRM, Compliance, and Slides all draw on public corpora that may appear in pretraining data. A small human validation of the judges and a stronger check on the recast tasks would address this.

Questions for authors
  1. Which models serve as the user simulator and as the LLM judges, and can you report human-judge agreement on a sample of held-out evaluations, particularly for CRM whose score is entirely judge-carried?
  2. Given that τ-bench has been public since 2024, do models score anomalously higher on τ-Airline and τ-Banking than on the five novel tasks after controlling for difficulty?
  3. Can you report confidence intervals for overall MMS@3 and recompute the leaderboard with dagger-marked cells treated as zeros instead of dropped?
3 comments
AuthorsOpenReview ↗

W2, Q1: Models used as user simulators and judges; LLM-judge to Human agreement

We thank the reviewer for their comments and report additional evidences below.

Concern: Which models serve as the user simulator and as the LLM judges, and can you report human-judge agreement on a sample of held-out evaluations

The following models are used in the user simulator and LLM judges:

  • Build time customer simulator: anthropic/claude-opus-4-8
  • Eval time user simulator: openai/gpt 5.2
  • Eval time LLM as a judges: anthropic/claude-opus-4-8

We agree with the concerns raised here regarding lack of human-judge agreement study and tau-bench task evaluation validation. To address this, we conducted a small human study with a 3-co-author panel, evaluating and validating 70 data points / pairs randomly selected in a stratified manner across the 7 tasks, agent models, and LLM-as-a-judge metrics within each task. The study is subdivided into 2 sections:

  • For the 5 tasks where LLM judges are used (CRM insights, compliance review, order-to-cash, customer call insights, and slides generator), we frame the human study as a pairwise comparison question, where each human annotator needs to select the better response of the same evaluation question among the two presented. The LLM judge would be considered in agreement with the human preference if it assigns a higher score to the response the human majority selects. We follow prior studies and our concurrent work on comparing pointwise scores with preference rankings when designing this study (https://openreview.net/forum?id=9gdZI7c6yr, https://arxiv.org/abs/2609.36086). To avoid trivializing the comparison task or providing strictly tied pairs, we limit each pair to have a score difference between 0.05 to 0.25 during the randomized data pair generation process, with the exception of the answer_correctness metric within CRM insights, which has a strict binary (0/1) output. This constitutes 50 data pairs.
  • For the 2 tasks where only deterministic database checks are used for evaluation (the 2 tau-bench tasks), we use the same human panel to manually validate if the deterministic check result aligns with human judgement when the conversation traces and all relevant policy information are considered. Instead of human agreement, the goal is to validate whether deterministic check is a good proxy of artifact agent performance. This constitutes 20 data points.

We report results here separately.

  • On the 50 LLM-as-a-judge pairs, the judge sided with the human majority 80% of the time (kappa 0.60), and it agreed with individual annotators 77% of the time, against 73% among the annotators themselves (+4 pts, CI -3 to +11). The judge behaves more or less like one more annotator.
  • The judge's agreement with the majority rises from 73% at score gaps of 0.05-0.15 (n=30) to 87% at 0.15-0.25 (n=15) and 100% at gap 1.0 (n=5, CRM insights task answer_correctness metric only), though the difference is not statistically significant due to the small sample sizes.
  • For the deterministic checkers, annotators upheld 19 of 20 checker verdicts (95%, CI 76-99%). The checker looks at the final database state and the facts the agent had to tell the caller, not the conversation traces, so an agent can plausibly reach the right end state while handling the simulated user badly.

We will include this in the appendix of the revised manuscript.

AuthorsOpenReview ↗

W1, Q3: Harness comparison, Confidence intervals for model scores

Concern: "Claude Code with roughly 2 to 5 times the token budget of the AppSciAgent runs, so the harness comparison is not budget-matched"

We agree the native-harness comparison is not budget-matched, but the budget does not alone explain the performance gap. The native adapters did not apply AppSciAgent's limits, since we wanted to measure those harnesses in their natural configurations. We present the native harnesses on the leaderboard, because ultimately users of the benchmark can test the harness of their choice. Claude Code used about 2–3× more tokens (edited in paper too) per build than AppSciAgent with the optimization layer on (Codex usage is not recorded). Budget does not explain the performance gap, however: AppSciAgent's limits were precautionary and the top 3 models we compare across harnesses never reach these limits in AppSciAgent (no turn or wall-clock limit was hit by these 3 models). Poorer models do hit turn budgets due to poor exploration and artifact building, thus applying the constraints is necessary for a fair comparison. The poor performance for the top models mainly comes from poor context transfer between sub-agent calls. We provide a more detailed analysis of why native harnesses score higher overall than AppSci-Agent in Appendix J.

Concern: Can you report confidence intervals for overall MMS@3 and recompute the leaderboard with dagger-marked cells treated as zeros instead of dropped?

Tables 2 and 6 have been recomputed with 3 builds each for every task (i.e., all dagger rows are removed).

Reliability of eval samples: We present the CIs on overall score below, they are found to vary in +-3 points (bootstrapped on task’s eval samples keeping trial and build fixed).

ModelMMS@3 [95% CI]Average [95% CI]
Opus 544.7 [41.4, 47.9]58.3 [55.3, 61.1]
Opus 4.834.8 [31.7, 37.9]53.8 [50.8, 56.6]
Kimi K330.9 [27.9, 33.8]51.6 [48.9, 54.3]
GPT-5.510.1 [8.2, 12.0]24.6 [22.6, 26.7]
Sonnet 4.68.6 [6.0, 11.0]24.9 [22.5, 27.1]

Reliability of MMS@k: MMS@3 cannot have a CI score on a build level, since we are restricted to 3 build attempts per model due to budget constraints, but we provide the CI intervals for MMS@1 (same as an average) below. In order to demonstrate that MMS@3 is a reliable leaderboard metric, we also present MMS@k, k={1,2,3} here and show that the rankings are stable: the ranking under MMS@1 and MMS@2 closely matches the MMS@3 ranking: Rankings are stable, over all 20 leaderboard rows (model × harness × optimization setting), Kendall's τ-b between the MMS@3 ranking and the MMS@1 and MMS@2 rankings is 0.89 and 0.92, so about 94% and 96% of row pairs keep their order.

#RowMMS@1 (mean ± SD)MMS@1 95% CIMMS@2 (mean ± SD)MMS@3Rank @1 / @2 / @3Tasks zeroed by one build
1Opus 5, Claude Code, opt71.5 ± 1.9[67.8, 75.2]64.1 ± 1.959.11 / 1 / 10
2Opus 5, AppSci, no opt68.0 ± 3.5[61.6, 74.4]60.2 ± 2.755.63 / 2 / 20
3Opus 5, Claude Code, no opt68.6 ± 3.9[61.4, 75.8]58.6 ± 3.651.72 / 3 / 30
4Opus 4.8, Claude Code, no opt64.3 ± 5.1[49.9, 78.6]54.8 ± 4.048.74 / 4 / 40
5Opus 5, AppSci, opt58.6 ± 5.5[46.3, 70.9]48.2 ± 1.744.76 / 6 / 50
6Opus 4.8, Claude Code, opt62.8 ± 5.6[51.7, 73.9]51.6 ± 5.243.25 / 5 / 61
7Opus 4.8, AppSci, no opt56.8 ± 5.4[46.0, 67.5]47.0 ± 5.239.97 / 7 / 70
8Opus 4.8, AppSci, opt54.1 ± 5.5[41.5, 66.7]42.8 ± 5.234.88 / 8 / 80
9GPT-5.5, Codex, no opt45.8 ± 2.7[41.4, 50.2]37.4 ± 1.833.311 / 10 / 90
10Kimi K3, AppSci, opt51.8 ± 6.5[39.3, 64.3]38.4 ± 4.030.99 / 9 / 101
11Kimi K3, AppSci, no opt46.6 ± 6.7[34.6, 58.5]31.7 ± 4.024.010 / 11 / 110
12GPT-5.5, Codex, opt37.5 ± 4.0[29.5, 45.5]27.7 ± 3.322.312 / 12 / 121
13Sonnet 4.6, AppSci, no opt24.1 ± 4.9[15.8, 32.4]14.1 ± 1.311.915 / 16 / 132
14GPT-5.5, AppSci, no opt22.6 ± 3.9[14.4, 30.8]15.2 ± 2.711.816 / 13 / 142
15GPT-5.5, AppSci, opt24.6 ± 2.2[20.6, 28.6]14.3 ± 2.210.114 / 15 / 153
16Sonnet 4.6, AppSci, opt25.0 ± 6.0[14.8, 35.3]14.3 ± 4.18.613 / 14 / 163
17Haiku 4.5, AppSci, opt9.9 ± 5.8[−0.6, 20.3]1.7 ± 2.50.017 / 17 / 18.51
18GPT-OSS-120B, AppSci, opt4.7 ± 4.3[−3.6, 13.1]0.0 ± 0.00.018 / 19 / 18.50
19Haiku 4.5, AppSci, no opt2.9 ± 2.3[−2.1, 8.0]0.5 ± 0.70.019 / 18 / 18.51
20GPT-OSS-120B, AppSci, no opt2.9 ± 2.9[−3.4, 9.2]0.0 ± 0.00.020 / 20 / 18.50

I thank the authors for the detailed response and the new experiments. I am satisfied with the answers to my concerns. I will maintain my score.

Reviewer_afr1OpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

AppSci-Bench evaluates whether LLMs can build working agent systems from underspecified business requirements, including asking questions, exploring infrastructure, implementing solutions, and designing internal evaluations.

Critical strengths

I find the research question meaningful and timely. Evaluating AI’s ability to build and improve other AI systems is an important direction. The benchmark goes beyond coding to include requirement elicitation and self-evaluation, and the paper is generally clear and easy to follow.

Critical weaknesses

The evaluation does not sufficiently separate agent-building ability from harness compatibility. The failure analysis includes repeated tool-formatting, interface, and turn-limit failures, while native coding harnesses produce substantially different results under larger token budgets. This makes it difficult to determine how much of the measured performance reflects general agent-building limitations versus the particular scaffold and budget. The distinction matters because the paper draws broader conclusions about models’ ability to build and improve agents.

Questions for authors
  1. How much does performance reflect agent-building ability versus compatibility with the AppSci harness? Can the authors distinguish model failures from those caused by tool interfaces or interaction limits?

  2. Does the development environment provide enough data and domain knowledge to build representative internal evaluations? Would better examples or a supplied evaluation set reduce the optimization gap?

  3. How would humans perform with more than four hours? A longer-budget baseline would help distinguish agents’ speed advantage from differences in achievable solution quality.

3 comments
AuthorsOpenReview ↗

W1,Q1: Distinguishing agent-building capability from harness effects, Why native harnesses perform better

Thank you for the insightful comment. To clarify this, here we distinguish findings that were dependent on AppSci agent, from conclusions that are harness-agnostic; explain why using a custom harness was required; and give our view on why measuring both kinds of harnesses have their merits. Later, we also deep dive into why native harnesses are found to have better performances.

Why use a custom harness? AppSci Agent was used to draw conclusions whenever the study

  1. necessitated a shared harness for fair comparison of all the models (eg, Model leaderboard for all 7 models, Pareto frontier for accuracy/latency for 7 models, Policy elicitation of the models with a simulated user etc.)
  2. needed finer grained control in artifact management (e.g., tracking internal checkpoints systematically for Table 3)

Thus, to clarify, the failure analysis in Section 4 is added for completeness and with the intention of informing the user of how these models failed in our custom harness - and not to draw a conclusion that similar failures will be seen in the native harnesses too.

How the dependence does not affect main findings The main aim of the paper is to guide future research on agent-building as a capability and compare models and not harnesses. This is why we present the main model rankings on the leaderboard with all 3 kinds of harnesses -native harness scores give an upper limit of frontier models performance on AppSci-Bench, as they have more sophisticated coding and context management than mini-swe. Section 3.5 measure how these models perform w/ optimization on v/s off across all 3 harnesses as well. We limit other analysis like policy elicitation (Section 3.4) to AppSci-agent builds because due to the simpler nature of talk_to_user tool call, frontier models can do policy elicitation equally well in either harness.

We want to argue analysis on either type of harness has merits and is not contradictory in nature. Using these models in custom harnesses (like AppSci-Agent) is a very realistic setting: since users of these frontier models should be able to construct a capable, generic harness and expect the task performance to not drop significantly.

Analysis of why native harnesses outperform custom harness: For the three models we ran in both harnesses (Opus 5, Opus 4.8 and GPT-5.5), the native harnesses score higher overall than AppSci-Agent (Appendix J). We summarize the reasons here. A detailed report of harness gaps can be found in Appendix K, and the failure taxonomy in Appendix O,P.

TLDR: The gap does not come from build-time failures; it lies in the artifact quality: Neither Opus 4.8 nor Opus 5 had a single build-time failure in AppSci-Agent.

  1. A key contributor of lower performance in Appsci-Agent was context hand-off to sub-agents. AppSci-Agent delegates work such as coding and optimization to sub-agents, and the main agent does not always pass on all the context they need. An example of this is the artifact's I/O contract: the main agent sometimes leaves out the exact request or response field names when delegating to the coding sub-agent (mini-SWE). Other task context can be lost the same way. This can cause outright failures and can also lower the quality of artifacts that otherwise work. We acknowledge can be alleviated by further increasing complexity of AppSci-Agent; the current design gives generic guidance (thus leaving room for ambiguity) but is not incorrect: since even for weaker models the loss happens only intermittently. If the harness was faulty in context propagation unavoidable, it would appear in every build. We will aim to improve AppSci-Agent's capabilities in further iterations of the project.
    • Mini-swe agent is a weaker coding harness than native harnesses. We also have a potential design flaw of letting the model manage the coding agent's context with a fresh context per call. Passing on the necessary details is the delegating model's job, and, as shown below, the strongest model does it reliably for the I/O contract.
    • How often the I/O contract is lost: We measured every build to quantify how often an I/O contract detail that the main agent had, never reached it’s coding sub-agent, in both AppSci-Agent and the native harnesses (methodology described in detail in Appendix K.2). This affects about 10% of all AppSci-Agent builds, and concentrated in a few tasks, mainly compliance review. In native harnesses, this issue never occurs.
  2. Conclusion: Strong models are largely immune to build/artifact failures irrespective of harness. Long context management may play a role in lower appsci-agent scores: We hypothesize the design flaw is amplified by how well a model keeps track of important details over a long task. But we rule out "absolute incorrectness" in harness design, since even these context losses happens only intermittently and does not affect every build for any model.
AuthorsOpenReview ↗

Q2, Q3: Does development environment provide enough data and domain knowledge, Human baselining time budgets

Concern: "Does the development environment provide enough data and domain knowledge to build representative internal evaluations?"

For each task, all the domain knowledge is provided via read-only policy documents and a small build-time store of records in the tools/DBs. The development environment does not supply evaluation set, but requirements about what a good output looks like are elicited from simulated stakeholders (L1/L2/L3). Slides task includes example request inputs at build time (a prompt and attached files). Build and evaluation environments are separate in every task.

Further certification of eval samples To certify each task for correctness further, we ran a small analysis of what the development environment gives the builder and whether the gold labels can be reached from it – i.e., check whether the build-time task environment has full information for building a successful agent to solve a test sample. We test this offline for the tasks whose data points carry ground-truth labels: O2C, compliance and call insights. We ran every case through an LLM judge. The judge sees the policy rules, the case facts and the gold label. It says whether the label follows from the policy, and which rules were needed to reach it. To validate the judge, we removed the rules it named as necessary, for up to 3 rounds, and re-ran it. If the label really depended on those rules, the judge should stop finding it supported once they are gone. As a control, we removed the same number of randomly chosen rules, which should not change the verdict.

The test captured bugs in the Compliance review's test samples – and we are thankful to this review for this finding. We will fix the eval samples and recompute results for this task before camera-ready.

Concern: "Would better examples or a supplied evaluation set reduce the optimization gap?"

While we agree that the optimization gap can vary as we provide bigger datasets in the build phase, the benchmark is designed to force the model to ask and clarify if it finds the current data insufficient. We can potentially try an ablation study with varying build time datasets in size and measuring the impact on the end-performance but are unable to do so in the rebuttal period due to the time-consuming nature of this study.

Concern: "How would humans perform with more than four hours?" Humans used AI assisted coding and all human testers made their final submissions well within the 4 hr budget. There are some tasks that are easy for both humans and AI like O2C, while some like Banking are extremely challenging. The invisibility of the external evaluation in a submission based system and the impossibility to improve from hill-climbing on an external signal justifies the cap for humans. Most likely, small cap raises (from 4 to 6 hours) would have not made any difference, because no information arises to change the setup. In contrast, we cannot discount that large upgrades e.g. a week could have indeed made a significant difference in the hard tasks.

Thank you for the detailed response and the additional analysis of the harness effects. I will maintain my positive rating.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.