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.
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:
- The CLI accepts a task and initializes the local neural runtime.
- The neural guest maintains the conversation records and requests a worker response using its retained context.
- The native model adapter serializes that context, adds system instructions, sends the request, checks the response and returns a typed frame.
- 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.
- 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.
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.
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.
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.
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.
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.
Model tree for Freddiex/wintermute
Base model
percepta-ai/spotlight-vm




