Wintermute

Wintermute is an experimental neural agent harness. A small, constructed Spotlight transformer executes the harness's control and tool procedures; an external language model decides how to solve the user's task. The runtime performs real file operations and runs real Python and Bash processes.

Version 0 investigates whether a neural harness can perform useful multi-step work in place of a conventional software harness, and measures the execution cost. It demonstrates feasibility on a selected development panel; it does not establish general equivalence or superior task-solving ability.

Built on Percepta AI's research. Wintermute uses Percepta AI's Spotlight VM, its constructed base weights and memory image, and compiler components from Transformer VM. The foundational model and memory mechanism are Percepta AI's work. See Spotlight Memory and Can LLMs grow their own capabilities?. Wintermute adds the agent guest program, its constructed fixed-program lookup, host integration, lifecycle policy, CLI and comparative evaluation. This is an independent project, not a Percepta AI product or endorsement.

Architecture

Wintermute separates task reasoning, harness execution, and physical services. The external LLM proposes actions. The local neural guest carries out harness continuations and tool algorithms. Native adapters perform the requested network, filesystem and process operations and return observations.

Wintermute architecture: bundled Rust runtime, specialized neural core, Spotlight memory, universal executor and external interfaces

The overview shows the bundled native services and neural application separately. Physical I/O remains a host operation; installing procedures changes program memory, not the caller weights. The worker API box is conceptual: the later Astra evaluation used direct OpenAI Responses.

The earlier detailed diagram, its SVG, Graphviz source, and source audit remain available separately; they are not editable sources for the supplied overview.

A typical task follows this cycle:

  1. The CLI accepts a task and initializes the local neural runtime.
  2. The neural guest maintains the conversation records and requests a worker response using its retained context.
  3. The native model adapter serializes that context, adds system instructions, sends the request, checks the response and returns a typed frame.
  4. The worker's tool call drives the guest's neural tool procedure. For example, search matching and edit calculations run neurally, while reading file bytes or launching Python requires a host effect.
  5. The guest publishes an effect request. The native boundary checks and dispatches it, then delivers the result. The guest records the observation and continues until it presents a final response or stops.
Component What it owns Implementation
External worker LLM Task reasoning, proposed commands/code, final wording Separate model endpoint
Neural guest Continuations, history retention, payload reclamation, tool algorithms and effect requests guest.rs, executed through Spotlight and constructed lookup coefficients
Writable Spotlight state Conversation records, tool state and payloads Neural memory operations backed by native runtime storage
Effect boundary and adapters Committed-request validation, API encoding/schema checks, transport budgets, physical I/O and process services bridge.c, lib.rs, api.rs, host.rs, process.rs, jobs.rs
Numerical runner Evaluates neural operations and advances the VM Native C/SIMD kernels
Optional installed procedure Supported Wasm compilation, child scheduling and isolated neural execution Native compiler/scheduler plus a universal neural child; procedure.rs

At build time, the Rust guest is lowered through Wasm into a fixed program, then converted into constructed lookup coefficients. The specialized runtime combines that lookup with Percepta AI's base Spotlight model. This is not an LLM translating the guest on each request, and it is not a training run.

Python and Bash commands execute as ordinary host processes. HTTP transport, response validation, rendering and resource accounting also remain native. The claim is neural execution of the guest harness, not that every supporting operation is neural or that weights directly issue OS syscalls.

The Rust reference executes the same guest policy conventionally through the same host-service interface. It is a separate comparison backend, not an automatic fallback inside the production neural runtime.

Both backends use bounded rolling context: retain the task/latest user instruction and recent complete exchanges, discard older exchanges, and reclaim payload storage. There is no learned retention policy, summarizer or shared latent representation with the worker LLM in v0.

Quickstart

The release includes source, weights and a Linux x86-64 runtime bundle. The binary requires compatible glibc, libcurl/TLS libraries, and Python 3 and Bash for host tools. It is not a statically linked, cross-platform executable.

From the downloaded repository:

tar -xzf binaries/wintermute-linux-x86_64.tar.gz
./wintermute-linux-x86_64/wintermute --help
./wintermute-linux-x86_64/wintermute auth set
./wintermute-linux-x86_64/wintermute model set deepseek/deepseek-v4.1-flash-1017
./wintermute-linux-x86_64/wintermute "Write and execute a Fibonacci program"

Run the binary without a task for interactive chat. Loading finishes before the first input prompt. Use /help, /status and /exit; Ctrl-C requests cooperative cancellation.

The worker model is configurable. DeepSeek V4.1 Flash was used in the live pilot; the code's fallback model is qwen/qwen3-coder. Model and provider availability depend on OpenRouter. The external worker weights are not included in this repository.

auth set reads the key without echo and saves it locally in an owner-only credentials file. It does not embed the key in the binary. OPENROUTER_API_KEY overrides the saved credential. Transport preferences live in $XDG_CONFIG_HOME/wintermute/ or ~/.config/wintermute/; no personal configuration or credentials are shipped.

Host commands run with the process user's permissions. Workspace restrictions on file tools are not a sandbox for Python or Bash. Use a disposable container or another isolated environment for untrusted tasks.

Example sessions

The transcripts below show the full startup, tool activity, replies and resource summary. Plain text keeps the examples searchable and copyable; the interactive terminal also adds colour and a live activity indicator.

These are actual CLI captures using the shipped offline response fixtures, with real neural execution and real host file/process operations. Assistant wording is scripted, API waiting is approximately zero, and there is no API spend. They demonstrate the interface, not autonomous task-solving or live performance. Live replies, tool sequences, timings and memory usage will vary. Temporary workspace paths and header padding are normalized; typed chat input is included.

For ordinary live use, run:

./wintermute-linux-x86_64/wintermute "Write and execute a Fibonacci program"
./wintermute-linux-x86_64/wintermute

The fixture commands shown in the transcripts reproduce the demonstrations without a key. Replace wintermute with ./wintermute-linux-x86_64/wintermute if the binary is not on your PATH.

Fibonacci: write a program, execute it and verify seven cases

$ wintermute --workspace demo-fibonacci --api-fixture examples/fibonacci.json "Write and execute a Fibonacci program"

β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”
β”‚ Wintermute                                                                                       β”‚
β”‚ Revision   v0                                                                                    β”‚
β”‚ Execution  specialized neural Β· 1 CPU thread                                                     β”‚
β”‚ Model      Spotlight base Β· 8 layers Β· width 16 Β· 8 heads/layer Β· FP32                           β”‚
β”‚ Parameters 323,374 Β· base 46,342 + lookup 277,032                                                β”‚
β”‚ LLM        offline replay Β· no model API                                                         β”‚
β”‚ Workspace  demo-fibonacci                                                                        β”‚
β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜

  [ OK ] Loaded neural weights      Β· 0.001s
  [ OK ] Initialized neural harness Β· 0.150s

  VM Β· 5,977 neural tokens Β· 26,398 tok/s Β· 0.226s inference
  Waiting for LLM endpoint…
  LLM endpoint Β· 0.00s wait Β· offline/adapter

write Β· specialized β†’ host filesystem
  βœ“ fib.py Β· Wrote 353 bytes
  VM Β· 7,450 neural tokens Β· 26,615 tok/s Β· 0.280s inference
  Waiting for LLM endpoint…
  LLM endpoint Β· 0.00s wait Β· offline/adapter

execute Β· specialized β†’ host process
  python Β· import subprocess …
  βœ“ exit 0 (outer process)
  VM Β· 23,791 neural tokens Β· 26,513 tok/s Β· 0.897s inference
  Waiting for LLM endpoint…
  LLM endpoint Β· 0.00s wait Β· offline/adapter
  VM Β· 3,420 neural tokens Β· 26,491 tok/s Β· 0.129s inference

Wintermute
Created fib.py and ran it successfully.

Run: python3 fib.py 10
Output: 55

It prints the nth Fibonacci number, with F(0)=0 and F(1)=1.
Verified exact results for 0, 1, 10 and 20, plus exit code 2 for negative, non-integer and missing arguments. All seven checks passed.
  VM Β· 324 neural tokens Β· 26,089 tok/s Β· 0.012s inference

Files changed: fib.py

Session completed Β· 1.89s active Β· 1.55s neural Β· replay 0.00s Β· replay (no API spend)
  RAM Β· 139.4 MiB resident Β· 161.3 MiB peak (process)

Download transcript Β· Response fixture.

Chat: load the harness, exchange messages and exit

$ wintermute --workspace demo-chat --api-fixture examples/chat.json

β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”
β”‚ Wintermute                                                                                       β”‚
β”‚ Revision   v0                                                                                    β”‚
β”‚ Execution  specialized neural Β· 1 CPU thread                                                     β”‚
β”‚ Model      Spotlight base Β· 8 layers Β· width 16 Β· 8 heads/layer Β· FP32                           β”‚
β”‚ Parameters 323,374 Β· base 46,342 + lookup 277,032                                                β”‚
β”‚ LLM        offline replay Β· no model API                                                         β”‚
β”‚ Workspace  demo-chat                                                                             β”‚
β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜

  [ OK ] Loaded neural weights      Β· 0.001s
  [ OK ] Initialized neural harness Β· 0.154s

Type /help for commands; /exit to finish.

β€Ί hi
  VM Β· 4,243 neural tokens Β· 26,470 tok/s Β· 0.160s inference
  Waiting for LLM endpoint…
  LLM endpoint Β· 0.00s wait Β· offline/adapter
  VM Β· 3,420 neural tokens Β· 26,392 tok/s Β· 0.130s inference

Wintermute
Hi! What can I help you with?
Response ready Β· 0.29s Β· 7663 neural tokens Β· uncapped token budget

β€Ί What can you do?
  VM Β· 4,554 neural tokens Β· 26,093 tok/s Β· 0.175s inference
  Waiting for LLM endpoint…
  LLM endpoint Β· 0.00s wait Β· offline/adapter
  VM Β· 3,420 neural tokens Β· 26,368 tok/s Β· 0.130s inference

Wintermute
I can inspect and edit files in the workspace, search code, and run Python or Bash commands. Tell me a task and I can work through it, check the results, and explain what changed.
Response ready Β· 0.27s Β· 7062 neural tokens Β· uncapped token budget

β€Ί /exit
  VM Β· 1,478 neural tokens Β· 26,475 tok/s Β· 0.056s inference

User input wait Β· 0.00s
Session completed Β· 0.81s active Β· 0.65s neural Β· replay 0.00s Β· replay (no API spend)
  RAM Β· 139.1 MiB resident Β· 161.6 MiB peak (process)

Download transcript Β· Response fixture.

Capture script Β· Capture provenance. To record both examples again:

python3 examples/capture.py ./wintermute-linux-x86_64/wintermute --output /tmp/wintermute-example-captures

Offline smoke test

No API key or paid model call is needed:

python3 tests/offline_smoke.py ./wintermute-linux-x86_64/wintermute

This tests startup, a real file write, chat continuation and clean exit using fixed responses. It tests integration, not the language model's ability to solve a task.

Model and weight accounting

The weights are analytically constructed, not learned through a Wintermute training run.

Property Value
Transformer layers 8
Residual width 16
Spotlight head slots 8 per layer
Base checkpoint floating coefficients 46,406
Base floating coefficients used by the C loader 46,342
Constructed lookup entries 69,258
Lookup scalar coefficients, including coordinates 277,032
Runtime base plus lookup coefficients 323,374
Stored floating coefficients, including unused alpha tensors 323,438
Runtime precision FP32
Base checkpoint storage precision FP64, converted on load
Core memory image 23,989,346 bytes

The 786 integer output-token IDs are a mapping, not floating weights. The base checkpoint also stores 64 alpha values that the C loader does not use. Lookup coordinates and coefficients are counted explicitly; this is scalar accounting, not a count of learned parameters.

The release ships the base checkpoint, vocabulary, configuration and core memory image under vendor/spotlight-vm/, and Wintermute's coefficients under wintermute-v0/runtime/specialization/build/lookup.weights. The constructed arrays are compiled into the specialized runtime. The core image includes inherited MicroPython material and arithmetic data; it is not solely conversation memory.

Weight size does not equal process memory. Cell maps, runtime state, loaded images, telemetry and child processes contribute separately.

Current capabilities and limits

  • Neural file reads, writes, searches, edits and directory traversal, backed by physical host services.
  • Atomic multi-chunk publication and optional version checks for file updates.
  • Python/Bash execution and process start, poll, input and cancellation services.
  • Multi-turn chat, bounded rolling history, exact output/evidence retention, single-use checkpoints and optional durable effect receipts.
  • No fixed 64-user-turn cap. Neural token budgets default to unlimited, but physical capacities and configured task/API limits still apply.
  • A default 256-record rolling context, configurable from 8 to 256 records. Eviction can lose useful semantic context.
  • Ordinary tool bodies remain bounded; extended writes allow up to 8 KiB content. File operations and output capture have additional byte limits.
  • Finite process/procedure capacity and restricted Wasm support. Durable recovery of live OS jobs is not promised.
  • Endpoint timeouts, partial responses, cancellation delays and incorrect model-generated artifacts remain possible.

The complete command and tool limits are available through --help and help.txt. Uncapped session length does not imply unlimited memory or guaranteed long-horizon success.

Live development pilot

The retained Relace v4 cohort contains 50 live attempts: five Terminal-Bench 2.1 development tasks Γ— two backends Γ— five repetitions. Both backends used DeepSeek V4.1 Flash and shared tool/context policies. Tasks ran inside qualified containers. These are local evaluations, not an official Terminal-Bench leaderboard submission.

Task Native artifact passes Neural artifact passes Native clean task passes Neural clean task passes
Log summary 5/5 5/5 5/5 5/5
Scientific-stack modernization 5/5 5/5 5/5 5/5
gRPC key-value service 5/5 5/5 5/5 5/5
Raman fitting 0/5 0/5 0/5 0/5
PyTorch model CLI 0/5 2/5 0/5 1/5
Total 15/25 17/25 15/25 16/25

β€œClean task pass” requires both passing artifacts and normal session completion. One neural PyTorch attempt passed the grader but did not complete its session.

Across the explicitly selected three task types passed by both backends, native/neural mean agent time was 65.38/81.59 seconds, and mean peak harness memory was 20.43/159.92 MiB. These are descriptive live differences, not an isolated neural overhead estimate: the agents took different trajectories and experienced different API waits.

Raman attempts ended on endpoint-related limits without passing artifacts. PyTorch failures included incorrect predictions, incomplete sessions and forced termination. The later Astra evaluation is reported below; provider, transport and runtime-policy changes prevent treating it as a model-only ablation. The evidence does not attribute every failure to either model intelligence or harness architecture.

No context-capacity stop was recorded in this cohort. This is evidence for the tested workloads, not proof of lossless memory or unlimited reliable execution. The final forced-termination attempt lacks final runtime metrics; monitor evidence remains available. Missing values are retained rather than treated as zero.

These five task types are a development case study. Five repetitions do not create 25 independent task types, and the observed pass counts do not establish neural superiority. Historical experiments used frozen binaries; current release changes must not be attributed retrospectively to those measurements.

Live pilot overview

Detailed timings, CPU, memory, tokens, billing coverage and failure analysis are in the pilot report, 50-attempt CSV and analysis JSON. These are sanitized exports; original absolute source paths are made relative. Full traces, task environments and frozen benchmark binaries are not included in this compact release.

Astra follow-up: complete five-task panel

The GPT-6.2 Astra follow-up (medium reasoning, direct Responses API) completed 50 attempts: five tasks Γ— two backends Γ— five repetitions. Both backends achieved 20/25 artifact passes and 20/25 clean passes (80%). All 50 sessions completed normally, with no recorded harness errors or endpoint failures. Four task types passed on every attempt; all ten Raman attempts failed the 2D-peak numerical check. No failures were discarded or automatically retried.

Task Backend Artifact / clean passes Completed sessions Active time, mean Β± SD Active time range Mean peak harness RAM
Log summary Native 5/5 / 5/5 5/5 23.68 Β± 4.03 s 19.06–30.17 s 18.3 MiB
Log summary Neural 5/5 / 5/5 5/5 26.89 Β± 2.56 s 24.65–30.72 s 159.6 MiB
Scientific stack Native 5/5 / 5/5 5/5 40.77 Β± 4.95 s 35.47–47.35 s 18.4 MiB
Scientific stack Neural 5/5 / 5/5 5/5 39.50 Β± 2.94 s 37.18–44.17 s 160.3 MiB
gRPC service Native 5/5 / 5/5 5/5 44.05 Β± 2.03 s 41.35–46.20 s 18.8 MiB
gRPC service Neural 5/5 / 5/5 5/5 49.64 Β± 3.77 s 46.91–56.25 s 159.8 MiB
Raman fitting Native 0/5 / 0/5 5/5 38.03 Β± 2.25 s 35.24–40.28 s 19.5 MiB
Raman fitting Neural 0/5 / 0/5 5/5 44.83 Β± 3.62 s 40.61–50.00 s 159.7 MiB
PyTorch CLI Native 5/5 / 5/5 5/5 93.16 Β± 36.84 s 69.24–158.05 s 20.8 MiB
PyTorch CLI Neural 5/5 / 5/5 5/5 82.20 Β± 11.79 s 69.32–94.54 s 159.8 MiB

SD is the sample standard deviation across five repetitions. Active time excludes environment setup and grading. RAM is the mean of per-attempt peak harness-process RSS; it excludes child processes and remote inference. The CSV retains each individual sample, including its own peak RAM and timing.

The following quantities are means per attempt. LLM input tokens include repeated context across requests and cached tokens; output tokens include reported reasoning. These are external-worker tokens, distinct from Wintermute's neural execution tokens, which are recorded separately in the detailed exports.

Task Backend API wait Harness computation API requests LLM input tokens LLM output tokens Estimated API cost
Log summary Native 23.45 s 91 Β΅s 5.8 51,628 537 $0.079
Log summary Neural 19.40 s 7.02 s 5.6 49,465 507 $0.069
Scientific stack Native 38.28 s 166 Β΅s 9.4 94,163 784 $0.115
Scientific stack Neural 27.58 s 9.51 s 9.0 87,868 779 $0.112
gRPC service Native 42.00 s 112 Β΅s 10.0 97,807 1,161 $0.144
gRPC service Neural 37.65 s 9.75 s 10.2 101,139 1,208 $0.150
Raman fitting Native 37.50 s 135 Β΅s 8.6 78,688 1,249 $0.156
Raman fitting Neural 36.71 s 7.51 s 9.0 83,547 1,311 $0.161
PyTorch CLI Native 81.51 s 214 Β΅s 18.0 250,283 2,415 $0.345
PyTorch CLI Neural 59.77 s 15.55 s 15.2 189,694 2,154 $0.291

Total recorded batch time was 1 h 14 min 38 s, including setup and grading but excluding gaps between invocations. Estimated API cost was $8.11 for these 50 attempts. All calls supplied token usage. Cost uses actual recorded cache-read and cache-write categories at standard Astra rates checked on 2026-11-18: $8/M ordinary input, $0.40/M cached input, $10/M 30-minute cache writes, and $40/M output. It is not a reconciled provider invoice and excludes preliminary budget-limited/interrupted attempts. The export script also handles 12-hour cache writes and long-context rates when applicable.

Neural PyTorch attempts averaged 15.55 s of harness computation, but followed shorter trajectories (15.2 versus 18.0 requests) and waited less for the API. Their lower mean elapsed time is not an isolated neural speedup. Host workload, API waiting and different model decisions contribute to live elapsed time; matched replay remains the controlled execution-overhead measurement.

Historical worker comparison

Worker/configuration Native artifact passes Native clean passes Neural artifact passes Neural clean passes
DeepSeek V4.1 Flash / Relace v4 pilot 15/25 15/25 17/25 16/25
GPT-6.2 Astra / direct Responses follow-up 20/25 20/25 20/25 20/25

A clean pass requires both a passing artifact and a normally completed session. The two panels total 100 attempts on five selected development tasks. They provide repeated evidence of practical neural-harness execution with two worker families, not 100 independent task types. Equal Astra success counts do not prove statistical equivalence or equal general reliability. DeepSeek/Astra differences also include provider, transport and runtime-policy changes; this is a comparison of configured agents, not a controlled model-only ablation. Task selection and prior diagnosis make this an exploratory case study rather than a held-out score.

Detailed, portable exports: 50-attempt Astra CSV and aggregate statistics, pricing and source hashes. The CSV contains per-run timing, peak memory, request/tool counts, input/output, cache and reasoning-token usage, neural execution tokens, outcomes and estimated cost. Source paths are repository-relative; prompts, credentials and raw worker responses are not exported. These are later evaluation results from the development runtime, not a claim that the packaged binary below has been upgraded. The bundled runtime/source/weights remain unchanged by this documentation update. Raw task environments, traces and evaluation binaries are not distributed here. No Hugging Face upload has been performed by this staging update.

Raman caveat: the instructions do not prescribe a fitting window. In round 1, both Astra agents fitted the 2D peak over 2580–2760 cm⁻¹; the supplied reference uses 2500–2900 cm⁻¹. Their widths (18.55160) and offsets (907.04) fail tolerances around 17.52 and 1239.09. In a post-hoc offline audit, changing only the window predicate in each archived fitting algorithm makes all four 2D numerical checks pass. Independent SciPy fits reproduce this sensitivity. The expected reference values are reproducible: this supports an underspecified fitting-choice caveat, not a claim of a broken grader or a neural-specific failure. Neither the task, grader nor original submissions were changed; official failures remain failures. Across all ten Astra Raman attempts, only the 2D-peak test failed: every fitted offset was below tolerance, and some widths also failed. The exact window-only intervention was verified on round 1; it was not repeated for all ten attempts. These findings do not retrospectively explain DeepSeek's endpoint/context failures. See the reproducible Raman audit.

The user removed local dollar admission limits after conservative budgeting prematurely stopped earlier attempts. The current follow-up uses provider-default output allowance, retains time/request limits, and performs no automatic retries. Raw usage and evidence are retained. Both task panels preserved their first rounds separately and completed rounds 2–5 without changing model-facing instructions or runtime policies. See the evaluation protocol.

Controlled replay comparison

An earlier matched Fibonacci interaction was replayed five times per backend, with real host execution and no LLM waiting. All 15 runs matched logical records, file contents, exit codes and captured output.

Metric, arithmetic mean Rust reference Python reference Neural
Complete replay 0.348 s 0.413 s 3.739 s
Host commands 0.330 s 0.333 s 0.331 s
Resident harness RAM 8.2 MiB 15.2 MiB 137.6 MiB
Peak harness RAM 8.2 MiB 15.2 MiB 159.5 MiB

Timing includes process/interpreter startup and report serialization. RAM excludes child processes and the remote worker. The limited Python reference implements this trajectory, not a complete agent or mini-swe-agent; its difference from Rust is not a pure language-overhead measurement.

These historical measurements isolate execution more closely than independent live trajectories, but do not predict all tasks or measure the latest release. All 15 samples.

Performance figures

These figures restore the recorded development measurements. They describe the historical configurations that produced the data, not a fresh benchmark of the current release. PNG previews and downloadable SVGs are included with their source tables.

Matched backend comparison

The same saved Fibonacci interaction was replayed five times per backend with real host execution and no LLM waiting. The chart shows individual samples and means for elapsed time and peak harness memory. The Python reference covers this trajectory only; it is not mini-swe-agent or a complete alternative harness.

Five matched Fibonacci replays: elapsed time and peak harness memory

SVG Β· All 15 samples Β· Source provenance.

Session timing and cost over development

All 74 eligible completed specialized Fibonacci sessions are shown, including slower runs. Active time, neural inference, API time and provider-reported cost are separate measurements. The trailing five-session median describes the observed history. Changes in generated programs, verification, prompts, retries and endpoint behavior mean this is not a controlled cumulative speedup experiment.

Fibonacci session timing, neural inference, API waiting and provider cost

SVG Β· Session data Β· Cohort summary.

Tool-specific optimizations

The seven optimization studies retain all 31 measured workload cases, including regressions. Each comparison uses median neural harness time from three runs per condition. Workloads differ between changes, so these reductions must not be added or multiplied into a cumulative speedup.

Neural tool optimization comparisons, including measured regressions

SVG Β· Medians, ranges and source hashes.

Controlled before-and-after replays

These earlier paired comparisons hold the external interaction fixed within each row and measure elapsed replay time. They include regressions and the rejected observation-reference experiment. Their elapsed-time metric differs from the neural-inference timer above, and the workloads differ between rows.

Controlled before-and-after specialized replay comparisons

SVG Β· Measurements, native controls and provenance.

Build from source

Use a recent Rust toolchain with wasm32v1-none, Python 3.11 or newer, a C compiler with x86 SIMD support, and libcurl development libraries. The current release is qualified on Linux x86-64.

rustup target add wasm32v1-none
cargo fetch --locked --manifest-path wintermute-v0/runtime/Cargo.toml
python3 wintermute-v0/runtime/build.py
cargo test --manifest-path wintermute-v0/runtime/Cargo.toml --lib
python3 tests/offline_smoke.py wintermute-v0/runtime/target/release/wintermute

The build lowers the Rust guest to Wasm, constructs the lookup, builds specialized/universal/native controls, verifies pinned upstream payloads and records new hashes. Compilation itself makes no model API calls. Cargo dependency fetching may require network access.

Outputs:

  • wintermute-v0/runtime/target/release/wintermute: production specialized neural CLI.
  • wintermute-v0/runtime/target/release/libwintermute.so: shared runtime.
  • wintermute-v0/runtime/target-reference/release/wintermute: native control.
  • wintermute-v0/runtime/target-universal/release/wintermute: universal neural control.

To package a newly built runtime:

python3 wintermute-v0/runtime/bundle.py /tmp/wintermute-bundle

The destination must not already exist. The bundler verifies the build manifest before copying the executable and dependencies. Release-file hashes are in SHA256SUMS; build/source provenance is in release-manifest.json.

Checksum scope: SHA256SUMS covers the release payloads but excludes itself and .gitattributes. Hugging Face may update .gitattributes when adding large-file tracking rules.

Repository layout

.
β”œβ”€β”€ README.md                         # Setup, architecture, results and limitations
β”œβ”€β”€ LICENSE                           # Wintermute's Apache-2.0 license
β”œβ”€β”€ NOTICE                            # Percepta AI credit and upstream attribution
β”œβ”€β”€ SHA256SUMS                        # Integrity checks for the published files
β”œβ”€β”€ release-manifest.json             # Source hashes, toolchain and evidence provenance
β”œβ”€β”€ architecture/                    # Overview diagram, editable source and code audit
β”œβ”€β”€ binaries/
β”‚   └── wintermute-linux-x86_64.tar.gz # CLI, shared library and required runtime assets
β”œβ”€β”€ examples/                        # Full CLI transcripts, offline fixtures and capture script
β”œβ”€β”€ tests/
β”‚   └── offline_smoke.py              # Startup, file write and chat test; no API charges
β”œβ”€β”€ results/
β”‚   β”œβ”€β”€ terminal-bench/               # DeepSeek pilot: 50 attempts and figures
β”‚   β”œβ”€β”€ terminal-bench-astra/         # Astra: 50 attempts, protocol and Raman audit
β”‚   β”œβ”€β”€ fibonacci/                    # Samples from the matched replay comparison
β”‚   └── performance-history/          # Historical charts, SVGs and measurement tables
β”œβ”€β”€ wintermute-v0/
β”‚   β”œβ”€β”€ runtime/
β”‚   β”‚   β”œβ”€β”€ src/                      # Rust host services, API transport, CLI and reference
β”‚   β”‚   β”œβ”€β”€ guest.rs                  # Agent program compiled for neural execution
β”‚   β”‚   β”œβ”€β”€ bridge.c                  # Typed boundary between the neural VM and host
β”‚   β”‚   β”œβ”€β”€ http.c                    # HTTP transport support
β”‚   β”‚   β”œβ”€β”€ system-prompt.txt          # Instructions sent to the external worker LLM
β”‚   β”‚   β”œβ”€β”€ help.txt                  # CLI commands, options and tool limits
β”‚   β”‚   β”œβ”€β”€ Cargo.toml / Cargo.lock   # Rust package and pinned dependency versions
β”‚   β”‚   β”œβ”€β”€ build.py / build.rs       # Guest compilation and runtime build
β”‚   β”‚   β”œβ”€β”€ bundle.py                 # Package a verified runtime with its assets
β”‚   β”‚   β”œβ”€β”€ python/                   # Python interface to the shared runtime
β”‚   β”‚   β”œβ”€β”€ build/                    # Guest Wasm, lowered program and instruction image
β”‚   β”‚   └── specialization/
β”‚   β”‚       β”œβ”€β”€ build_specialized.py  # Construct fixed-program lookup coefficients
β”‚   β”‚       β”œβ”€β”€ compile_procedure.py  # Compile supported Wasm procedures
β”‚   β”‚       β”œβ”€β”€ lookup_kernel.c.in    # Numerical lookup kernel template
β”‚   β”‚       └── build/                # Generated neural runtime and lookup.weights
β”‚   └── spotlight/
β”‚       β”œβ”€β”€ session.c / session.h     # Neural VM session and state integration
β”‚       β”œβ”€β”€ upstream-lock.json        # Pinned Percepta revision and payload hashes
β”‚       β”œβ”€β”€ build/                    # Session binding identifier
β”‚       └── bridge/, capacity/,
β”‚           roundtrip/                # Compiler encoding and lowering helpers
β”œβ”€β”€ vendor/
β”‚   β”œβ”€β”€ spotlight-vm/
β”‚   β”‚   β”œβ”€β”€ intelligence/            # Percepta base weights, configuration and vocabulary
β”‚   β”‚   β”œβ”€β”€ memory/                  # Core memory image and pinned upstream assets
β”‚   β”‚   └── ...                      # Pinned source, examples and original license
β”‚   └── transformer-vm/              # Required upstream compiler modules and license
└── experiments/neural-host/src/
    └── measurements.rs              # Shared timing helper; retained for build compatibility

The source paths are retained for build compatibility. Earlier experiments, local sessions, environments, caches and large build trees are excluded.

Attribution and license

Wintermute is released under Apache-2.0, consistent with the project's existing license declaration. Upstream licenses remain with the vendored files.

Percepta AI is credited for Spotlight VM, the base model, memory image, and the Transformer VM compiler foundation. The pinned Spotlight revision is 00acba5abee230535d14fa3e08825f999f382952; payload hashes are recorded in upstream-lock.json. See NOTICE for the modification summary and bundled notices.

This release does not include DeepSeek weights or redistribute the Terminal-Bench task environments. Worker-model and benchmark names identify experimental dependencies, not ownership or endorsement.

Future work includes faster neural execution, memory policies, preference alignment and tighter integration with the worker model. These are research directions, not capabilities demonstrated by the current results.

Downloads last month

-

Downloads are not tracked for this model. How to track
Inference Providers NEW
This model isn't deployed by any Inference Provider. πŸ™‹ Ask for provider support

Model tree for Freddiex/wintermute

Finetuned
(1)
this model