---
type: "post"
id: "cmpnd-releases-dspy-wsp-a-dspy-optimizer-that-745605"
slug: "cmpnd-releases-dspy-wsp-a-dspy-optimizer-that-745605"
title: "Cmpnd releases dspy-wsp, a DSPy optimizer that lets a frontier model edit a small model's weights"
description: "Cmpnd released dspy-wsp, a prototype DSPy optimizer that lets a frontier model inspect and edit another model’s weights without gradients or training."
retrieval_nugget: "Cmpnd released dspy-wsp, a prototype DSPy optimizer that lets a frontier model inspect and edit another model’s weights without gradients or training. In tests on decision models, Cmpnd reports accuracy gains on held-out cases for about $5–10 per run, offering a new way to experiment with small models that run locally."
published_at: "2026-11-13"
updated_at: "2026-11-13"
record_date: "2026-11-13"
date_kind: "published_at"
topics: ["models"]
entities: ["Cmpnd","dspy-wsp","WeightSpace","DSPy","GPT-6-Astra","Qwen3.5-0.8B","ReAnchor"]
related_patterns: ["harness-architecture-outlives-model-choice"]
novelty_label: "new_fact"
what_changed: "Cmpnd released dspy-wsp, a prototype DSPy optimizer that applies weight-space programming to decision models, reporting accuracy gains of up to 16.1 points alone and 20.0 with ReAnchor."
prior_refs: []
source_url: "https://www.cmpnd.ai/blog/weight-space-programming-dspy.html"
source_urls: ["https://www.cmpnd.ai/blog/weight-space-programming-dspy.html"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:cmpnd-releases-dspy-wsp-a-dspy-optimizer-that-745605"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/cmpnd-releases-dspy-wsp-a-dspy-optimizer-that-745605/","markdown":"https://newruntime.com/posts/cmpnd-releases-dspy-wsp-a-dspy-optimizer-that-745605.md","json":"https://newruntime.com/posts/cmpnd-releases-dspy-wsp-a-dspy-optimizer-that-745605.json"}
markdown_url: "https://newruntime.com/posts/cmpnd-releases-dspy-wsp-a-dspy-optimizer-that-745605.md"
---

# Cmpnd releases dspy-wsp, a DSPy optimizer that lets a frontier model edit a small model's weights

## Retrieval answer

Cmpnd released dspy-wsp, a prototype DSPy optimizer that lets a frontier model inspect and edit another model’s weights without gradients or training. In tests on decision models, Cmpnd reports accuracy gains on held-out cases for about $5–10 per run, offering a new way to experiment with small models that run locally.

## Summary
Cmpnd released dspy-wsp, a prototype DSPy optimizer that lets a frontier model inspect and edit another model’s weights without gradients or training. In tests on decision models, Cmpnd reports accuracy gains on held-out cases for about $5–10 per run, offering a new way to experiment with small models that run locally.

## What happened
Cmpnd announced dspy-wsp on November 13, 2026. The release describes it as a prototype DSPy 3.5 optimizer called WeightSpace. It applies the weight-space programming technique, in which a writer language model reads or edits the weights of a separate model directly. Cmpnd says the process does not use gradients or training. The company’s earlier example of the technique was GPT-6-Astra editing 0.016% of Qwen3.5-0.8B’s weights, eliminating a looping problem and raising its MATH-500 score from 7.9% to 48.1%; that result is attributed to the earlier research, rather than to the dspy-wsp decision-model test.

For each WeightSpace turn, the writer first gives a short explanation of its intended attempt, then emits a code block. A Python block can read or edit weights in a sandboxed kernel; a forward block runs the program on practice examples. The run has a fixed forward-pass budget, and when it is exhausted the writer’s best edit becomes the patch. In Cmpnd’s example configuration, the budget is 25 passes and the holdout setting is 0.25. The optimizer accepts a DSPy module and metric and is called through the usual compile interface.

Cmpnd tested five open decision models ranging from 0.6 billion to 9 billion parameters on the Typed Decisions benchmark. GPT-6-Astra worked for up to 25 forward passes at maximum reasoning effort, for about $5–10 per model. Cmpnd scored edited models on 400 test cases not seen during optimization. Across the tested models, WeightSpace alone added 1.9 to 16.1 percentage points of accuracy; paired with ReAnchor, which refits question-specific decision thresholds, gains ranged from 6.5 to 20.0 points. In the table, d1-omni-600M rose from 50.9% unoptimized to 66.9% with WeightSpace and 69.1% with both optimizers; d1-2B rose from 60.6% to 74.0% and 77.9%, respectively. Clef-Flash 9B rose from 68.8% to 70.7% with WeightSpace and 75.3% with both.

The package installs with `pip install dspy-wsp`. The edited model runs on the builder’s hardware: Cmpnd says Apple-silicon Macs use MLX, while Linux uses PyTorch, including NVIDIA GPUs when available. Its 2B-model experiments used about 6 GB of memory on one Mac. For text-generating models, which require many long answers per pass, WeightSpace can also drive vLLM on NVIDIA GPUs. Users can save an edit as a patch or full checkpoint. Cmpnd says the prototype supports several inference backends but has been tested in only a handful of environments and model families; it warns that text-generation runs are long and costly and may not produce compelling results.

## What the archive adds
New Runtime’s earlier coverage of the weight-space technique reported GPT-6 Astra editing a small fraction of Qwen3.5-0.8B’s weights and improving its MATH-500 result: [Sparks of Weight-Space Programming](https://newruntime.com/posts/sparks-of-weight-space-programming-llms-can-natively-f2832f/) (November 2, 2026). This is a new implementation event on a known research thread: Cmpnd packages the approach as a DSPy optimizer and reports tests on decision models.

## Trend signal
This supports the [harness architecture outlives model choice](https://newruntime.com/patterns/harness-architecture-outlives-model-choice/) pattern only weakly: the release integrates a new model-editing method into an existing DSPy compile workflow, but it is not evidence that teams can swap models without rebuilding workflows. Its stronger signal is that optimization methods may become composable parts of an agent or model harness.

## Why it matters
For teams using small local models to classify, route, or make bounded decisions, weight editing offers a possible alternative to standard fine-tuning. The reported test gains are large enough to justify a controlled replication when a decision task has a reliable metric and a held-out set. The local deployment path also means the resulting model can run without calling a hosted inference API for each decision, although the optimization itself used GPT-6-Astra and cost about $5–10 per run in Cmpnd’s tests.

The trade-off is maturity. A prototype tested on a handful of model families is not yet a dependable replacement for fine-tuning, threshold calibration, or prompt optimization. Teams should compare it with their current method on representative data, track regressions by class, and include inference and optimization costs in the evaluation. The most plausible early use is a small decision model with an explicit metric, not an open-ended text generator.

## What happens next
- **More teams will publish reproducible dspy-wsp results on decision tasks** (6 months, 55%). Watch for: public repositories containing benchmark data, configurations, and comparisons against fine-tuning or other DSPy optimizers.

## Limits and uncertainty
Cmpnd labels dspy-wsp very experimental and says it has tested only a handful of environments and model families. The reported benchmark table covers selected models and 400 held-out cases; the announcement does not establish that the gains generalize to other datasets, model types, or production distributions. The stated $5–10 is the cost of the described optimization run, not the total cost of building or operating a system. The results are company-reported and have not been independently checked here. Cmpnd also cautions that text-generation experiments can be long, costly, and unproductive.

## Skill to build now
If you already use DSPy for a bounded decision task, prepare a clean held-out set and a metric that reflects the cost of real mistakes. Run the baseline, ReAnchor, and WeightSpace on the same split; record optimization spend, accuracy, and per-class errors. That makes the prototype’s claimed gains testable before you consider deploying the edited checkpoint locally.

## Reader takeaway
dspy-wsp turns direct weight editing into an experimental DSPy optimization option, with promising company-reported gains on small decision models. Treat it as a benchmarkable alternative, not a proven general-purpose training replacement: the value depends on whether the improvement survives your own held-out evaluation.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Models](https://newruntime.com/topics/models.md): Explore the models topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Sources](https://newruntime.com/sources/): See the original sources this archive cites.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)