betaFeedback

WorksComputer Science

Speculative Forking: Turning Idle Wait into Parallel Exploration for Repository Environment Setup

Abstract

Before developers can use a software project, they must first get it to run. This often requires installing the right language runtime, system packages, build tools, and test commands. Recent LLM-based agents automate environment setup by inspecting a repository, writing setup scripts, running them, and repairing the resulting errors. However, these agents still follow a sequential trial-and-error loop: they try one setup route, wait for slow commands to finish, observe the failure, and only then decide what to try next. Because environment commands often take long to run, this sequential workflow makes setup slow and limits exploration to one route at a time. We present SpecBuild, an LLM-based environment setup system designed to be both faster and more successful through speculative forking. SpecBuild explores candidate setup branches in parallel, returns the first committed environment, and discards the rest. It applies this design at two granularities: strategy-level forking explores alternative setup routes, such as different base images and dependency policies, while command-level forking predicts failures of running commands and prepares repair branches before those failures are observed. We evaluate SpecBuild on Multi-Docker-Eval, covering 334 tasks from 40 repositories and 9 programming languages. Across three backbone models, SpecBuild improves the success rate by 6.4 to 12.0 percentage points over the strongest baseline, while reducing average setup time by 22.4% to 41.6%. These results show that LLM-based environment setup need not trade speed for reliability: parallel speculative exploration can make agents both faster and more successful.

Introduction

Before developers can modify, test, debug, or reuse a software project, they must first get it to run. Running a project’s tests is central to validating code changes in both development and software-engineering research [1]. This requires matching language runtimes, system packages, build tools, environment variables, and test commands to the project at hand. Containerization makes this setup explicit through artifacts such as Dockerfiles, which have been widely studied as software-engineering and DevOps artifacts [2, 3, 4]. Yet writing these artifacts remains difficult: developers report Docker and Docker-Compose specifications as time-consuming, and prior work observes that they require system-administration knowledge and project-specific adaptation [2], [5], [6]. Environment setup is therefore a practical bottleneck for developers before they can run tests, reproduce bugs, or validate fixes.

This bottleneck is amplified by recent efforts to make software-engineering tasks verifiable at scale. Benchmarks and training pipelines for coding agents require executable environments in which tests can be run against real repositories [7, 8, 9, 10, 11, 12]. Recent systems now scale this construction to tens of thousands or even millions of environments [13], [14]. In this setting, setup time is no longer a one-time inconvenience: each failed or slow construction attempt becomes a recurring wall-clock cost for evaluation, data generation, and developer workflows.

Recent work has started to automate environment setup with LLM-based agents. These agents inspect repository files, generate setup scripts, run them in containers, read execution errors, and revise the scripts until the tests pass or a budget is exhausted [1], [15], [16]. Newer systems broaden this automation across languages, repositories, and training-data pipelines [16, 17, 18]. This feedback-driven loop also appears in broader software-engineering agents, which execute tools, observe feedback, and use that feedback to plan later actions [19, 20, 21]. In environment setup, however, the loop is typically sequential: the agent tries one setup route, waits for slow commands such as package installation, dependency resolution, and compilation to finish, observes the result, and only then decides what to try next [1], [16].

This sequential structure exposes two uncertainties in environment setup. First, the agent faces route uncertainty: it does not know which setup route, including choices such as the base image, runtime, package manager, and dependency policy, will build the repository. A sequential loop can validate only one route at a time, so failed routes consume time and iteration budget before other plausible routes are tried. Second, the agent faces command-outcome uncertainty: slow setup commands may fail, but a sequential loop waits for the failure before preparing a repair. Together, these uncertainties couple wall-clock time and success: slow feedback makes each trial expensive, and one-route-at-a-time search limits how broadly the agent can explore.

Figure 1. Timeline comparison on polarsignals/frostdb. The sequential agent waits for go mod download to fail before diagnosing and retrying, whereas speculation predicts the missing Go toolchain during the idle waiting interval and prepares an apk-based repair branch in advance.

Our insight is to address both uncertainties with speculative forking. Rather than waiting for one setup future to fail before considering another, SPECBUILD explores candidate setup branches in parallel, returns the first committed environment, and discards the rest. We apply this primitive at two granularities. Strategy-level forking explores alternative setup routes, such as different base images, runtimes, and dependency policies, addressing route uncertainty. Command-level forking predicts the failure of a currently running command and prepares a repaired branch before the failure is observed, addressing command-outcome uncertainty. In both cases, speculation is predict-then-verify: branches only matter if real execution validates them.

We implement SPECBUILD for LLM-based environment setup and evaluate it on Multi-Docker-Eval [22], a benchmark of 334 environment-construction tasks drawn from 40 real-world repositories and 9 programming languages. Across three backbone models, SPECBUILD improves the success rate by 6.4 to 12.0 percentage points over the strongest baseline, while reducing average setup time by 22.4% to 41.6%. The results support the central claim of this paper: LLM-based environment setup need not trade speed for reliability, because parallel speculative exploration can make agents both faster and more successful.

In this paper, we make the following contributions:

  • A dual objective for environment setup. We formulate LLM-based environment setup as a dual-objective problem: improve the success rate while reducing wall-clock setup time. This framing captures the practical cost that developers and large-scale evaluation pipelines pay when sequential setup attempts fail slowly.

  • Speculative forking and its two granularities. We introduce speculative forking, a fork, explore, commit, and discard primitive over isolated setup branches, at two granularities: strategy-level forking races alternative setup routes, while command-level forking prepares repairs for likely command failures in advance.

  • Implementation and multi-language evaluation. We implement SPECBUILD and evaluate it on Multi-Docker-Eval across three backbone models and 9 programming languages, measuring end-to-end success and time, isolating each granularity’s contribution, analyzing the branch-budget trade-off, and illustrating the mechanism through a case study. We release our implementation at https://anonymous.4open.science/r/Speculative-Forking-C907.

Background and Motivation

Environment setup is a developer-facing problem before it is a benchmark abstraction. Before developers can modify, test, or reproduce a project, they must first install the right language runtime, system packages, build tools, and commands. Containerization makes this setup explicit through artifacts such as Dockerfiles, which are widely studied as software-engineering and DevOps artifacts [2, 3, 4]. Yet these artifacts remain difficult to write: developers report Docker and Docker-Compose specifications as time-consuming, while prior work observes that they often require system-administration knowledge and project-specific adaptation [2, 5, 6].

Problem Formulation

We study environment construction for verifiable software-engineering tasks [7, 9]. Following Multi-Docker-Eval [22], each task provides a repository, a reported issue, and the developer’s corresponding patch. The system produces a setup configuration (B,P,T)(B, P, T): a base image BB, installation commands PP, and a test script TT for executing issue-related tests.

Environment correctness is assessed by whether the setup supports reproducing the issue and validating its fix. We use the benchmark’s fail-to-pass (F2P) criterion: the tests fail before the patch is applied and pass afterward under the same environment configuration.

Existing methods optimize their pipeline targeting the success rate alone. Yet time matters in both day-to-day development and large-scale automation. For a developer, each failed setup route blocks testing, reproduction, and validation until slow package installation, dependency resolution, @page 2/12 starts_mid=0 ends_mid=1

Figure 1 (PDF p. 2). Timeline comparison on polarsignals/frostdb. The sequential agent waits for go mod download to fail before diagnosing and retrying, whereas speculation predicts the missing Go toolchain during the idle waiting interval and prepares an apk-based repair branch in advance.

Our insight is to address both uncertainties with speculative forking. Rather than waiting for one setup future to fail before considering another, SPECBUILD explores candidate setup branches in parallel, returns the first committed environment, and discards the rest. We apply this primitive at two granularities. Strategy-level forking explores alternative setup routes, such as different base images, runtimes, and dependency policies, addressing route uncertainty. Command-level forking predicts the failure of a currently running command and prepares a repaired branch before the failure is observed, addressing command-outcome uncertainty. In both cases, speculation is predict-then-verify: branches only matter if real execution validates them.

We implement SPECBUILD for LLM-based environment setup and evaluate it on Multi-Docker-Eval [22], a benchmark of 334 environment-construction tasks drawn from 40 real-world repositories and 9 programming languages. Across three backbone models, SPECBUILD improves the success rate by 6.4 to 12.0 percentage points over the strongest baseline, while reducing average setup time by 22.4% to 41.6%. The results support the central claim of this paper: LLM-based environment setup need not trade speed for reliability, because parallel speculative exploration can make agents both faster and more successful.

In this paper, we make the following contributions:

  • A dual objective for environment setup. We formulate LLM-based environment setup as a dual-objective problem: improve the success rate while reducing wall-clock setup time. This framing captures the practical cost that developers and large-scale evaluation pipelines pay when sequential setup attempts fail slowly.

  • Speculative forking and its two granularities. We introduce speculative forking, a fork, explore, commit, and discard primitive over isolated setup branches, at two granularities: strategy-level forking races alternative setup routes, while command-level forking prepares repairs for likely command failures in advance.

  • Implementation and multi-language evaluation. We implement SPECBUILD and evaluate it on Multi-Docker-Eval across three backbone models and 9 programming languages, measuring end-to-end success and time, isolating each granularity’s contribution, analyzing the branch-budget trade-off, and illustrating the mechanism through a case study. We release our implementation at https://anonymous.4open.science/r/Speculative-Forking-C907.

Background and Motivation

Environment setup is a developer-facing problem before it is a benchmark abstraction. Before developers can modify, test, or reproduce a project, they must first install the right language runtime, system packages, build tools, and commands. Containerization makes this setup explicit through artifacts such as Dockerfiles, which are widely studied as software-engineering and DevOps artifacts [2, 3, 4]. Yet these artifacts remain difficult to write: developers report Docker and Docker-Compose specifications as time-consuming, while prior work observes that they often require system-administration knowledge and project-specific adaptation [2, 5, 6].

Problem Formulation

We study environment construction for verifiable software-engineering tasks [7, 9]. Following Multi-Docker-Eval [22], each task provides a repository, a reported issue, and the developer’s corresponding patch. The system produces a setup configuration (B,P,T)(B, P, T): a base image BB, installation commands PP, and a test script TT for executing issue-related tests.

Environment correctness is assessed by whether the setup supports reproducing the issue and validating its fix. We use the benchmark’s fail-to-pass (F2P) criterion: the tests fail before the patch is applied and pass afterward under the same environment configuration.

Existing methods optimize their pipeline targeting the success rate alone. Yet time matters in both day-to-day development and large-scale automation. For a developer, each failed setup route blocks testing, reproduction, and validation until slow package installation, dependency resolution, or compilation commands finish [1], [6]. At scale, recent pipelines build executable environments to train and evaluate coding agents [7, 8, 9, 10]. Recent environment-construction systems further scale this process to tens of thousands or millions of environments [13], [14], where the per-instance build time becomes a first-order cost. We therefore treat the wall-clock time to build the environment as a first-class objective, posing the task as two goals at once: raise the success rate while cutting build time. To our knowledge, this is the first method to optimize the time cost of LLM-based environment construction rather than only report it.

Motivating Example

To see why this is hard, consider how current agents construct an environment. A typical system such as SWE-Builder [16] works in a loop: it inspects the repository’s files (manifests, READMEs, CI configs), drafts a setup script, runs it in a container, reads whatever error the run produces, and revises the script, often re-inspecting the repository, before trying again. It repeats this loop of analysis, execution, and diagnosis until the tests pass or a budget runs out. The loop is sequential: the agent issues one script, waits for it to finish, and only then learns whether it worked. This waiting is the structural bottleneck. A single installation command may still take as long as it takes, but the sequential loop makes every next decision depend on that command’s completion and failure.

On polarsignals/frostdb, a Go columnar database from Multi-Docker-Eval whose tests build only once a working Go toolchain is present, this sequential loop is slow, with progress blocked until each failure is observed (Figure 1). Starting from a base image without the toolchain, the agent’s first setup round ends in failure on the missing Go toolchain after 19.3 minutes; it then reruns with Go installed, a further 9.1 minutes, spending about 28.5 minutes across two sequential rounds. No useful progress is possible until that first failure surfaces, and no repair is ready when it does.

SPECBUILD turns this waiting into useful work. While the first round is still running, it predicts that the setup will fail for a missing Go toolchain and prepares the repair apk add --no-cache go on a parallel branch. The prediction is platform-aware: seeing an Alpine base image, the model installs with apk rather than apt, and it does so from reasoning alone, with no cached history. When the failure surfaces, the prepared branch already carries a working toolchain and is adopted directly, so the setup succeeds without a second round. The task finishes in 11.4 minutes, saving about 17 minutes over the sequential run, and the committed environment passes the same F2P check.

This is speculation in the predict-then-verify sense: the predicted object is a command’s outcome, and verification is its real execution. At the higher level, SPECBUILD also speculates over setup routes: it analyzes the repository, plans a primary route, and creates complementary routes that hedge against different environment assumptions. The routes run independently, and the first committed environment is returned while the remaining branches are discarded. Thus, strategy-level forking selects among plausible routes, while command-level forking hides wait-then-repair latency within a route. We formalize speculative forking and its two granularities in Section III.

Approach

Overview

SPECBUILD replaces the sequential agent’s one-route-at-a-time process with parallel speculative exploration, which at once hides the latency of slow commands and covers more of the configuration space than a single route. It analyzes the repository and plans several candidate routes (Section III-B), races them as parallel branches that each run an iterative setup loop, and within that loop speculates on the failure of individual commands (Section III-C); Section III-D ties the two together in an end-to-end workflow. We introduce speculative forking, a design that explores setup alternatives before a sequential agent would reach them.

Figure 2 overviews the design. Given an input task, SPECBUILD analyzes repository signals such as the snapshot, metadata, issue, and patch, and plans complementary setup routes. At the strategy level, these routes run as parallel branches. Each branch then follows the same iterative setup loop: plan a setup script, execute it in a container, and verify the resulting environment against the tests. Inside the execution step, command-level speculation runs the original command and a candidate repair in parallel. If the original command fails and the candidate repair succeeds, the repaired state is adopted immediately; otherwise the candidate repair is discarded. The first committed environment is returned, and the non-winning branches are discarded. This parallel breadth matches the structure of the problem: the configuration that builds is sparsely distributed across many routes, so exploring several at once reaches what a single sequential route cannot.

Overview of SPECBUILD

Figure 2. Overview of SPECBUILD. Given a repository, SPECBUILD plans complementary setup routes that run as parallel branches, each repeatedly planning a setup script, executing it, and verifying the environment. Inside execution, command-level speculation runs the original command and a candidate repair in parallel, adopting whichever validates. The first committed environment is returned; the remaining branches are discarded.

All exploration follows the same validation rule: run candidate work early, return the first committed environment, and discard branches that are no longer needed. The two granularities differ only in what they fork and in what counts as reaching the goal. Both are speculation in the predict-then-verify sense: work that may be needed is done ahead of time and verified by real execution, so a correct branch is kept and a wrong one is discarded. The two granularities address two axes of uncertainty. Strategy-level forking (Section III-B) handles uncertainty between routes, which configuration will build: it anticipates how a whole route could fail and hedges across routes accordingly. Command-level forking (Section III-C) handles uncertainty within a route, whether a given command will fail, making an explicit per-command prediction of that failure. Both anticipate failure and differ only in granularity, a whole route versus a single command.

Strategy-Level Forking

Strategy-level forking addresses uncertainty over which setup route will build the repository. Real repositories rarely document their exact environment, so several plausible configurations coexist and which one builds is revealed only by trying. A route is a setup direction: a base-image family, a runtime version, a package manager, and a dependency policy. For rootdb, three routes start from the official images golang:1.20-alpine, golang:1.19-bookworm, and golang:1.19-bullseye. Rather than guess a single route, SPECBUILD speculates across them: it pursues several plausible routes in parallel and lets execution decide which one builds.

Generating routes. An analysis phase reads the repository’s build signals, such as manifests, CI test commands, and project metadata, and summarizes them into a structured profile. Conditioned on this profile, SPECBUILD plans a primary route, the setup direction most likely to build the repository, and, by reasoning about how that route could fail, such as a wrong base-image family, an incompatible runtime version, or a mismatched package manager or dependency policy, composes a small set of complementary routes that hedge those distinct failure modes. Because the primary and its hedges are planned together before any route runs, they cover different environment assumptions by construction rather than by chance, which is what distinguishes route racing from drawing independent samples (§ 6-B).

The branch iteration. Each route runs as an isolated branch that repeats a three-step loop: it plans a setup script from the profile, the route, and any feedback; executes the script in a container; and verifies the result using test commands or scripts selected or written by its agent. A branch iterates this loop for up to mm rounds, and the diagnostics of a failed round condition the next. It commits a candidate environment when its agent considers the setup complete; a branch that reaches the iteration limit without committing terminates without a submission. Command-level speculation (Section III-C) operates inside the execute step of this same loop.

Racing to a winner. The branches run concurrently, bounded by a configurable budget of kk branches. The first committed environment is returned, and the remaining branches are cancelled and discarded. If no branch commits before all branches terminate or the task times out, no environment is submitted. No route is privileged, so a failure on any single one never stalls the task. This is where both gains originate: racing reaches a working configuration that a single route would miss, and it avoids the wall-clock a sequential agent spends exchanging dead ends one after another. Because the branches race, the first to commit cancels the rest: no branch runs past the moment of commit, and a route that hits a dead end is abandoned within a few rounds. The branch budget kk and the per-task speculation budget cap the total work, so racing explores breadth without unbounded cost; § 6-D analyzes the effect of the branch budget.

Command-Level Speculation

Within the execute step of that same loop, individual commands run one after another. Command-level forking addresses the uncertainty over whether a given command will fail, and turns the time spent running it, often minutes for an install or a compile, into preparation for its repair. The design rests on an asymmetry: a wrong guess costs only a millisecond-scale fork and one short, bounded repair attempt, whereas a right guess removes an entire round of failure, diagnosis, and retry. Because the downside is so much smaller than the upside, SPECBUILD can speculate opportunistically. On frostdb, the execute step runs the build, and SPECBUILD anticipates that it will fail for a missing Go toolchain.

Predicting failures. Before a command runs, SPECBUILD queries an LLM with the repository, its language, the base-image family, and the command, and receives a structured prediction: a failure signature and class, a candidate fix, and a confidence score. For frostdb it predicts GO_MISSING and proposes apk add go. The choice is platform-aware: recognizing an Alpine base image, the model installs with apk rather than apt, and it does so from reasoning alone, with no cached history.

When to speculate. The value of speculation grows with a command’s running time and its chance of failing, so SPECBUILD speculates only on setup-relevant commands such as dependency installation, building, and compilation, and skips trivial ones like cd or echo. A per-task budget bounds the number of predictions and their cost.

Speculative repair via fork-both. SPECBUILD runs two attempts concurrently: one executes the original command, the other applies the predicted fix and then the command. If the original succeeds, the repair is discarded; if the original fails while the repair succeeds, the repair is adopted, sparing a full diagnose-and-retry round; if both fail, the speculative repair is discarded and the branch continues from the original failure feedback. A misprediction therefore merely wastes a bounded parallel attempt. This is why fork-both is preferable to acting on a prediction directly: the predicted fix is verified against the real command rather than trusted.

End-to-End Workflow and Validation

The two granularities run under a single driver. Strategy-level forking launches the candidate routes as parallel branches and returns the first committed environment; each branch runs the plan, execute, and verify loop; and within a branch, risky commands may invoke command-level fork-both, which is the point where the two levels meet.

Each branch follows its agent’s own checks and completion criteria when deciding whether to commit. Command-level forking preserves the original execution path while evaluating a repair in an isolated branch; a discarded repair therefore leaves the retained environment unchanged. Speculation changes the timing and ordering of exploration while retaining the agent’s checks and commit decision. With a single branch and command-level speculation disabled, SPECBUILD reduces to the sequential base agent.

Experimental Setup

We organize the evaluation around four research questions, followed by a case study.

  • RQ1 (Effectiveness). How effectively does SPECBUILD reduce the wall-clock time of environment construction while improving its success rate, compared with state-of-the-art agents?

  • RQ2 (Ablation). How much does each speculation level, strategy-level and command-level, contribute to the time and success gains?

  • RQ3 (Generality). How well do the gains generalize across the diverse programming-language ecosystems of the benchmark?

  • RQ4 (Branch Sensitivity). How many parallel branches does SPECBUILD need?

The rest of this section describes the benchmark, baselines, metrics, and implementation used to answer them.

Benchmark

We evaluate all methods on Multi-Docker-Eval [22], a benchmark designed specifically for automated environment construction. It consists of 334 tasks drawn from 40 real-world repositories spanning 9 programming languages (C, C++, Go, Java, JavaScript, PHP, Python, Ruby, and Rust), each following the fail-to-pass criterion of Section II-A. This breadth of languages and build ecosystems within a single benchmark enables a controlled cross-language comparison under consistent evaluation conditions.

Baselines

We compare SPECBUILD against four state-of-the-art environment-construction agents. Repo2Run [15] constructs executable Python environments from repository context; because it is Python-specific, we include it in the per-language analysis rather than the full multi-language comparison. RePoLaunch [17] automates dependency resolution, repository build, and test-result extraction across languages and platforms. SWE-Builder [16] inspects a repository, generates a setup script, runs it, and revises it from execution errors. MEn-vAgent [18] retrieves environments from previously solved repositories, then reuses and patches them for a new project to avoid building from scratch. RQ2 further includes two ablation controls, Sequential (More Budget) and Best-of-N (Naive Parallel), to test whether the gains come from a larger sequential budget or from running independent workers in parallel.

Metrics

Following Multi-Docker-Eval [22], we report five metrics for each method.

  • Success Rate: the percentage of tasks whose constructed environment is verified as correct. Following Multi-Docker-Eval [22], verification assesses whether the environment can execute the issue-related tests to reproduce the reported issue and validate its fix, as described in Section II-A.

  • Commit Rate: the percentage of tasks for which the agent commits an environment for evaluation, a self-reported signal that the agent judged its setup ready; it does not require the environment to verify the change, so a high Commit Rate alone does not imply success.

  • Average Time: the average wall-clock time per task; our primary efficiency metric.

  • Token Consumption: the average input and output tokens used per task during environment construction.

  • Average Cost: the average LLM API cost per task in US dollars.

Models and Implementation

To assess robustness across reasoning backbones, we run SPECBUILD and all baselines end-to-end with three state-of-the-art LLMs spanning open-source and proprietary models: DeepSeek-V4-Flash [23], MiMo-V2.5-Pro [24], and GPT-5.5 [25]. Unless noted otherwise, SPECBUILD uses a branch budget of k=5k = 5, an iteration limit of m=15m = 15 per branch, a per-task budget of 15 speculative predictions, temperature 0, and a 5400 s timeout. All experiments run on a single server with two Intel Xeon Platinum 8259CL CPUs (96 threads) and 128 GiB of RAM under Ubuntu 22.04.

Experimental Results

RQ1: Effectiveness

Setup. We compare SPECBUILD against all baselines on the full Multi-Docker-Eval set of 334 tasks across the three backbone LLMs, reporting Success Rate, Commit Rate, and average time per task (Table I), under the configuration of Section IV-D.

ModelMethodSuccess Rate (%)Commit Rate (%)Avg. Time (min)Avg. Input Tokens (K)Avg. Output Tokens (K)Avg. Cost ($)
DeepSeek-v4-FlashRepoLaunch11.0842.8136.87796.898.870.0359
SWE-Builder17.9634.1366.75142.5935.540.0160
MEnvAgent24.4745.4148.01235.23114.280.0402
SPECBUILD30.8446.7128.04775.3778.060.0483
MiMo-v2.5-ProRepoLaunch14.6763.7755.801313.2715.840.1395
SWE-Builder21.5651.2059.98195.3753.020.0737
MEnvAgent26.6561.3849.38322.31170.490.1819
SPECBUILD38.0256.8933.58832.2664.450.2059
GPT-5.5RepoLaunch23.3562.2746.06884.439.654.2670
SWE-Builder32.3360.7764.88113.8729.921.4434
MEnvAgent46.4061.9726.7888.7418.340.9780
SPECBUILD58.3874.8520.79254.7966.793.1168

Table I. End-to-end performance on the Multi-Docker-Eval benchmark.

SPECBUILD is both faster and more successful. Across all three backbones, SPECBUILD attains the highest Success Rate and the lowest average time of any method. Against the strongest baseline, MEnvAgent in every case, it raises the Success Rate from 24.5% to 30.8% on DeepSeek-v4-Flash, from 26.7% to 38.0% on MiMo-v2.5-Pro, and from 46.4% to 58.4% on GPT-5.5, a gain of 6.4 to 12.0 percentage points. At the same time it cuts average setup time from 48.0 to 28.0, from 49.4 to 33.6, and from 26.8 to 20.8 minutes respectively, a reduction of 22.4% to 41.6%. Both gains are statistically significant. On every backbone, the Success Rate improvement over the strongest baseline is significant under McNemar’s test [26], and the setup-time reduction under the Wilcoxon signed-rank test [27], each paired per task at p<0.005p < 0.005.

The two goals do not trade off. No baseline is at once the fastest and the most successful: SWE-Builder and RepoLaunch are both slow and far less accurate, while MEnvAgent, the most successful baseline, remains much slower than SPECBUILD. SPECBUILD is the only method that leads on both axes, the direct payoff of replacing sequential exploration with parallel speculative exploration.

Commit Rate reflects submission, not success. Commit Rate counts whether the agent submitted an environment it judged ready, which need not coincide with the environment actually working: on MiMo-v2.5-Pro, RepoLaunch commits more often (63.8%) than SPECBUILD (56.9%) but verifies far fewer tasks (14.7% versus 38.0% Success Rate). We therefore report Commit Rate for completeness and read the Success Rate as the measure of success (Section V-C).

Image not extracted

Figure 1. Across three backbones, SPECBUILD raises the Success Rate by 6.4 to 12.0 percentage points over the strongest baseline while cutting average setup time by 22.4% to 41.6%, the only method that is at once the fastest and the most successful.

RQ2: Ablation

Setup. We decompose SPECBUILD’s gain on Multi-Docker-Eval. Building up from a sequential agent, we first add strategy-level forking and then add command-level forking on top, so the third row is the full SPECBUILD configuration. We also add two controls that rule out alternative explanations of the gain:

  • Sequential (More Budget): the sequential agent with a larger budget, set to a comparable token-cost budget, ruling out that the gain comes merely from spending more.

  • Best-of-N (Naive Parallel): five independent base-agent workers run in parallel, matching SPECBUILD’s maximum strategy budget, ruling out that the gain comes merely from running more workers.

The two levels play complementary roles. Adding strategy-level forking primarily improves success, raising the Success Rate from 22.2% to 29.9%, while also cutting average time from 57.4 to 32.7 minutes. This matches its purpose: strategy-level forking addresses route uncertainty by validating several problem-guided setup routes instead of spending the whole budget on one route. Adding command-level forking on top gives the full system, which further cuts average time to 28.0 minutes and raises Success Rate to 30.8%. This matches its purpose as well: command-level forking addresses command-outcome uncertainty by preparing repairs before slow commands fail.

Figure 3. Cross-language comparison on Multi-Docker-Eval: each point is a (method, language) pair; upper-left (higher Success Rate, lower time) is better.

ConfigurationSuccess RateCommitTime (min)Cost ($)
Component ablation
Sequential22.2%31.4%57.40.0144
+ Strategy29.9%42.2%32.70.0449
+ Strategy + Command30.8%46.7%28.00.0483
Controls
Sequential (More Budget)25.1%35.9%81.30.0501
Best-of-N (Naive Parallel)24.8%35.3%52.60.0582

Table 2. Component ablation and controls (DeepSeek-V4-Flash).

More sequential budget does not replace route exploration. Could the gain be explained by SpecBuild simply spending more? The larger-budget sequential control reaches only 25.1% Success Rate, 5.7 pp below SpecBuild, while taking 81.3 minutes and costing about the same as the full system. This shows that deeper sequential search does not resolve route uncertainty: it spends more effort on one trajectory, whereas SpecBuild uses the budget to validate multiple setup routes.

Naive parallelism is not enough. Could the gain be explained by parallelism alone? We build a Best-of-N control where each task launches five independent base-agent workers, matching SpecBuild’s maximum strategy budget. As in SpecBuild, the first worker to commit a candidate environment determines the output. Best-of-N improves over the sequential agent, raising Success Rate from 22.2% to 24.8% and Commit Rate from 31.4% to 35.3%, showing that parallel sampling increases candidate coverage. However, it remains well below SpecBuild’s 30.8% Success Rate and 46.7% Commit Rate, while taking 52.6 minutes per task and costing $0.0582, compared with SpecBuild’s 28.0 minutes and $0.0483. Thus, the gain comes from problem-guided speculation, which allocates complementary setup routes and prepares likely repairs, not from launching independent workers alone.

Finding 2 Strategy-level forking mainly improves success, command-level forking further reduces latency, and neither comparable sequential budget nor 5-way naive parallelism matches the full system.

RQ3: Generality

Setup. We test whether SpecBuild’s gains hold across language ecosystems rather than only within one. We disaggregate the results by language and report the Success Rate, Commit Rate, and average time of each (method, language) pair (Fig. 3).

The gains generalize across languages. SpecBuild’s points cluster in the upper-left region across the language spectrum, while the baselines spread toward the lower-right: it leads on Success Rate in most languages and completes them in 23 to 36 minutes, against the 43 to 81 minutes of SWE-Builder. The gains hold across ecosystems rather than reflecting tuning to any single one.

Success Rate, not Commit Rate, separates the methods. The template-based RepoLaunch and the Python-specialized Repo2Run reach high Commit Rate on the languages they cover, yet their Success Rate stays low: they produce a runnable container that is mistaken for readiness while the test suite remains non-executable. SpecBuild ranks high on both, producing environments that not only run but pass the fail-to-pass check that downstream use requires.

Where the gain narrows. The benefit is smaller on languages dominated by system-level configuration. Go, Python, and JavaScript, with declarative ecosystems and mature package managers, admit a small space of plausible setups that parallel exploration covers efficiently; C++, Java, and Rust instead hinge on system libraries, compiler toolchains, and version-specific builds that are hard to infer, where all methods score low. The contrast is sharp even within one method: RepoLaunch attains 40.0% Success Rate on Go in 13.4 minutes, where a unified toolchain (go build, go mod) maps to a deterministic build, but drops to 10.0% on C while taking 82.8 minutes, over six times longer, as fragmented build systems (CMake, Make, Autotools) force an open-ended search. Here the bottleneck is resolving underspecified build requirements, a challenge orthogonal to search breadth that parallel exploration complements rather than supplants; it narrows but does not reverse SPECBUILD’s advantage.

Finding 3 SPECBUILD’s success and time gains hold across all nine ecosystems of Multi-Docker-Eval, narrowing only where the bottleneck shifts from search breadth to underspecified system-level builds (C++, Java, Rust).

RQ4: Branch Sensitivity

Setup. By default, SPECBUILD does not fix the number of branches: its planner proposes between two and five candidate routes per repository and adapts the count to the project. To study how this budget shapes the cost-benefit trade-off, we sweep a fixed KK from 1 to 5 under DeepSeek-V4-Flash.

The planner self-selects a cost-effective budget. Sweeping fixed KK (Figure 4), Success Rate climbs steeply from 22.2% at K=1K = 1 to 30.8% at K=3K = 3 and then rises only gradually, while average setup time falls sharply from 56.8 to about 29 minutes by K=3K = 3 and stays near its minimum. Because each branch runs its own planning and repair loop, token cost grows with KK, so the marginal success beyond K≈3K \approx3 is bought at a disproportionate cost. The knee is therefore around K=3K = 3, where most of the success gain is realized at near-minimum time while cost stays moderate. Average time edges up slightly at K=5K = 5 largely because the extra environments solved only at a larger budget are the harder, slower ones that smaller budgets abandon, which lifts the mean over solved tasks. SPECBUILD’s adaptive planner averages Kˉplan=2.87\bar{K}_{\mathrm{plan}} = 2.87 routes, about three, landing right at this knee, so it captures most of the multi-route benefit without a tuned budget.

Figure 4. Sensitivity results under DeepSeek-V4-Flash for K=1K = 1 to 5.

Finding 4 SPECBUILD’s planner automatically lands at the efficiency knee, averaging about three routes where fixed-KK success gains flatten and setup time is near its minimum, so it captures most of the multi-route benefit without tuning.

Case Study

This case study illustrates the command-level mechanism rather than the branch budget: we trace one branch to show how a prepared repair is validated by real execution and then adopted or discarded.

A hit is an adopted branch, not a correct diagnosis. Figure 5 traces one rubyzip (Ruby) branch on the ruby:3.2-slim image, where bundle install fails while compiling a native gem extension. At each risky build, SPECBUILD runs the original command and a candidate repair, a system-package install such as apt-get install zlib1g-dev, side by side and adopts whichever the build validates. The guess need not name the true cause: at each step the candidate repair runs in parallel with the original command, and the branch adopts whichever validates, converging to a working environment without a serial diagnosis-and-retry detour; the third speculation is unnecessary, because the build succeeds on its own, and is discarded for the cost of a fork. Because adoption is decided by real execution rather than by the prediction, a wrong or unnecessary bet is discarded without ever changing the environment that is finally committed. This illustrates how an adopted repair removes a retry round while a discarded repair leaves the retained environment unchanged.

Figure 5. Case study: three command-level speculations on one rubyzip branch, two adopted and one discarded.

Headroom that grows with model capability. Because command-level speculation removes a round only when a prepared repair validates a failing command, the latency it hides grows with predictor quality. More accurate predictions create more opportunities to prepare successful repairs before the original commands fail. Ecosystems with canonical fixes, such as Go, already show what a strong predictor delivers, while more open-ended ones, such as Python, leave headroom that more capable backbones close. Command-level speculation therefore converts advances in model reasoning directly into faster setup, and stands to gain as backbone models improve. A perfect predictor would catch every recoverable failure and remove every corresponding round, the ceiling this mechanism approaches as models improve.

Discussion

Command-Level Speculation as a Design Space

Command-level speculation is best seen not as a single heuristic but as a cheap, discardable bet with an asymmetric payoff: a prepared repair is adopted when real execution validates it and discarded otherwise, so correctness never depends on the guess. This opens a concrete design space for future improvement: better failure predictors, stronger repair generators, and policies trained on setup traces would each raise how often a bet is adopted and so hide more latency. Speculative forking thus extends a long line of predict-then-verify systems, from speculative execution to recent speculative LLM and agent-serving work [28, 29, 30].

When Speculation Pays Off

Speculation is most valuable when the setup process exposes long, uncertain commands with structured failure modes. Package installation, dependency resolution, compilation, and test preparation often take minutes before revealing a missing toolchain, a stale module graph, or an absent system library, recurring bottlenecks in environment construction and test-execution agents [1], [6], [22]. In such cases, a correct speculative branch can remove a full wait, diagnose, and retry round from the critical path. The largest gains therefore arise when commands are long enough to expose useful waiting time and when failure modes are regular enough for advance repair work to be validated. This gives a practical scheduling rule: speculate where there is enough latency and enough regularity to make advance work worth doing. This rule is also a deployment knob: where wall-clock latency dominates, the branch and speculation budgets control how much parallel exploration to spend, and SpecBuild sets this adaptively rather than by hand (§ 6-D).

Route Racing versus Naive Parallelism

Strategy-level forking may look like simply running several setup attempts in parallel, but the advantage is not parallelism alone. Each branch is a distinct, problem-guided setup route rather than an interchangeable sample, and our ablation isolates the difference: at matched cost, route racing outperforms both a larger sequential budget and naive parallelism (§ 6-B). Where a sequential agent deepens a single setup attempt from execution feedback [1], [15], [16], route racing selects the first route whose agent completes.

Command-level forking addresses a different source of latency. It does not race complete routes; it predicts that a running command is likely to fail and prepares a repair before the failure is observed. Together, the two granularities change the schedule of execution-driven setup: strategy-level forking broadens the search over routes, while command-level forking turns command waiting time into repair preparation. Both remain bounded by branch and speculation budgets, and both commit only work validated by real execution.

Threats to Validity

Internal validity. LLM-based agents can vary across model backends and runs, a common issue in recent software-engineering agent evaluations [19], [20]. We control for this by evaluating all methods with the same benchmark, budget, execution harness, and validation scripts within each comparison, and by checking that the main conclusion holds across three backbone models. We also confirm the gains with paired significance tests (McNemar’s test for Success Rate [26], Wilcoxon signed-rank for time [27]; p<0.005p < 0.005).

External validity. We evaluate on Multi-Docker-Eval because it is designed for executable environment construction and covers 334 tasks from 40 repositories and 9 programming languages [22]. This multilingual setting reduces the risk of tuning to one ecosystem, while broader industrial settings remain an important target for future evaluation.

Construct validity. Our two primary metrics match the paper’s objectives: F2P measures whether the environment verifies the patch, and wall-clock time measures setup latency. Following SWE-bench and Multi-Docker-Eval, F2P requires the tests to fail on the original code and pass after the gold patch [22], [31], the executable validation used by current SWE benchmarks and data pipelines [7], [9]. We measure wall-clock time under identical hardware and matched concurrency, so infrastructure variation affects absolute times more than relative comparisons.

Speculative Execution and Decoding

Speculation is a classic latency-hiding principle in computer systems: perform work that may be needed before its necessity is known, commit it when the prediction is validated, and discard it otherwise. This pattern appears in speculative computation and computer architecture [28, 32], thread-level speculation that executes likely future code in parallel [33], and optimistic concurrency control that validates tentative work before committing it [34]. SPECBUILD follows the same systems principle, but applies it to software environment construction: the speculative unit is an isolated build branch, and the validation signal is real execution.

Speculation has recently become central to LLM inference through speculative decoding [29, 35, 36]. A lightweight draft model proposes future tokens, the target model verifies them in parallel, accepted tokens are committed, and rejected tokens are discarded. Follow-up work improves this draft-and-verify loop with multiple decoding heads, feature-level drafting, and self-speculation [37, 38, 39]. More recent agent-serving work extends speculation beyond tokens, speculatively executing likely actions or tools to reduce the latency of sequential agent loops [30, 40, 41]. Closest to our latency-hiding goal, EAGER overlaps LLM code generation with interpreter execution to hide execution latency during code interpretation [42].

SPECBUILD instead speculates on setup routes and likely command failures, returning the first committed environment. This makes speculation valuable in a new setting: long-running environment setup commands, where a correct prediction can remove an entire wait-diagnose-retry round from the critical path.

Automated Environment Construction

Environment setup has long been a software-engineering and DevOps problem rather than only a benchmark artifact. Container specifications such as Dockerfiles are widely used and studied [2, 3, 4], but developers still report Docker and Docker-Compose specifications as time-consuming and knowledge-intensive [5, 6]. Prior work has therefore explored assistance for containerization, including dependency inference from source code [43], Dockerfile generation from knowledge graphs [44], Dockerfile completion [45], base-image recommendation [46], and Dockerfile generation for reproducible research [47]. These works help produce or recommend environment specifications; SPECBUILD focuses on the execution-time process of finding a specification that actually passes validation.

Executable environments are also central to modern software-engineering automation. Benchmarks and training pipelines need tests that can run on real repositories [7, 9, 31], and recent environment benchmarks and datasets scale this need across many repositories and languages [13, 14, 22, 48, 49]. To automate this process, Repo2Run [15] and ExecutionAgent [1] iteratively issue commands and refine setup scripts; SWE-Builder [16] automates environment construction inside an issue-resolution data pipeline; RepoLaunch [17] resolves dependencies, builds repositories, and extracts test results across languages and platforms; and MEn-vAgent [18] reuses and patches retrieved environments instead of always rebuilding from scratch.

These systems share the execution-driven style common to LLM agents for software engineering [19, 20, 50, 51]: run an action, observe feedback, and decide the next step. SPECBUILD keeps the same real-execution feedback, but changes the schedule: it explores alternative setup routes and likely failures while slow commands are still running. This turns waiting time into useful search, targeting both fail-to-pass success and wall-clock time.

Conclusion

LLM-based environment setup remains slow and brittle because agents usually follow a sequential trial-and-error loop: they try one setup route, wait for slow commands to finish, and only then decide what to repair or try next. This paper introduced SPECBUILD, which treats fail-to-pass success and wall-clock time as joint objectives and uses speculative forking to turn waiting time into useful parallel search. Speculative forking supports two granularities: strategy-level route exploration before execution and command-level repair preparation while the original command is still running. On Multi-Docker-Eval, covering 334 tasks from 40 repositories and 9 languages, SPECBUILD improves the Success Rate by 6.4 to 12.0 percentage points over the strongest baseline while reducing average setup time by 22.4% to 41.6% across three backbone models. Speculative forking shows that LLM-based environment setup need not trade speed for reliability: exploring candidate branches in parallel and returning the first committed environment makes agents both faster and more successful.

Data Availability

To support reproducibility, all related code, scripts, and experimental data are available at https://anonymous.4open.science/r/Speculative-Forking-C907.

References

  1. [1]I. Bouzenia and M. Pradel, “You name it, i run it: An llm agent to execute tests of arbitrary projects,” Proceedings of the ACM on Software Engineering, vol. 2, no. ISSTA, pp. 1054–1076, 2025.arxiv.org/abs/2412.10133
  2. [2]J. Henkel, C. Bird, S. K. Lahiri, and T. Reps, “Learning from, understanding, and supporting devops artifacts for docker,” in Proceedings of the ACM/IEEE 42nd international conference on software engineering, 2020, pp. 38–49.DOI
  3. [3]J. Cito, G. Schermann, J. E. Witten, P. Leitner, S. Zumberi, and H. C. Gall, “An empirical analysis of the docker container ecosystem on github,” in 2017 IEEE/ACM 14th International Conference on Mining Software Repositories (MSR). IEEE, 2017, pp. 323–333.
  4. [4]K. Eng and A. Hindle, “Revisiting dockerfiles in open source software over time,” in 2021 IEEE/ACM 18th International Conference on Mining Software Repositories (MSR). IEEE, 2021, pp. 449–459.arxiv.org/abs/2103.12298
  5. [5]D. Reis, B. Piedade, F. F. Correia, J. P. Dias, and A. Aguiar, “Developing docker and docker-compose specifications: A developers’ survey,” IEEE Access, vol. 10, pp. 2318–2329, 2021.DOI
  6. [6]G. Rosa, M. Astropoalo, S. Scalabrino, G. Bavota, and R. Oliveto, “Automatically generating dockerfiles via deep learning: Challenges and promises,” arXiv preprint arXiv:2303.15990, 2024.arxiv.org/abs/2303.15990
  7. [7]J. Pan, X. Wang, G. Neubig, N. Jaitly, H. Ji, A. Suhr, and Y. Zhang, “Training software engineering agents and verifiers with swe-gym,” arXiv preprint arXiv:2412.21139, 2024.arxiv.org/abs/2412.21139
  8. [8]J. Yang, K. Lieret, C. Jimenez, A. Wettig, K. Khandpur, Y. Zhang, B. Hui, O. Press, L. Schmidt, and D. Yang, “Swe-smith: Scaling data for software engineering agents,” Advances in Neural Information Processing Systems, vol. 38, 2026.arxiv.org/abs/2504.21798
  9. [9]N. Jain, J. Singh, M. Shetty, L. Zheng, K. Sen, and I. Stoica, “R2e-gym: Procedural environments and hybrid verifiers for scaling open-weights swe agents,” arXiv preprint arXiv:2504.07164, 2025.arxiv.org/abs/2504.07164
  10. [10]D. Yuan, W. Wu, Z. Wang, X. Zhao, H. Zhang, and D. Zhao, “Swe-minisandbox: Container-free reinforcement learning for building software engineering agents,” arXiv preprint arXiv:2602.11210, 2026.arxiv.org/abs/2602.11210
  11. [11]J. Chen, H. Huang, Y. Lyu, J. An, J. Shi, C. Yang, T. Zhang, H. Tian, Y. Li, Z. Li et al., “Securevibebench: Benchmarking secure vibe coding of ai agents via reconstructing vulnerability-introducing scenarios,” in Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 2026, pp. 24 144–24 168.
  12. [12]Y. Shi, J. Xu, K. Fu, W. Zeng, S. He, L. Zhang, Y. Liu, Z. Zhao, T. Y. Zhuo, J. Cao et al., “Swe-bench promax: Benchmarking agents on large-scale multilingual code refactoring,” arXiv preprint arXiv:2608.09802, 2026.arxiv.org/abs/2608.09802
  13. [13]M. Chen, L. Zhang, Y. Feng, X. Wang, W. Zhao, R. Cao, J. Yang, J. Chen, M. Li, Z. Ma et al., “Swe-universe: Scale real-world verifiable environments to millions,” arXiv preprint arXiv:2602.02361, 2026.arxiv.org/abs/2602.02361
  14. [14]D. Fu, S. Wu, Y. Wu, Z. Peng, Y. Huang, J. Sun, J. Zeng, M. Jiang, L. Zhang, Y. Li et al., “davinci-env: Open swe environment synthesis at scale,” arXiv preprint arXiv:2603.13023, 2026.arxiv.org/abs/2603.13023
  15. [15]R. Hu, C. Peng, J. Xu, and C. Gao, “Repo2run: Automated building executable environment for code repository at scale,” Advances in Neural Information Processing Systems, vol. 38, pp. 32 679–32 718, 2026.arxiv.org/abs/2502.13681
  16. [16]L. Guo, Y. Wang, C. Li, W. Tao, P. Yang, J. Chen, H. Song, D. Tang, and Z. Zheng, “Swe-factory: Your automated factory for issue resolution training data and evaluation benchmarks,” arXiv preprint arXiv:2506.10954, 2025.arxiv.org/abs/2506.10954
  17. [17]K. Li, R. Li, L. Zhang, Q. Jin, L. Zhu, X. Huang, G. Zhang, Y. Zhang, S. He, C. Xie et al., “Replaunch: Automating build&test pipeline of code repositories on any language and any platform,” arXiv e-prints, pp. arXiv–2603, 2026.
  18. [18]C. Guo, J. Wu, S. He, Y. Chen, Z. Kuang, S. Fan, B. Chen, S. Bao, J. Liu, H. Wu et al., “Menvagent: Scalable polyglot environment construction for verifiable software engineering,” arXiv preprint arXiv:2601.22859, 2026.arxiv.org/abs/2601.22859
  19. [19]I. Bouzenia, P. Devanbu, and M. Pradel, “Repairagent: An autonomous, llm-based agent for program repair,” in 2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE), 2025, pp. 2188–2200.arxiv.org/abs/2403.17134
  20. [20]C. S. Xia, Y. Deng, S. Dunn, and L. Zhang, “Agentless: Demystifying llm-based software engineering agents,” arXiv preprint arXiv:2407.01489, 2024.arxiv.org/abs/2407.01489
  21. [21]J. Chen, C. Yang, X. Hu, Z. Li, X. Xia, and D. Lo, “Agentexecutor: Partial code execution via agentic context generation,” arXiv preprint arXiv:2608.05959, 2026.arxiv.org/abs/2608.05959
  22. [22]K. Fu, T. Liu, Z. Shang, Y. MA, J. Liu, J. Yang, and K. Bian, “Multi-docker-eval: A ‘shovel of the gold rush’ benchmark on automatic environment building for software engineering,” in Findings of the Association for Computational Linguistics: ACL 2026, M. Liakata, V. P. Moreira, J. Zhang, and D. Jurgens, Eds. San Diego, California, United States: Association for Computational Linguistics, Jul. 2026, pp. 17 911–17 927. [Online]. Available: https://aclanthology.org/2026.findings-acl.889/
  23. [23]DeepSeek-AI, “Deepseek-v4: Towards highly efficient million-token context intelligence,” 2026.arxiv.org/abs/2606.19348
  24. [24]Xiaomi MiMo Team, “MiMo-v2.5-pro,” https://huggingface.co/collections/XiaomiMiMo/mimo-v25, 2026.
  25. [25]OpenAI, “GPT-5.5 System Card,” https://openai.com/index/gpt-5-5-system-card/, 2026, accessed: 2026-06-30.
  26. [26]Q. McNemar, “Note on the sampling error of the difference between correlated proportions or percentages,” Psychometrika, vol. 12, no. 2, pp. 153–157, 1947.pubmed.ncbi.nlm.nih.gov/20254758
  27. [27]F. Wilcoxon, “Individual comparisons by ranking methods,” Biometrics bulletin, vol. 1, no. 6, pp. 80–83, 1945.
  28. [28]B. W. Lampson, “Lazy and speculative execution in computer systems,” in Proceedings of the 13th ACM SIGPLAN International Conference on Functional Programming, ser. ICFP ’08. New York, NY, USA: Association for Computing Machinery, 2008, p. 1–2. [Online]. Available: https://doi.org/10.1145/1411204.1411205
  29. [29]Y. Leviathan, M. Kalman, and Y. Matias, “Fast inference from transformers via speculative decoding,” in International Conference on Machine Learning. PMLR, 2023, pp. 19 274–19 286.arxiv.org/abs/2211.17192
  30. [30]N. Ye, A. Ahuja, G. Liargkovas, Y. Lu, K. Kaffes, and T. Peng, “Speculative actions: A lossless framework for faster agentic systems,” arXiv preprint arXiv:2510.04371, 2025.arxiv.org/abs/2510.04371
  31. [31]C. E. Jimenez, J. Yang, A. Wettig, S. Yao, K. Pei, O. Press, and K. Narasimhan, “Swe-bench: Can language models resolve real-world github issues?” in International Conference on Learning Representations, vol. 2024, 2024, pp. 54 107–54 157.arxiv.org/abs/2310.06770
  32. [32]W. W. Burton, “Speculative computation, parallelism, and functional programming,” IEEE Transactions on Computers, vol. 100, no. 12, pp. 1190–1193, 1985.DOI
  33. [33]A. Estebanez, D. R. Llanos, and A. Gonzalez-Escribano, “A survey on thread-level speculation techniques,” ACM Comput. Surv., vol. 49, no. 2, Jun. 2016. [Online]. Available: https://doi.org/10.1145/2938369
  34. [34]H. T. Kung and J. T. Robinson, “On optimistic methods for concurrency control,” ACM Trans. Database Syst., vol. 6, no. 2, p. 213–226, Jun. 1981. [Online]. Available: https://doi.org/10.1145/319566.319567
  35. [35]C. Chen, S. Borgeaud, G. Irving, J.-B. Lespiau, L. Sifre, and J. Jumper, “Accelerating large language model decoding with speculative sampling,” arXiv preprint arXiv:2302.01318, 2023.arxiv.org/abs/2302.01318
  36. [36]Y. Li, J. Chen, X. Hu, and X. Xia, “An empirical study of speculative decoding on software engineering tasks,” arXiv preprint arXiv:2604.26469, 2026.
  37. [37]T. Cai, Y. Li, Z. Geng, H. Peng, J. D. Lee, D. Chen, and T. Dao, “Medusa: Simple llm inference acceleration framework with multiple decoding heads,” arXiv preprint arXiv:2401.10774, 2024.arxiv.org/abs/2401.10774
  38. [38]Y. Li, F. Wei, C. Zhang, and H. Zhang, “Eagle: Speculative sampling requires rethinking feature uncertainty,” arXiv preprint arXiv:2401.15077, 2024.arxiv.org/abs/2401.15077
  39. [39]J. Zhang, J. Wang, H. Li, L. Shou, K. Chen, G. Chen, and S. Mehrotra, “Draft& verify: Lossless large language model acceleration via self-speculative decoding,” in Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 2024, pp. 11 263–11 282.
  40. [40]Y. Sui, H. Zhao, R. Ma, Z. He, H. Wang, J. Li, K. Xu, K. Chen, and Y. Yang, “Parallellizing tool execution and llm generation for low-latency agent serving,” arXiv preprint arXiv:2603.18897, 2026.arxiv.org/abs/2603.18897
  41. [41]Y. Guan, Q. Lan, S. Fei, D. Ding, D. Acharya, C. Wang, W. Y. Wang, and W. Hua, “Dynamic speculative agent planning,” arXiv preprint arXiv:2509.01920, 2025.
  42. [42]Z. Sun, Z. Lin, Z. Chen, C. Yang, M. Zhou, L. Li, and D. Lo, “Executing as you generate: Hiding execution latency in llm code generation,” arXiv preprint arXiv:2604.00491, 2026.arxiv.org/abs/2604.00491
  43. [43]E. Horton and C. Parnin, “Dockerizeme: Automatic inference of environment dependencies for python code snippets,” in 2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE), 2019, pp. 328–338.arxiv.org/abs/1905.11127
  44. [44]H. Ye, J. Zhou, W. Chen, J. Zhu, G. Wu, and J. Wei, “Dockergen: A knowledge graph based approach for software containerization,” in 2021 IEEE 45th Annual Computers, Software, and Applications Conference (COMPSAC), 2021, pp. 986–991.DOI
  45. [45]K. Hanayama, S. Matsumoto, and S. Kusumoto, “Humpback: Code completion system for dockerfiles based on language models,” in Proc. Workshop on Natural Language Processing Advancements for Software Engineering, vol. 2020, 2020, pp. 1–4.
  46. [46]Y. Zhang, Y. Zhang, X. Mao, Y. Wu, B. Lin, and S. Wang, “Recommending base image for docker containers based on deep configuration comprehension,” in 2022 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), 2022, pp. 449–453.DOI
  47. [47]D. Nüst and M. Hinz, “containerit: Generating dockerfiles for reproducible research with r,” Journal of Open Source Software, vol. 4, no. 40, p. 1603, 2019.DOI
  48. [48]A. Eliseeva, A. Kovrigin, I. Kholkin, E. Bogomolov, and Y. Zharov, “Envbench: A benchmark for automated environment setup,” arXiv preprint arXiv:2503.14443, 2025.arxiv.org/abs/2503.14443
  49. [49]L. Milliken, S. Kang, and S. Yoo, “Beyond pip install: Evaluating llm agents for the automated installation of python projects,” in 2025 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, 2025, pp. 1–11.arxiv.org/abs/2412.06294
  50. [50]J. Yang, C. Jimenez, A. Z. Wettig, K. Lieret, S. Yao, K. Narasimhan, and O. Press, “Swe-agent: Agent-computer interfaces enable automated software engineering,” in Advances in Neural Information Processing Systems, A. Globerson, L. Mackey, D. Belgrave, A. Fan, U. Paquet, J. Tomczak, and C. Zhang, Eds., vol. 37. Curran Associates, Inc., 2024, pp. 50 528–50 652. [Online]. Available: https://proceedings.neurips.cc/paper_files/paper/2024/file/5a7c947568c1b1328cc523017e2e1e7c-Paper-Conference.pdfarxiv.org/abs/2405.15793
  51. [51]Y. Zhang, H. Ruan, Z. Fan, and A. Roychoudhury, “Autocoderover: Autonomous program improvement,” in Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis, ser. ISSTA 2024. New York, NY, USA: Association for Computing Machinery, 2024, p. 1592–1604. [Online]. Available: https://doi.org/10.1145/3650212.3680384

Paper details

vlnc:W_mmmnbuzy
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents