Dockerless: Environment-Free Program Verifier for Coding Agents

Training Coding Agents Without the Container Tax

Training AI coding agents usually requires setting up complex, custom environments for every single task. This process is slow and expensive. The current gold standard for verifying if an AI's code fix actually works is to execute that code inside an isolated Docker container. A Docker container is a lightweight, portable virtual machine. Each container is specifically configured for an individual software repository. While accurate, this process creates a massive engineering bottleneck. You must build custom images and resolve hundreds of dependencies. You must also manage unique test runners for every single issue you want to learn from.

A new study introduces Dockerless. This method allows agents to learn from code without actually running the code in a specialized environment. Instead of relying on a "pass/fail" signal from a test runner, Dockerless uses an AI "agent" to actively explore the codebase. The agent searches for evidence to judge if a patch is correct. The researchers report that this approach enables a fully environment-free training pipeline. This pipeline matches the performance of traditional, expensive execution-based methods.

The bottleneck of per-repository execution

In the current landscape of software engineering (SWE) agents, training relies on two main pillars. First is Supervised Fine-Tuning (SFT). In SFT, the model learns from successful "trajectories" (sequences of actions taken to solve a problem). Second is Reinforcement Learning (RL). In RL, the model is rewarded for successful outcomes. To ensure high-quality training data, researchers typically use execution-based verification. This means running the agent's proposed code patch against unit tests. These tests run inside a dedicated Docker container tailored to that specific repository.

As shown in, this "gold standard" comes with a heavy price. Building these environments is computationally expensive and difficult to scale. Many real-world, private, or legacy codebases lack reproducible environments. They may even lack comprehensive test suites. Furthermore, existing "environment-free" alternatives often rely on shallow LLM scorers. These scorers merely compare the text of a fix to a reference solution. Such surface-level comparisons fail on complex tasks. A fix might be functionally identical to the reference but look entirely different in its syntax.

Grounding judgment in repository exploration

Dockerless moves away from both expensive execution and shallow text matching. It treats verification as an investigative process. The architecture is detailed in . It operates in two distinct stages. First, the system performs "Question Generation." The model derives a set of targeted verification questions. These questions are based on the issue description and a known correct reference patch. These questions focus on critical dimensions. They ask where the fix should occur and what the intended behavior is. They also look for potential edge cases.

Second, the system enters the "Exploration" phase. Dockerless dispatches parallel sub-agents to answer the generated questions. These sub-agents use read-only shell tools. Examples include grep (a utility for searching text patterns) or find. These tools allow the agents to navigate the codebase and gather empirical evidence. Once the sub-agents return their findings, a final "Judge" model aggregates this evidence. It then produces a correctness score. This allows the verifier to ground its decision in the actual structure of the code. It acts like a human reviewer who reads surrounding files to understand a change.

Matching the performance of the gold standard

The primary goal of Dockerless was to prove that an environment-free pipeline could compete with execution-based approaches. The authors report significant success across multiple benchmarks. On the SWE-bench Verified benchmark, the Dockerless-RL-9B model achieved a 62.0% resolve rate. This surpassed the Qwen3.5-9B baseline by 2.4 points. On the Multilingual and Pro versions, the model saw improvements of 8.7 and 2.9 points, respectively. These gains indicate that the model can solve more real-world issues than the baseline.

Crucially, the authors demonstrate that this scalability does not come at the cost of efficiency. In an RL training setting, calculating a reward via Dockerless adds some time. However, it is negligible compared to the time spent on the agent rollouts themselves. As shows, Dockerless adds roughly 180 seconds of evaluation time.

This represents only about 7.2% of the total wall-clock time per rollout. Most of the time is dominated by the agent's own thinking and action steps. Furthermore, the authors found a "sweet spot" for the number of verification questions. shows that performance peaks at $K=4$ questions.

Adding more questions tends to introduce redundant or noisy evidence. This can actually degrade the verifier's accuracy.

Residual signals and language gaps

Despite the impressive results, the paper identifies clear boundaries to the "environment-free" promise. The performance gap between environment-based and environment-free training is not uniform across all languages. Specifically, in compilation-heavy languages like Rust and C, the environment-based approach maintains a significant advantage.

The researchers attribute this to the loss of compiler diagnostics. In a standard environment, an agent can see specific error messages from a compiler. In an environment-free setting, the agent must infer these truths from the source code alone. For practitioners working in systems programming, this is a key finding. While Dockerless handles logic and flow well, it currently lacks the immediate feedback provided by a live compiler. This feedback is a vital signal for catching low-level errors.

The verdict: A scalable path for post-training

Dockerless is an effective solution for scaling the training of coding agents. It reduces the massive infrastructure overhead of managing thousands of custom Docker images. By replacing execution with intelligent, agentic exploration, the authors have demonstrated a new path. You can achieve performance comparable to the gold standard using only a minimal Linux base image.

If your target domain involves high-level languages like Python or JavaScript, this method is a viable alternative. However, if you are training agents for low-level systems programming in C or Rust, use caution. The absence of real-time compiler feedback remains a notable limitation. Overall, the work establishes that environment-free post-training is a scalable and competitive path forward.

Figures from the paper