A trajectory is not yet training data

Claude Code and Codex already produce valuable real-world trajectories: failed attempts, human corrections,
discarded changes, recovery paths, tests, and successful implementations. But a raw transcript still lacks a
stable task boundary, reconstructable repository state, replayable environment, validated verifier, privacy
review, and provenance.

EvoTrace compiles that missing layer:

Real-world Claude Code / Codex sessions
                    ↓
        import + Git/repo archaeology
                    ↓
        evidence-backed trajectory mining
                    ↓
 preference data  ·  RL environments  ·  execution rewards
                    ↓
       train locally · evaluate · license eligible assets

The same executable task can evaluate an agent today, generate and score new rollouts tomorrow, and become
high-quality verifier-grounded RL data. The future opt-in EvoTrace Marketplace will let users license reviewed,
rights-cleared assets on terms they control instead of surrendering raw history to a data intermediary.

EvoTrace also closes a second loop: an Explorer generates and executes repository questions, an Experience
Compressor distills the grounded trajectory, and fresh solver attempts test whether that packet improves a truly
held-out task. Compression is judged by downstream execution success—not by whether an LLM likes the summary.

real repo → execution exploration → trajectory capsule → experience packet
                                                      ↓
                     held-out task: baseline vs conditioned solver
                                                      ↓
                         Docker reward → adaptive curriculum

[!IMPORTANT]
The Marketplace and managed fine-tuning integrations are roadmap products. The current open-source release
works locally. Nothing is uploaded, sold, or shared by default.

Built on DeepSeek Harness

EvoTrace is now a specialized distribution of
DeepSeek Harness, not a separate ad-hoc chat UI.

DeepSeek Harness supplies the browser/agent shell, sessions, streaming, slash-command surface, provider settings,
credential storage, approvals, and plugin runtime. EvoTrace supplies the domain composition:

• Claude Code and Codex history import;
• trajectory mining and evidence catalog;
• one Orchestrator that opens four least-privilege DeepSeek subagents in sequence;
• fixed, allowlisted compiler tools backed by the existing Python core;
• EvoTrace branding and onboarding copy;
• a Docker-only contract for future autonomous execution.

The Python package is now an internal deterministic compiler sidecar. It no longer owns the product interface,
model routing, or agent loop.

Quickstart

One-line install — macOS, Linux, WSL

curl -LsSf https://raw.githubusercontent.com/jinzijian/EvoTrace/main/install.sh | sh

Then launch the app:

evotrace

New sessions default to the Harness Full access permission preset. To start
with the narrower workspace sandbox instead, run
DSH_PERMISSION_MODE=workspace-write evotrace.

One-line install — Windows PowerShell

irm https://raw.githubusercontent.com/jinzijian/EvoTrace/main/install.ps1 | iex
evotrace

From source

Requires Git, Node.js 22.19+ or 24+, Python 3.9+, and Docker for isolated execution work.

git clone https://github.com/jinzijian/EvoTrace.git
cd EvoTrace
python3 -m venv .venv
.venv/bin/python -m pip install -e .
pnpm install
pnpm dev

On first launch:

1. choose a workspace;
2. optionally configure DeepSeek, OpenAI, or Anthropic in Settings;
3. type / to open the command palette;
4. run /init to index existing Claude Code and Codex history.

Useful commands inside the app:

/init [all|codex|claude]    import existing history and refresh mining
/candidates                browse ranked, evidence-backed candidates
/search payment retry      search tasks, repos, and evidence
/show 1                    inspect provenance and readiness gaps
/review 1                  run the four-agent sequential review pipeline
/build 1                   compile a Docker-ready asset candidate
/validate 1                reject the base and accept the reference in Docker
/calibrate 1               run 5 DeepSeek attempts and target 2 verifier passes
/harden 1                  derive, verify, and self-play a harder child task
/evolve 1 2                explore asset 1, test compressed experience on held-out asset 2
/assets                    inspect compiled assets
/runs                      inspect saved validation evidence
/doctor                    check local integrations

These are native Harness slash commands, and the same operations are exposed as typed agent tools. API keys are
entered in the Harness Settings UI; EvoTrace does not accept keys in slash commands or store them in trajectories.

One orchestrator, four sequential subagents

/review <candidate> starts one model turn. The EvoTrace Orchestrator then waits for each foreground DeepSeek
Harness child before starting the next one, so downstream stages receive upstream evidence instead of producing
four unrelated votes. Candidate Gate must first record one immutable route: direct, derived_seed,
preference_only, or reject. EvoTrace binds that decision to the exact candidate ID; build/harden tools reject
candidate switching, and validation is bound to the asset actually produced by the hardener.

Only the EvoTrace Orchestrator is exposed in the product roster. Each role is a fresh, foreground, one-shot child
session with a role-specific tool allowlist and no delegation tools. The generic DeepSeek Harness coding presets
are intentionally excluded because they have a different host-access contract.

What an asset contains

Mined, Buildable, bundle generated, and Verified are different states. A history import is buildable only
when it has a meaningful task, an execution-verifiable route, a repository base, medium-or-better reconstruction,
a recovered reference patch, runnable verification commands, and a supported environment. Empty attachment
wrappers, low-confidence reconstructions, and missing Node manifests fail closed instead of producing weak
bundles. EvoTrace never promotes a generated verifier to Verified merely because an LLM wrote it.

Codex subagent/fork trajectories remain indexed with parent lineage for audit and future preference mining, but
they are hidden from the default candidate list so one parent session is not counted as several independent tasks.
Use /candidates --all to inspect them explicitly.

Security

• Importers read Claude Code/Codex history and Git evidence without modifying the source files.
• The Orchestrator and its leaf subagents expose fixed domain operations, not arbitrary host shell or filesystem tools.
• DSH telemetry is disabled by the EvoTrace launcher unless the user explicitly overrides it.
• Local product state lives under ~/.evotrace/; Harness state is isolated under ~/.evotrace/harness/.
• Verifier validation runs in a fresh Docker world with no host
  source bind mount, Docker socket, host network, privileged mode, host credentials, or arbitrary output path.
• Builder and Verifier Critic are separate child sessions. A builder cannot approve its own verifier.
• /review is strictly sequential: Episode Miner → Candidate Gate → Task Builder/Hardener → Verifier Critic.
• /calibrate is explicitly opt-in because task context is sent to the configured DeepSeek provider. Every attempt starts from a fresh task-only workspace; the reference stays hidden, and final scoring runs in Docker without host mounts.
• /evolve is also opt-in. Exploration runs in a disposable workspace sandbox; hidden reasoning is excluded from the saved capsule, secrets and absolute paths are redacted, the raw capsule is withheld from downstream solvers, and candidate patches are scored in Docker.
• Explorer, Compressor, and every paired solver attempt must pass the workspace-boundary access audit before an evolution can be certified.

Read the normative sandbox contract and design.

[!WARNING]
EvoTrace is early alpha, and DeepSeek Harness is currently a developer preview. Mining labels and generated
verifier candidates are evidence, not proof. Review every asset before training on it or sharing it.

Current status

V0.8 now includes:

• a real DeepSeek Harness Web app with EvoTrace title, mark, onboarding, and provider settings;
• one managed EvoTrace Orchestrator with four foreground, least-privilege subagent roles;
• native /init, /import, /mine, /candidates, /search, /show, /review, /build, /harden, /validate, /calibrate, /evolve, /assets, /runs, /doctor flows;
• Claude Code and Codex import, edit-event reference reconstruction, deterministic mining, bundle generation, provenance, and privacy gates;
• fail-closed build-readiness gates, command-aware Python/Node environment inference, and default deduplication of nested Codex subagents;
• immutable /review route tokens and produced-asset lineage, preventing downstream stages from mutating a different candidate;
• Docker-only two-state verifier validation: the behavioral verifier must reject the base state and accept the reference state;
• immutable run evidence tied to the exact bundle digest; only a conforming Docker run promotes an asset to Verified.
• DeepSeek self-play difficulty calibration: independent five-way attempts, target-pass tracking, automatic hint addition/removal, reference-gated verifier overlays, and a too_easy/too_hard result when a task cannot be honestly forced into the target bucket.
• execution-experience evolution: autonomous runtime exploration, grounded trajectory compression, paired baseline/conditioned held-out solving, Docker rewards, measured utility, and curriculum feedback.

/evolve <source> <held-out> requires two independently built tasks from the same repository for a certifying
functional-compression result. Omitting the second asset deliberately produces smoke_only: it verifies the
wiring but cannot prove transfer because the source and evaluation task are identical.

Still in progress:

• broader cross-language dependency repair and autonomous environment-builder loops;
• semantic held-out task generation and adversarial task mutation for assets that remain too easy after all legitimate hints are removed;
• validated DPO/SFT/RL dataset exporters;
• the opt-in Marketplace and fine-tuning-service integrations.

Acknowledgements

• DeepSeek Harness is the application and agent foundation.
• Microsoft RepoLaunch is a primary inspiration for reproducible
  repository-to-environment construction. EvoTrace begins earlier, by mining tasks and learning signals from lived
  coding-agent work.

License

Apache-2.0. See LICENSE and NOTICE.