Product1 distinct publisher3 min readPublished
The open-source kit runs an evaluation command inside a Docker Sandbox and records six fields about what happened, which settles which command produced a number without settling what was installed at the time.
The Product Desk · Product desk

product
The allowlist read the command name, not what the command would do1 distinct publisher
product
AI writes the Dockerfile, and the pipeline is still checking the app code1 distinct publisher
build
Before you spend quota on an agent skill, make it pass an eval harness1 distinct publisher
product
MinIO went dark on 13 February. Docker will keep patching it until 2031, for a fee.1 distinct publisher
Compiled by The Product DeskSomething wrong?How this is made
Only one of the six recorded fields is guaranteed to move between two correct re-runs of the same evaluation, and that is the elapsed time, reported as 120.0 milliseconds against an exit code of 0 in the post's own sample artifact [10]. Five fields are left worth comparing, which makes checking one run against another a field-by-field exercise rather than a diff of whole files [14].
The fields that are absent matter just as much. The digest the repository generates is taken over the evaluation configuration, binding the YAML to the artifact it produced [9]; nothing in the recorded fields identifies the image, the interpreter build, or the resolved package versions [13]. The artifact tells you the SBX executor was selected [8]. What was inside the sandbox at that moment is a file somebody else owns.
Set that against the post's own diagnosis, which names three drift sources: Python dependencies that change, local tools that go out of step, and setup steps that nobody wrote down [2]. The third one this design closes, because the YAML definition is the setup step, executed instead of described [6]. The first two stay wherever the sandbox image comes from.
That is still a real gain, and worth being precise about why. A page describing how to run an eval is not the same as documenting it. The post's own distinction is sharper than that: a written evaluation records what someone intended to do, and an execution-backed one records what actually happened [16]. Most reproduction attempts die in the space between those two, and writing down the command and the exit status closes it without anyone relitigating the judge model. Docker's complaint is that attention has gone to benchmarks and scoring methods while how a run gets executed receives much less [3].
Two axes sort the decision for whoever owns this on Monday: whether you can re-run the exact command and flags that produced last quarter's number, and whether you can rebuild the environment it ran in. If both are no, the runbook only works because you take it on faith. Command yes and environment no is where this kit puts you, which is sufficient if your failures have been about invocation, a wrong flag or a stale script path. Environment yes and command no is a pinned image with a lost invocation, and that is the cheapest case for the kit to fix. Both yes is the goal, and it requires an image pinned and versioned by a person you can name, with the artifact recording that the sandbox was used rather than what was in it [13].
One detail hints at where this goes. The repository is packaged so it can be applied when starting a Claude sandbox, with `sbx run claude --kit .` [11], which puts the eval harness and the agent's working environment behind the same description. The kit covers the execution half of reproducibility; the environment half still comes down to an image with an owner.
Ranked by verification strength, evidence, and original report placement.
Docker's blog post argues that keeping the prompt, model and scoring method fixed does not necessarily make an evaluation run reproducible, because the execution environment matters too.
The post names the failure modes: Python dependencies change, local tools drift, and setup steps go undocumented, so a workflow that succeeds on one machine may behave differently on another.
The author released the SBX AI Evaluation Kit, an open-source Docker Sandboxes Mixin Kit focused on repeatable execution, structured evaluation records and runtime evidence.
The current implementation does not execute AI models or automatically derive evaluation judgments; it executes configured commands consistently and preserves evidence of what actually ran.
Each evaluation is defined in a YAML file describing the evaluation and the command to run; the repository validates that definition, executes it, and produces a structured JSON record of the result.
An executor abstraction separates definition from location: the local executor runs the configured command on the host, the SBX executor delegates execution to Docker Sandboxes, and switching between them only requires changing the executor configuration.
Distinct publishers with included, body-backed reporting in this cluster.
1 article · September 2, 2026
Follow any of these and your For You feed starts watching them — no settings page required.
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Fully shown, never independently run
Docker prints the thing itself — the execution block, the field list, an artifact with exit_code 0 and duration_ms 120.0 — which is a stronger form of proof than most tooling posts offer, and it makes the gaps checkable too. But every detail comes from the author of the kit on the vendor's own blog, and no one else in this reporting has executed the workflow or verified that two runs actually match.
Code is out, users unknown
The public repository and the applicable Mixin Kit are the entire adoption record. No team, deployment, download count or internal Docker use appears anywhere in this reporting, and the kit's own scope note — no model execution, no judgments — means anyone picking it up still has to bring their evaluation stack with them.
'Reproducible' outruns the receipt
The post's own argument is that dependencies and local tooling drift — then the artifact it produces names the executor and the command and stays silent on image, interpreter and package versions. That is a real gap between the headline promise of reproducible evaluation workflows and what the six fields settle. It is a modest gap rather than a large one because Docker volunteers most of the limits itself: no models run, no judgments derived, no replacement for experiment tracking.
Docker's blog, Docker's sandbox
The kit only runs its interesting path through Docker Sandboxes, it ships as a Mixin Kit — Docker's extension format — and the case for it appears on docker.com written by its author. The closing suggestion that the same Kit pattern could carry regression testing, policy checks and security analysis reads as product surface expansion as much as engineering advice. None of that makes the mechanics wrong; it does mean the framing of the problem and the choice of remedy come from the same interested party.
Clear on mechanics, blank on uptake
We can describe what this kit does with near-certainty, because the artifact and the invocations are on the page; we can say almost nothing about whether it will be used or whether its receipts hold up across machines. Confidence sits mid-range for that asymmetry, and a second account from anyone running the kit outside Docker would move it more than any further detail from the author.