Researchers from MIT and Sakana AI have developed SIFT (Self-Improvement via Fast Tree-search), a framework designed to reduce the computational cost of recursively improving coding agents. Instead of fully evaluating every candidate modification, SIFT uses an LLM judge to rank promising agent changes before sending them through expensive benchmark evaluations.
The approach achieved a 35.1% score on the full Polyglot benchmark with an o3-mini coding agent after 30 expansion steps, compared with 30.7% reported for the Darwin Gödel Machine (DGM) after 80 search nodes. The researchers also report substantially lower compute requirements in several configurations.
The work is described in the paper Self Improvement via Fast Tree-search, authored by Xinghong Fu of MIT and Aravinth Kulanthaivelu and Yutaro Yamada of Sakana AI. The paper was posted to arXiv on September 17, 2026.
Quick Summary
- SIFT is a self-improvement method developed by researchers from MIT and Sakana AI.
- It uses LLM-based judging to identify promising agent modifications before expensive benchmark evaluation.
- SIFT reached 35.1% on Polyglot with an o3-mini coding agent after 30 expansion steps.
- The approach reduces the amount of compute spent on evaluating weaker candidates.
- A separate Qwen3-Coder-30B experiment completed its search with 224 CPU hours and $34.3 in API costs.
- On TerminalBench, the SIFT-selected agent improved from 29.2% to 36.7% in the reported experiment.
- The research demonstrates a more compute-efficient approach to recursive improvement of coding agents, rather than proving that coding agents can universally improve themselves.
What SIFT Changes in Self-Improving AI Agents?
Self-improving coding agents work by modifying the software that controls the agent itself. A higher-level model examines the current agent, identifies weaknesses, creates a modification and produces a new version. That new version is then evaluated, with the results feeding into another round of improvement.
The problem is that evaluating each candidate can be expensive. Existing approaches can repeatedly run coding agents against benchmark tasks to determine whether a modification actually improves performance. The SIFT researchers identify this evaluation stage as a major runtime bottleneck.
SIFT separates the search process from expensive benchmark evaluation.
After an agent produces a candidate modification, an LLM judge compares it with existing candidate agents using pairwise comparisons. Those win-loss results are aggregated through a regularized Bradley–Terry model, producing a ranking signal that helps determine which branches of the search should receive further attention.
Only candidates that appear promising through the combined signals are prioritized for more expensive downstream evaluation.
How the SIFT Framework Works?
SIFT maintains an archive of different versions of an agent harness and uses several signals to decide which versions should generate new descendants.
The LLM judge does not run the benchmark itself. Instead, it examines candidate implementations and determines which one it considers stronger in a pairwise comparison. The resulting preferences are accumulated and converted into a global ranking using the Bradley–Terry model.
The system then combines judge rankings with benchmark-accuracy information and an exploration term when selecting parent nodes for further self-improvement.
This creates a disaggregated search pipeline in which agent expansion and expensive evaluation can proceed in parallel. The researchers say this allows the search to continue exploring promising candidates without waiting for every benchmark evaluation to finish.
The method therefore does not eliminate evaluation. Instead, it uses a cheaper intermediate signal to decide where expensive evaluation resources should be spent.
SIFT Reaches 35.1% on Polyglot
The main Polyglot experiment compares SIFT with previous self-improvement approaches including SICA, DGM and HGM.
Polyglot contains 225 coding tasks across C++, Go, Rust, Java, JavaScript and Python. For the search process, the researchers use a smaller 50-task subset and reserve the complete 225-task benchmark for final evaluation.
With Qwen3-Coder-30B as the coding model, SIFT achieved 31.1% on the full Polyglot benchmark when Qwen3-Coder-480B served as the judge. Using GPT-5.4 as the judge raised the result to 32.0%.
A separate experiment started with the DGM agent harness and used o3-mini as the coding model. SIFT reached 35.1% with GPT-5.4 acting as the judge after 30 expansion steps. DGM reached 30.7% in the researchers’ comparison after 80 search nodes.
The researchers repeated the o3-mini experiment three additional times and obtained results ranging from 32.0% to 35.6%, according to the paper.
| Method | Coding model | Judge | Polyglot accuracy |
|---|---|---|---|
| Base Agent | o3-mini | None | 14.2% |
| DGM | o3-mini | None | 30.7% |
| SIFT | o3-mini | GPT-5.4 | 35.1% |
| SIFT | o3-mini | GPT-5-mini | 31.6% |
| SIFT | Qwen3-Coder-30B | Qwen3-Coder-480B | 31.1% |
| SIFT | Qwen3-Coder-30B | GPT-5.4 | 32.0% |
The table values come from the paper’s full Polyglot evaluation.
The Compute Savings Come From Selective Evaluation
The efficiency difference is central to SIFT.
In the Qwen3-30B configuration using Qwen3-Coder-480B as the judge, the researchers report 224 CPU hours, $34.3 in API costs and 6.7 hours of wall-clock time for a 30-step search. The paper describes this as one-tenth of the CPU usage of the DGM baseline used for comparison.
The o3-mini experiment that reached 35.1% used 42 CPU hours, completed in under five hours and consumed $150 in API credits. This is a different experimental configuration from the $34.3 Qwen3 run, so the figures should not be combined.
The underlying reason for the savings is straightforward: an individual LLM judge comparison is considerably cheaper than running a complete Polyglot evaluation. The researchers estimate a single judge comparison at roughly $0.044 and 0.0042 CPU hours under their default setup, while a full Polyglot-50 evaluation costs substantially more.
SIFT Also Shows Results on TerminalBench
The researchers tested the approach beyond Polyglot using TerminalBench 2.1, a benchmark for long-horizon tasks executed inside terminal environments.
For this experiment, GPT-5-mini served as the coding model, GPT-5 handled diagnosis and self-improvement, and GPT-5.4-high served as the pairwise judge. The starting agent achieved 29.2% on repeated full evaluations. The agent selected by the SIFT judge reached 36.7%.
The experiment also illustrates an important limitation of judge-based search: the judge is useful for ranking candidates, but it is not a replacement for actual benchmark evaluation.
The researchers found that GPT-5 as a weaker judge still produced a strong result of 34.5%, but its top-ranked candidate was not the best agent discovered during that search. GPT-5.4-high performed better at selecting among the strongest candidates.
Why the LLM Judge Matters?
One of the more important findings is that the judge provides a signal before full benchmark results are available.
Because the judge examines the candidate implementations themselves, it can identify potentially useful modifications even when a candidate has not yet undergone complete downstream evaluation. This allows the search process to continue exploring promising branches rather than waiting for every candidate to receive a full benchmark score.
The paper reports that the judge’s ranking signal correlated with full-benchmark performance on TerminalBench. GPT-5.4-high achieved a Spearman correlation of 0.72 across the evaluated candidates, while GPT-5 achieved 0.71.
However, the researchers also found that judge quality becomes particularly important near the top of the search frontier. A cheaper judge can help direct exploration, but a stronger judge may be more reliable when choosing between the best candidates.
What SIFT Means for Self-Improving Coding Agents?
SIFT does not create an unrestricted autonomous programmer that continuously improves without external evaluation. Its contribution is more specific: it provides a more efficient search strategy for modifying and evaluating coding-agent harnesses.
The experiments suggest that an LLM can provide a useful intermediate ranking signal, allowing researchers to spend expensive benchmark compute selectively rather than uniformly across the search tree.
The researchers also report that SIFT-discovered agent harnesses transferred to other coding models, including GPT-5-mini and GPT-5.4-mini, while retaining performance improvements on Polyglot.
That transferability is significant within the scope of the experiments because it suggests the improvements were not limited entirely to the particular model used during the search.
Still, the findings remain benchmark-based research results. They demonstrate that SIFT can make a particular class of recursive self-improvement experiments more efficient; they do not establish that self-improving coding agents have solved the broader problem of reliable autonomous software development.
For AI research, the more immediate development is the reduction of the evaluation bottleneck. By combining LLM-based judging, tree search and parallel evaluation, SIFT offers a way to explore more candidate agent designs under a fixed compute budget.
Also Read –
ScientistTwo Automates Autonomous AI Research
AgentCard Enables AI Agents to Make Payments and Buy Services
Grok Bot Galaxy: xAI to Livestream Product Build With AI Agents
Source
SIFT paper PDF and experimental results
Darwin Gödel Machine paper on OpenReview
