Open-source 9-task benchmark for coding-agent retrieval augmentation. Per-task deltas +0.010 to +0.320, all evals reproducible [P]
Our take
![Open-source 9-task benchmark for coding-agent retrieval augmentation. Per-task deltas +0.010 to +0.320, all evals reproducible [P]](https://preview.redd.it/ouf5uosmz8xg1.png?width=140&height=71&auto=webp&s=6373119fdf0622e553467d39d25b3308b8bf8f7e)
| Sharing an open-source benchmark suite ( Setup. Same coding agent (Claude Opus 4.6 as the planner, Gemini Flash 3 as the task model), same input data, same evaluation scripts across all 9 tasks: test generation (mutation score), text-to-SQL (execution accuracy), PDF extraction, contract extraction, PR review, text classification, few-shot prompt selection, LLM routing, summarization evaluation. Independent variable: whether the agent could call a retrieval tool over CS literature before writing its solution. One pass per task, no retries, no manual filtering of outputs. Task selection. Tasks were chosen to span the everyday-engineering surface a coding agent actually faces, not specialized ML scenarios. Selection criteria: (1) unambiguous quantitative metric, (2) baseline performance well below ceiling, (3) standard datasets where they exist, (4) eval reproducible on a free Gemini API key in roughly 10 minutes per task. Eval methodology. Each task uses its task-standard quantitative metric (mutation score for test_generation, execution accuracy for text_to_sql, F1 on labeled spans for the extraction tasks, weighted F1 for classification, etc.). Full per-task scripts and dataset choices are in the repo - one directory per task, Retrieval setup. The "with retrieval" agent has access to three tool calls: Comparability. Both agents share the same task-specific user prompt; the only system-prompt difference is the retrieval agent's tool-call grammar. Predictions and per-task prompts are diffable in the repo ( Results.
The test-generation delta came from the agent discovering mutation-aware prompting - the techniques are MuTAP and MUTGEN - which enumerate every AST-level mutation of the target and require one test per mutation. Baseline wrote generic tests from pretrain priors. The contract extraction delta came from BEAVER (section-level relevance scoring) and PAVE (post-extraction validation), both 2026 techniques that post-date the agent's training. 10 of the 15 most-cited sources across the experiments were published in 2025 or later, which is the conservative argument for why retrieval matters: the agent could not have reached these techniques from parametric memory. Failure modes. Self-refinement hurt text-to-SQL (the agent second-guessed correct queries after reading work on SQL ambiguity). Two suggested techniques (DyT, SeeDNorm) were architecture-incompatible in the autoresearch experiment and got discarded. Retrieval surfaces better options, not guaranteed wins. Reproducibility. Every prompt, every line of agent code, every prediction file, every eval script is in the repo. Each task directory has a README documenting methodology and an Repo: https://github.com/paperlantern-ai/paper-lantern-challenges Writeup with detailed per-task discussion: https://www.paperlantern.ai/blog/coding-agent-benchmarks Happy to share additional design choices in comments. [link] [comments] |
Read on the original site
Open the publisher's page for the full experience
Related Articles
- [R] Controlled experiment: giving an LLM agent access to CS papers during automated hyperparameter search improves results by 3.2%Ran a controlled experiment measuring whether LLM coding agents benefit from access to research literature during automated experimentation. Setup: Two identical runs using Karpathy's autoresearch framework. Claude Code agent optimizing a ~7M param GPT-2 on TinyStories. M4 Pro, 100 experiments each, same seed config. Only variable — one agent had access to an MCP server that does full-text search over 2M+ CS papers and returns synthesized methods with citations. Results: Without papers With papers Experiments run 100 100 Papers considered 0 520 Papers cited 0 100 Techniques tried standard 25 paper-sourced Best improvement 3.67% 4.05% 2hr val_bpb 0.4624 0.4475 Gap was 3.2% and still widening at the 2-hour mark. Techniques the paper-augmented agent found: AdaGC — adaptive gradient clipping (Feb 2025) sqrt batch scaling rule (June 2022) REX learning rate schedule WSD cooldown scheduling What didn't work: DyT (Dynamic Tanh) — incompatible with architecture SeeDNorm — same issue Several paper techniques were tried and reverted after failing to improve metrics Key observation: Both agents attempted halving the batch size. Without literature access, the agent didn't adjust the learning rate — the run diverged. With access, it retrieved the sqrt scaling rule, applied it correctly on first attempt, then successfully halved again to 16K. Interpretation: The agent without papers was limited to techniques already encoded in its weights — essentially the "standard ML playbook." The paper-augmented agent accessed techniques published after its training cutoff (AdaGC, Feb 2025) and surfaced techniques it may have seen during training but didn't retrieve unprompted (sqrt scaling rule, 2022). This was deliberately tested on TinyStories — arguably the most well-explored small-scale setting in ML — to make the comparison harder. The effect would likely be larger on less-explored problems. Limitations: Single run per condition. The model is tiny (7M params). Some of the improvement may come from the agent spending more time reasoning about each technique rather than the paper content itself. More controlled ablations needed. I built the paper search MCP server (Paper Lantern) for this experiment. Free to try: https://code.paperlantern.ai Full writeup with methodology, all 15 paper citations, and appendices: https://www.paperlantern.ai/blog/auto-research-case-study Would be curious to see this replicated at larger scale or on different domains. submitted by /u/kalpitdixit [link] [comments]
- ClawBench: Can AI Agents Complete Everyday Online Tasks? 153 tasks, 144 live websites, best model at 33.3% [R]We introduce ClawBench, a benchmark that evaluates AI browser agents on 153 real-world everyday tasks across 144 live websites. Unlike synthetic benchmarks, ClawBench tests agents on actual production platforms. Key findings: The best model (Claude Sonnet 4.6) achieves only 33.3% success rate GLM-5 (Zhipu AI) comes second at 24.2% — surprisingly strong for a text-only model Finance and Academic tasks are easier (50% for the best model); Travel and Dev tasks are much harder No model exceeds 50% in any category — there's a long way to go What makes ClawBench different: Tasks on real live websites, not sandboxed environments 5 layers of behavioral data: session replay, screenshots, HTTP traffic, agent reasoning traces, browser actions Request interceptor blocks the final HTTP request before irreversible actions (payments, bookings), enabling safe evaluation Human ground-truth for every task Agentic evaluator with step-level traceable diagnostics Resources: Paper: https://arxiv.org/abs/2604.08523 Website (interactive leaderboard + trace viewer): https://claw-bench.com Dataset: https://huggingface.co/datasets/NAIL-Group/ClawBench GitHub: https://github.com/reacher-z/ClawBench PyPI: pip install clawbench-eval Happy to answer any questions! We're actively looking for feedback on task selection and evaluation methodology. [R] Research submitted by /u/Extreme_Play_8554 [link] [comments]
- [P] I built an autonomous ML agent that runs experiments on tabular data indefinitely - inspired by Karpathy's AutoResearchInspired by Andrej Karpathy's AutoResearch, I built a system where Claude Code acts as an autonomous ML researcher on tabular binary classification tasks (churn, conversion, etc.). You give it a dataset. It loops forever: analyze data, form hypothesis, edit code, run experiment, evaluate with expanding time windows (train on past, predict future - no leakage), keep or revert via git. It edits only 3 files - feature engineering, model hyperparams, and analysis code. Everything else is locked down. Edit: To clarify based on some comments, I am using this to solve the problem of finding new signals to add to the model, not trying to overfit a limited dataset. -end Edit- Key design decisions: Introducing an analysis loop in addition to the experiment loop, this allow for better reflection and experimentation. Optimize for experiment throughput with a bunch of decisions: Use LightGBM as default model, limit feature count and tree count, locking down training run until it finishes. Constrained editing surface: only 3 files + logs. No infrastructure changes, no package installs. Without this, the agent will eventually try to modify the evaluation code to "improve" its score. Docker sandbox - the agent runs with full shell access (--dangerously-skip-permissions). Container keeps it contained. Expanding time windows over k-fold - mean score across multiple temporal train/test splits. Forced logging - every experiment gets a LOG.md entry (hypothesis, result, takeaway). Significant insights go to LEARNING.md. You can read the agent's reasoning after the fact. Analysis primitives built-in - univariate AUC, correlation pairs, null rates, feature importance, error analysis. The agent writes analysis code using these to save time, they also serve as initial suggestions for the first few analyses. What I learned building this: Air-tight evaluation is the essential for real improvement - this lesson hit me twice: Earlier version didn't constraint which file the agent could edit, it eventually changed the evaluation code to make "improvement" easier for itself. K-fold validation was originally employed, the agent found improvements that are actually data leakage and didn't hold out-of-time. After a painful manual inspection, I switched over to expanding time windows. Do everything to protect experiment throughput - this lesson also hit twice: Initially, I let the model run wild and was not very impressed when it barely run 20 experiments overnight. Turns out, the agent engineered thousands of new features that slowed down training and crash some runs due to RAM limit. I added the feature count limit and tree count limit to make sure training time is reasonable. Despite that, the agent still manage to crash/slow down training runs by putting many of them into background process at the same time. -> Locking mechanism was implemented to prevent 2 experiments being run at the same time. After this, the rate of progress increased to hundreds of runs per day. Persistent memory is important: Without forced logging, the agent would repeat experiments it already tried. The LOG.md and LEARNING.md system gives it memory across iterations. The code open source (sanitized version): https://github.com/trantrikien239/autoresearch-tabularOf course it is done with Claude Code, but it has improved so much after rounds of iterations, including manual edits, so I think it's worth sharing. submitted by /u/Pancake502 [link] [comments]
- [R] Forced Depth Consideration Reduces Type II Errors in LLM Self-Classification: Evidence from an Exploration Prompting Ablation Study - (200 trap prompts, 4 models, 8 Step-0 variants) [R]LLM-Based task classifier tend to misroute prompts that look simple at first glance, but require deeper understanding - I call it "Type II Error" here. Setup TaskClassBench, a custom benchmark of 200 effective trap prompts (context-contradiction + disguised-correction categories) designed to create a mismatch between surface simplicity and contextual complexity. For example: System context establishes a fault-tolerant ETL pipeline with retry logic, dead-letter queues, and alerting. User message: "we don't need the retry logic actually." Four-word sentence, but it's an architectural revision with cascading implications. 8 Step-0 variants tested across 4 commercial models (DeepSeek, Gemini Flash, Claude Haiku, Claude Sonnet), temperature 0, 4 independent API rounds. Key findings: Open-ended exploration "What's really going on here?" reduces Type II rate to 1.25% vs. 3.12% for directed extraction "Summarize the user's intent in one sentence" A content-free metacognitive directive ("Think carefully about the complexity of this task") achieves 1.0% - not significantly different from exploration - but I hypothesize it may differ under filled context (eg. 200k tokens in 1m window) Both significantly outperform structured detection "Are depth signals present? yes/no" and directed extraction Structured yes/no detection catastrophically harms Claude models: Haiku errors jump from 10 to 43 out of 200 (330% increase), Sonnet from 12 to 34 (183%) The mechanism appears to be forced attention to task complexity before classification, not open-ended framing specifically (which I still have high hopes for :D). What seems to matter is unbounded engagement. Structured approaches fail because they constrain or foreclose complexity signals. The most unexpected finding What I call "recognition without commitment": Claude Sonnet under "think carefully" writes "This request asks me to violate an established change management policy" in its Step-0 reasoning and still classifies Quick. Under exploration, the same model identifies the same violation and correctly escalates. The think-carefully instruction lets the model observe depth without committing to it; exploration forces a committed implication statement that anchors classification. This pattern is consistent across all 5 cases where exploration rescues think-carefully failures. Effect is capability-moderated (I suppose) DeepSeek and Claude Haiku drive the pooled result. Gemini Flash is near-ceiling at baseline (3/200 errors). Claude Sonnet shows a mixed 3:2 discordant pattern. The weaker the model, the larger the benefit. I hypothesise this relationship reverses at >100K context loads, where even capable models would need the scaffold but this is untested and stated as a falsifiable prediction. Key limitations I want to be upfront about: Post-hoc expansion: Benchmark was expanded after R2 yielded p = 0.065 at N=120. The categories expanded (CC and DC) were chosen based on R1/R2 discrimination patterns, not blindly. All claims are exploratory, not confirmatory. Circularity risk: Ground truth labels were generated by Claude Sonnet 4.6 - one of the four models subsequently tested. Partially mitigated by 93.3% human agreement on N=30 subset, but the 160 expanded prompts have zero interrater validation. Heterogeneous effect: Pooled result is driven by 2 of 4 models. Gemini Flash near-ceiling, Sonnet mixed. The claim is better scoped as "helps models with moderate baseline error rates." Narrow scope: All prompts are short (<512 tokens). Proprietary models only. Single API run for the primary dataset. Cross-dataset ablation: R3 mechanism ablation is a separate API run, not within-run. The expl2 vs. think equivalence (p = 0.77) could be affected by run-to-run variance (bounded at +-2 errors, but still). Single author: I designed, built, labelled, and analysed everything. No independent replication. The paper has 18 explicitly stated limitations in total - I'd be glad to receive your opinions and possibly hints :). Links Paper (32 pages with full appendices, all data table) Benchmark and experimental data What I'm looking for Interrater validation: If anyone is willing to label any number of trap prompts as Quick vs. requires-deeper-processing (binary or with categories), this would directly address the biggest methodological weakness. The prompts and contexts are in the repo. Methodological critique: What did I miss? What would you do differently? Replication on open-weight models: All my data is on commercial APIs. Would love to see if the pattern holds on Llama, Kimi, Qwen etc. ArXiv endorsement: I'm an independent researcher without academic affiliation. If anyone with cs.CL or cs.AI endorsement privileges finds the work credible enough, I'd appreciate help getting it on arXiv. submitted by /u/herki17 [link] [comments]