EvoTrace: Turning Claude Code and Codex Logs into Verified Training Data

The Gap EvoTrace Fills

Raw transcripts from Claude Code or Codex are not training data. A long chat contains multiple task boundaries, no repository state from before the task, no reproducible environment, and no independent verifier. EvoTrace exists to close that gap. It imports the session history already on your machine, finds the sessions worth keeping, and compiles them into preference data, executable task bundles, verifier candidates, and difficulty evidence. The intended user is an engineer or research team doing post-training work who wants to reuse real agent trajectories instead of synthetic ones. It is not another coding agent, and the README is explicit that you do not need to change how you use Claude Code or Codex. The project is local-first: you keep the source data and the resulting assets under your control.

How the Compilation Works

The core workflow starts with /init, which imports and normalizes session history and runs what the README calls Git archaeology. That step recovers the repository state before the task began. Then /candidates ranks sessions by evidence strength and hides nested subagent duplicates. The /review command runs a sequential four-agent process: mine episode, gate route, build or harden, and criticize. The output is routed to one of several destinations: preference or recovery data, an executable candidate, a hardening seed, or rejection with explicit reasons. Rejection is a designed outcome, not a failure. The README stresses that a long but weak trajectory should not be mislabeled as training-ready. After review, /validate runs the task in Docker, and /calibrate measures difficulty with fresh solver attempts. The status ladder is strict: Mined means signals exist but nothing executable is implied; Buildable means task, repo base, reconstruction confidence, reference patch, verifier commands, and environment gates pass; Bundle generated means a Docker-ready candidate exists but its verifier is not trusted; Verified means a conforming Docker run rejected the base, accepted the reference, and was recorded against the exact bundle digest; Calibrated means fresh solver attempts measured the task, with a default target of two verifier passes in five attempts.

Getting It Running

Installation is a one-liner. On macOS, Linux, or WSL, run curl -LsSf https://raw.githubusercontent.com/jinzijian/EvoTrace/main/install.sh | sh. On Windows PowerShell, run irm https://raw.githubusercontent.com/jinzijian/EvoTrace/main/install.ps1 | iex. Then launch with evotrace. That opens the DeepSeek Harness Web app. In Settings, you choose a provider supported by your Harness setup, such as DeepSeek, OpenAI, or Anthropic. Local import and deterministic mining do not require a model. Agent review, hardening, calibration, and evolution do. New sessions start with Harness Full access by default. To use a narrower workspace sandbox, set DSH_PERMISSION_MODE=workspace-write evotrace. Docker is required only when you build or validate executable environments. The first asset build uses slash commands: /init, /candidates, /show 1, /review 1, /assets. The README gives a clear recipe for compiling and validating an executable task: /review 1, /build 1, /validate 1, /runs.

What the Outputs Are Good For

The README lists six output types. The candidate catalog captures task intent, repo, corrections, failures, effective actions, and provenance gaps. Preference and recovery data includes rejected and chosen attempts, human corrections, and successful recoveries, useful for DPO, SFT, QA, and failure-recovery training. An executable task bundle contains a repository base, initial state, dependency evidence, and a task specification, usable for coding-agent evals, regression tasks, and RL environments. Verifier and reward candidates include test commands, behavioral checks, policy, and provenance, meant for rollout scoring and execution rewards after validation. Difficulty evidence comes from fresh independent solver attempts and verifier outcomes, replacing guesses from patch size. Execution experience is compressed runtime facts from exploration trajectories, for training examples and held-out experience-transfer experiments. The same validated task can evaluate an agent today, score newly sampled rollouts tomorrow, and produce verifier-grounded RL data later. That reuse is the core value proposition.

Where It Can Fail or Be the Wrong Tool

The README is upfront that EvoTrace is early alpha and DeepSeek Harness is a developer preview. Generated tasks and verifiers remain candidates until they pass documented evidence and Docker validation gates. That is a real limitation. If your sessions lack clean task boundaries, missing reference patches, or missing verification commands, EvoTrace will fail closed. The README lists failure modes: empty prompt wrappers, low-confidence reconstruction, missing reference patches, missing verification commands, unsupported environments, candidate switching, and mismatched asset lineage. That means a large fraction of real-world history may be rejected. The tool is also wrong for teams that cannot run Docker, because validation and calibration depend on it. And if you only have a handful of sessions, the compilation overhead may not be worth it. The deterministic mining step does not need a model, but the review and calibration steps do, so you need API access or a local model through Harness.

The Alternative: Manual Curation or Synthetic Data

The alternative is not another trajectory compiler, because few exist. The practical alternative is manual curation: an engineer reads transcripts, writes task descriptions by hand, builds Docker environments manually, and writes verifiers from scratch. That approach gives you full control and no dependency on an alpha tool, but it does not scale and it is prone to the same mislabeling problem EvoTrace tries to solve. Another alternative is synthetic trajectory generation, where you run agents on controlled tasks and record the sessions. That gives you clean provenance from the start, but it does not exploit the real-world history already on your machine. The difference in approach is that EvoTrace assumes your existing messy history has value and tries to mine it with deterministic gates, whereas synthetic generation avoids the mess entirely. If you already have a large corpus of real sessions, EvoTrace is the only tool in this space that attempts to automate the compilation. If you do not, synthetic generation is simpler and more predictable.

Maintenance, Upgrades, and License

The project is under Apache-2.0, which means you can use, modify, and distribute it freely, with attribution. The repository shows recent releases v0.3.2, v0.3.1, and v0.3.0, all on the same day, with the v0.3.0 release noting a project rename. That suggests active development but also instability. The README mentions a future opt-in EvoTrace Marketplace and fine-tuning integrations, but those are roadmap products, not part of the current local release. Maintenance cost is nontrivial: you are tied to DeepSeek Harness, which is a developer preview, so upstream changes can break your setup. You also need to keep Docker images current and track bundle digests if you want reproducible validation. The one-command onboarding in the release notes is a convenience, but the real cost is in learning the status ladder and debugging why sessions fail gates. Verify the current state of the harness before committing to a workflow.

Editorial conclusion

Adopt EvoTrace if you already have a deep pile of Claude Code or Codex sessions and you are willing to accept an early alpha plus a developer-preview harness. Do not adopt it if you need a stable production pipeline today, if your team cannot run Docker for validation, or if you expect one-command magic: the README warns that generated tasks and verifiers remain candidates until they pass evidence and Docker gates. Before relying on any asset, verify the status field, confirm the bundle digest matches the recorded run, and check that your environment is supported. Start with /init and /candidates to see how much of your history survives the deterministic gates. If the compiled assets fail validation, treat that as a signal about your data, not a bug in the tool.

Frequently asked questions

Official sources

1. Official README
2. Project repository
3. Release notes