Skip to content

Dockerless: Environment-Free Program Verifier for Coding Agents

Conference: EMNLP 2026
Paper: ACL Anthology
Area: LLM Agent
Keywords: Coding Agents, Environment-Free Verifier, Post-Training RL, Codebase Exploration, Program Correctness Judgment

TL;DR

Dockerless eliminates heavy per-repository Docker containers and test runners by generating targeted verification questions and deploying parallel read-only sub-agents to gather codebase evidence, matching execution-based SFT filtering and RL rewards on SWE-bench without executing tests.

Background & Motivation

Automated coding agents powered by frontier large language models have made dramatic strides in resolving complex, real-world software engineering issues. Their post-training pipelines rely critically on accurate program verifiers, which curate high-quality trajectories for supervised fine-tuning (SFT) through rejection sampling and supply dense or sparse rewards during reinforcement learning (RL). The established gold standard for assessing patch correctness is execution-based verification, which requires executing held-out unit test suites inside isolated per-repository containers with strictly pinned dependencies and working test harnesses. However, setting up these environments incurs immense engineering overhead: building custom Docker images, resolving brittle legacy dependencies, identifying relevant test targets, and developing custom output parsers. Even state-of-the-art automated environment builders fail on a significant fraction of repositories, while enterprise codebases, legacy software, and the long tail of open-source projects frequently lack reproducible environments or automated test suites altogether.

To circumvent the prohibitive costs of repository-specific containerization, recent studies have explored environment-free rollout collection inside a single shared minimal Linux base image. Yet, the verification bottleneck remains unresolved. Existing environment-free patch verifiers score candidate patches using only surface-level textual diffs, natural language issue descriptions, and fixed-prompt LLM judges, without ever inspecting the actual codebase. Such shallow approaches break down on complex software engineering tasks: deciding semantic equivalence between a candidate patch and a reference patch requires deep context, such as verifying whether an alternative inline implementation preserves global semantics, determining if an altered method is invoked along the failing execution path, or ensuring that surrounding caller modules remain unaffected.

This paper tackles the challenge from an agentic perspective: in a minimal environment, an agent lacks pre-installed compilers and test runners, but retains full access to static code browsing and shell navigation. Rather than treating program verification as passive text comparison, verification can be formulated as an active codebase exploration task where dedicated agents retrieve concrete factual evidence from the repository. Core idea: decouple program verification into a two-stage agentic workflow of multi-dimensional question generation, parallel codebase exploration via read-only sub-agents, and evidence-grounded continuous scoring, enabling a fully environment-free post-training pipeline for coding agents.

Method

Overall Architecture

Dockerless operates entirely inside a lightweight, minimal Ubuntu container without repository-specific runtime configurations or pre-installed dependency libraries. Given an issue description \(x\), a reference patch \(y_{\text{ref}}\), and an agent-generated candidate patch \(y\), the system executes a two-stage pipeline. In the first stage, the base model formulates \(K\) targeted verification questions and dispatches \(K\) parallel read-only sub-agents to inspect the codebase and harvest evidence-backed answers. In the second stage, a unified judge module ingests the original context along with the collected question-answer pairs, producing a continuous correctness score \(r_\phi(x, y)\) derived from token logits.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Input Context<br/>Issue Description + Reference Patch + Candidate Patch"] --> B["Multi-dimensional Verification Question Generation<br/>Derive K probing questions from issue and reference"]
    B --> C["Parallel Sub-agent Codebase Exploration<br/>K read-only sub-agents collect code evidence"]
    C --> D["Evidence-Grounded Judgment & Continuous Scoring<br/>Aggregate Q&A evidence into continuous reward"]
    D --> E["Downstream Post-Training Application<br/>RFT trajectory filtering and GRPO RL reward"]

Key Designs

1. Multi-dimensional Verification Question Generation: Surface comparison misses semantic divergence -> Decompose verification goals into targeted questions -> Establish concrete code review anchors
Directly comparing candidate diffs against reference patches often yields false negatives when implementations diverge syntactically while remaining functionally equivalent. To guide the inspection, the question generation module ingests the issue description and reference patch to produce \(K\) structured diagnostic questions \(\{Q_1, \ldots, Q_K\}\) (empirically \(K=2\) to \(4\)). These questions span four essential verification categories: Test Evidence (locating test assertions and regression checks), Error Location (identifying where the bug manifests in the call stack), Code Context (examining class definitions, signatures, and call sites), and Documentation & Configuration (confirming intended behaviors and flag semantics). By translating abstract patch correctness into factual queries grounded in code reality, the model establishes concrete investigative targets.

2. Parallel Sub-agent Codebase Exploration: Static code cannot be run -> Dispatch read-only shell sub-agents to query code evidence -> Provide grounded file-level context constraints
Without execution privileges or test runners, the verifier cannot rely on dynamic unit test outputs. Dockerless resolves this by assigning each question \(Q_k\) to an independent ReAct-style sub-agent. Running concurrently in the minimal Linux environment, each sub-agent executes non-destructive shell commands (find, grep, rg, cat) to navigate directories, inspect function definitions, and trace references across modules. Each sub-agent concludes its search by emitting a structured answer \(A_k\) featuring exact file paths (FILE) and line intervals (RANGE). This parallel exploration gathers grounded context at near-zero incremental latency, furnishing static proof equivalent to manual code auditing.

3. Evidence-Grounded Judgment & Continuous Scoring: Binary discrete verdicts lack optimization gradients -> Aggregate evidence to compute continuous scores from token logits -> Deliver robust filtering and RL reward signals
Relying on hard binary verdicts (0 or 1) provides sparse feedback that destabilizes reinforcement learning and offers insufficient granularity for ranking candidate trajectories. In the judgment stage, the judge module consumes the tuple \((x, y_{\text{ref}}, y, \{(Q_k, A_k)\}_{k=1}^K)\) and evaluates patch validity from the perspective of an expert code reviewer. Rather than taking the argmax token, Dockerless extracts the unnormalized logit values \(\ell_0\) and \(\ell_1\) corresponding to tokens 0 and 1, mapping them into a smooth continuous reward via softmax: $\(r_\phi(x, y) = \frac{\exp(\ell_1)}{\exp(\ell_0) + \exp(\ell_1)}\)$ The resulting probability in \([0, 1]\) acts as a well-calibrated confidence score, enabling global top-\(K\) trajectory selection for rejection sampling fine-tuning and driving group-normalized advantage estimation in GRPO.

A Worked Example

Consider a representative issue in Matplotlib concerning offsetText color inheritance: the offset text incorrectly adopted tick.color rather than respecting the resolved tick.labelcolor. The reference patch introduced a separate tick_color helper variable with an if-else branch in lib/matplotlib/axis.py, whereas an agent's candidate patch resolved the issue via an inline conditional directly inside self.offsetText.set(color=...).

Because the surface diff diverged substantially from the golden patch, standard text similarity scored the candidate at 0.468, and the offline DeepSWE Verifier assigned it a failing score of 0.035. In contrast, Dockerless formulated two probing questions: Question 1 asked whether both XAxis and YAxis initialization paths in lib/matplotlib/axis.py were updated at creation time; Question 2 asked whether explicit colors and 'inherit' configurations were properly distinguished. The parallel sub-agents traversed the repository, locating lines 2248โ€“2260 in lib/matplotlib/axis.py and the test case test_xtickcolor_is_not_xticklabelcolor() in lib/matplotlib/tests/test_axes.py (lines 7794โ€“7802). The gathered evidence verified that the inline expression was applied symmetrically across both axes and fully preserved inheritance semantics. Consequently, the judge module assigned an authoritative score of 0.996, accurately matching the execution outcome (\(r_{\text{env}}=1.0\)).

Loss & Training

Dockerless is trained via rejection sampling across 3.7K execution-labeled issues from SWE-Gym and Multi-SWE-RL. A teacher model (GLM-5) generates candidate question-answer-judge trajectories \(\tau\). Only trajectories whose predicted verdict \(\hat{r}\) matches the ground-truth unit-test outcome \(r^\star \in \{0, 1\}\) are retained in \(\mathcal{D}_{\text{rej}}\), while enforcing a negative-to-positive ratio cap of 4:1 to prevent class imbalance.

A unified Qwen3.5-9B backbone is trained jointly across question generation, exploration, and judgment using standard next-token cross-entropy over the sequence \(z = (z_1, \ldots, z_T)\): $\(\mathcal{L}_\phi = -\mathbb{E}_{\mathcal{D}_{\text{rej}}} \left[ \sum_{t=1}^T \log p_\phi(z_t \mid x, y_{\text{ref}}, y, z_{<t}) \right]\)$ During downstream environment-free RFT, 16K rollouts collected in a minimal Linux image are scored by Dockerless over \(M=2\) passes; the globally top-ranked 4K rollouts form \(\mathcal{D}_{\text{RFT}}\) to fine-tune the agent. For environment-free RL, the model samples groups of \(G=8\) rollouts \(\{y_1, \ldots, y_G\}\) per issue and optimizes policy parameters using GRPO, driven by group-normalized advantages: $\(A_i = \frac{r_\phi(x, y_i) - \bar{r}}{\hat{\sigma}_r}, \quad \bar{r} = \frac{1}{G}\sum_{j=1}^G r_\phi(x, y_j)\)$ where \(\hat{\sigma}_r\) denotes the standard deviation of verifier rewards within the group, eliminating all execution overhead during RL.

Key Experimental Results

Main Results

All models are evaluated under the standard environment-based SWE-bench benchmark protocol across SWE-bench Verified, Multilingual, and Pro to assess how environment-free training transfers to real-world code editing tasks.

Model Base Model Training Stage Env-free Training SWE-bench Verified SWE-bench Multilingual SWE-bench Pro
SWE-Gym-7B Qwen2.5-Coder-7B SFT No 11.4% 3.0% 3.3%
SWE-Dev-7B Qwen2.5-Coder-7B SFT No 10.6% 4.2% 4.0%
SWE-Lego-8B Qwen3-8B SFT No 41.2% 19.0% 16.1%
Qwen3.5-9B (Base) - - - 59.6% 41.3% 32.3%
Env-SFT-9B Qwen3.5-9B SFT No 60.0% 48.3% 33.9%
Dockerless-SFT-9B Qwen3.5-9B SFT Yes 60.6% 47.7% 35.3%
+ DeepSWE-Verifier RL Dockerless-SFT-9B RL Yes 60.6% 47.3% 34.1%
+ Test-Execution RL Dockerless-SFT-9B RL No 62.4% 51.3% 35.7%
Dockerless-RL-9B Dockerless-SFT-9B RL Yes 62.0% 50.0% 35.2%

Verifier discrimination is measured using Area Under the ROC Curve (AUC) on a balanced trajectory-level evaluation benchmark consisting of 776 instances (500 from SWE-bench Verified and 276 from Multi-SWE-bench Flash):

Verifier / Model Verified AUC Multi-SWE-bench Flash AUC
DeepSeek-V3.2 (Zero-shot Judge) 69.4 58.5
Kimi-K2.5 (Zero-shot Judge) 70.7 63.9
GLM-5 (Zero-shot Judge) 73.2 62.5
GPT-5.4 (Zero-shot Judge) 75.9 59.5
SWE-Gym Verifier 61.0 53.7
R2E-Gym Verifier 64.3 55.1
OpenHands Critic 48.6 52.2
DeepSWE Verifier 66.7 62.9
Dockerless (Ours) 81.0 72.1

Ablation Study

Holding the Qwen3.5-9B backbone and SFT hyperparameters constant, the trajectory selection strategy is varied to isolate the impact of verifier-guided data filtering:

SFT Training Data Filter Size Verified Multilingual Pro Description
None (Base model) 0 59.6% 41.3% 32.3% Unfine-tuned Qwen3.5-9B baseline
All Env-Free Rollouts 16K 58.8% 41.3% 31.9% Unfiltered training degrades performance
Random Sampling 4K 58.2% 44.3% 32.0% Uniform random sampling includes flawed patches
Env-based Docker Filter 4K 60.0% 48.3% 33.9% Filtered by physical Docker test execution
Dockerless Filter 4K 60.6% 47.7% 35.3% Environment-free agentic filtering matches execution

Ablation on the number of generated verification questions \(K\) on SWE-bench Verified: - \(K=0\) (Direct scoring without questions): 78.3 AUC - \(K=1\): 80.1 AUC - \(K=2\): 80.8 AUC - \(K=4\) (Empirical sweet spot): 81.0 AUC - \(K=6\): 79.6 AUC (Slight degradation due to question redundancy) - \(K=8\): 80.3 AUC (Plateaus with increased exploration latency)

Key Findings

  • Training on the complete, unfiltered pool of 16K environment-free rollouts hurts performance, dropping Verified resolve rate from 59.6% down to 58.8% and Pro from 32.3% down to 31.9%. Rigorous patch filtering is therefore mandatory to prune noisy and degenerate trajectories.
  • Dockerless achieves 81.0 AUC on SWE-bench Verified, surpassing the strongest trained baseline (DeepSWE Verifier) by 14.3 points and the leading frontier LLM judge (GPT-5.4) by 5.1 points, demonstrating the indispensable utility of active codebase inspection over surface matching.
  • Time allocation analysis shows that rollout generation accounts for the overwhelming majority of RL wall-clock time (averaging 2308 seconds per trajectory), while Dockerless evaluation requires 180 seconds (7.2% of total time). As a result, the end-to-end latency distribution closely mirrors execution-based RL.
  • Language-specific breakdowns indicate that environment-free SFT matches execution-based SFT within 2.5 percentage points on dynamic and interpreted languages (Python, JavaScript, Go, Java, PHP), but exhibits a gap on heavily compiled languages (falling behind by 7.0 points on Rust and 13.3 points on C) due to the absence of compiler feedback.

Highlights & Insights

  • Transforms patch verification from passive diff scoring into active, question-guided codebase evidence gathering, offering a principled framework for static patch verification.
  • Proves for the first time that an entirely environment-free post-training pipeline (rollouts, SFT filtering, and RL rewards) can match the performance of execution-based training with zero per-repository container overhead.
  • Demonstrates that reward model latency during RL is dominated by the long horizon of agent rollouts, rendering multi-step agentic verification practically viable at training scale.

Limitations & Future Work

  • The average verification latency of 180 seconds per patch is unsuited for low-latency interactive developer workflows and synchronous IDE code completion.
  • Performance degrades on compiled languages such as Rust and C where compiler error messages and linker diagnostics cannot be queried inside minimal base images.
  • Future work could explore distilling multi-agent exploration trajectories into faster dense scoring networks or integrating language server protocol (LSP) diagnostics into the base image.
  • vs SWE-Gym / R2E-Gym Verifier: Prior verifiers train patch classifiers conditioned on execution traces from containerized environments; Dockerless operates entirely without repository containers by deploying exploratory sub-agents.
  • vs DeepSWE Verifier / SWE-RM: These methods rely on single-pass forward prompts or mixture-of-experts critics that evaluate patches out of context; Dockerless queries the repository interactively, achieving significantly higher accuracy on complex refactoring tasks.
  • vs SWE-ZERO / SWE-World: Earlier environment-free initiatives restrict rollouts to mock execution environments or static toolsets; Dockerless allows arbitrary read-only shell access and replaces both SFT curation and RL rewards with a unified agentic verifier.

Rating

  • Novelty: โญโญโญโญยฝ [Pioneers active, multi-agent codebase exploration for environment-free patch verification.]
  • Experimental Thoroughness: โญโญโญโญโญ [Extensive verification benchmarks, SFT filtering, RL rewards, per-language breakdowns, and wall-clock analyses.]
  • Writing Quality: โญโญโญโญโญ [Exemplary clarity, coherent structure, well-defined mathematical formulation, and illuminating case studies.]
  • Value: โญโญโญโญโญ [Unlocks scalable post-training on enterprise and legacy codebases that lack reproducible execution environments.]