ibl.ai Agentic AI Blog

Insights on building and deploying agentic AI systems. Our blog covers AI agent architectures, LLM infrastructure, MCP servers, enterprise deployment strategies, and real-world implementation guides. Whether you are a developer building AI agents, a CTO evaluating agentic platforms, or a technical leader driving AI adoption, you will find practical guidance here.

Topics We Cover

Featured Research and Reports

We analyze key research from leading institutions and labs including Google DeepMind, Anthropic, OpenAI, Meta AI, McKinsey, and the World Economic Forum. Our content includes detailed analysis of reports on AI agents, foundation models, and enterprise AI strategy.

For Technical Leaders

CTOs, engineering leads, and AI architects turn to our blog for guidance on agent orchestration, model evaluation, infrastructure planning, and building production-ready AI systems. We provide frameworks for responsible AI deployment that balance capability with safety and reliability.

Back to Blog

Weight-Space Programming Is Now a pip install: dspy-wsp

Miguel AmigotNovember 19, 2026
Premium

Weight-Space Programming, from MIT CSAIL, has a frontier LLM read a small model's weights and edit them directly with no training run, and dspy-wsp now packages it as a DSPy optimizer. It only works on weights you hold, and the writer model's provider sees them while it works.

The Short Answer

Weight-Space Programming is an idea from MIT CSAIL researchers in which a frontier LLM reads a small model's weights and edits them directly, with no gradients or training run, and since November 8, 2026 it installs as dspy-wsp. It only works on weights you hold. On ibl.ai you own all the code and the data, so a model you edit stays yours to serve.

The method is new and the evidence is early: one research blog post and one package released outside the core DSPy library. Both are worth reading closely, because the limits are as instructive as the gains.

What is Weight-Space Programming?

Weight-Space Programming treats a network's weights as a program that an LLM can read and write. It was introduced in Sparks of Weight-Space Programming, published on November 2, 2026 by Rikiya Takehi, Jayden Teoh, Alex Zhang and Omar Khattab of MIT CSAIL.

The authors describe it as a concept rather than a finished method, and they present eight experiments as evidence for it.

The LLM they used, GPT-6 Astra (Astra in the post), identified which of four games (Breakout, Pong, Pac-Man, Freeway) a 17,253-weight policy network had been trained to play, from the weights alone.

It went further than reading. In one experiment it edited 3.5% of a 171,664-weight driving policy, and the car succeeded in all 1,024 episodes, where the original policy had never succeeded in 256.

What did Weight-Space Programming change in Qwen3.5-0.8B?

The headline result is Experiment 8. Astra edited 131,072 weights of Qwen3.5-0.8B, 0.016% of the model, targeting a direction in the MLPs of layers 15 and 19 that drove the model's thinking loops.

With a budget of 50 forward passes to test its edits, the share of MATH-500 answers that ran into the 32,768-token limit fell from 93.0% to 33.1%, and accuracy rose across three benchmarks.

Qwen3.5-0.8B MATH-500 GSM8K IFEval Hit token limit
Base model 7.9% 13.8% 21.0% 93.0%
Edit, 10 forward passes 12.3% 25.7% 49.0% 87.2%
Edit, 25 forward passes 14.1% 25.1% 39.9% 86.4%
Edit, 50 forward passes 48.1% 67.1% 62.3% 33.1%

Source: Takehi, Teoh, Zhang and Khattab, Experiment 8. These are the authors' own figures from a blog post, not a peer-reviewed paper.

Both models were evaluated with thinking on, and Qwen's model card notes this model is prone to thinking loops.

What does dspy-wsp do, and what does a run cost?

dspy-wsp is an MIT-licensed package that rebuilds the paper's harness as a DSPy optimizer called WeightSpace. Version 0.1.0 was published to PyPI on November 8, 2026 and version 0.2.0 on November 13. The source is on GitHub.

It works like other DSPy optimizers: you give it a metric and a program, and compile returns an improved one. A frontier "writer" model reads the student model's weights in a sandboxed Python kernel, runs your program on practice examples, and saves targeted edits.

On the package's Typed Decisions benchmark, the edits raised the test accuracy of five small decision models by 2 to 16 points on 400 held-out cases. Combined with DSPy's ReAnchor, which recalibrates answers without touching weights, the gain reached 7 to 20 points.

In the maintainers' tests, a 25-pass run on a decision model took 68 to 167 minutes and cost $5.42 to $10.78 in writer calls. The README puts the paper's 50-pass run at 158 turns and 20 hours.

Does the writer model matter in Weight-Space Programming?

Yes, a lot. The dspy-wsp README compares two writer models on the same three decision models. The stronger writer produced large gains on all three; the weaker one produced one large gain, one modest gain and one small loss.

Student model Gain, gpt-6.1-sol writer Gain, gpt-6-astra writer
d1-omni-600M +5.8 pts +16.1 pts
NanoJev +12.1 pts +13.3 pts
d1-2B βˆ’0.6 pts +13.4 pts

Source: dspy-wsp README, Results section. These are the maintainers' own figures, with standard errors of 0.7 to 1.4 points.

Can Weight-Space Programming add skills a model never learned?

No, by the authors' own account. The paper ran the same procedure on Gemma 3 270M, a model that rarely loops, and MATH-500 moved only from 6.8% to 7.7% at best. The authors say Astra could not improve it.

The dspy-wsp maintainers put the limit in one line: editing removes obstacles; it doesn't add abilities. The Qwen gain came from repairing a specific failure, the looping, not from teaching the model mathematics.

That makes Weight-Space Programming a repair tool for a model that almost works. Fine-tuning on your own data, as in Coinbase's fraud model built on an open-weight 9B base, remains the way to put new knowledge into weights.

What data leaves your network during a Weight-Space Programming run?

More than the word "sandbox" suggests. In dspy-wsp, the writer's code runs locally under bubblewrap on Linux or sandbox-exec on macOS, with no network and no access to your home folder or keys.

But the writer is a remote model, and the package's Safety section states it directly: everything the kernel prints goes to the writer's API, so the writer's provider sees the model's weights and your practice examples as the writer reads them.

For an organization whose practice examples are customer records, case files or patient notes, that is the deciding fact. The writer can be any dspy.LM, including one you host, but the table above shows a weaker writer can cost most of the gain.

The output side is cleaner. A run returns a patch of only the changed entries, with a sha256 hash of every base and edited tensor, or a full checkpoint that loads with no writer and no API key and can be served with vLLM like any other model.

Why does Weight-Space Programming favor organizations that own their model weights?

Because every step requires the weights in hand. You cannot open a closed model's tensors, run activations through it or save an edit to it. The method works only on open-weight models you have downloaded, and the result is a checkpoint you then have to host.

That is the same question this blog keeps returning to: an improvement to a model is an asset only if you hold the model. An edited checkpoint served on your own hardware is yours; a model you reach only through an API gives you no tensors to edit.

On ibl.ai you own all the code and the data. Agentic OS is model-agnostic across OpenAI, Gemini, Anthropic, Llama and local options, hot-swappable, so a checkpoint you edit and serve yourself is one more model your agents can run on.

You decide which writer sees which examples, where the edited model runs, and whether it ever leaves your network. For serving that checkpoint, our guide to self-hosted LLM serving with Ollama, vLLM and TGI covers the options.

Why does owning the AI stack matter?

ibl.ai is the agentic AI platform where you own all the code and the data. You self-host the entire stack inside your own perimeter, run it model-agnostic across any LLM and switch anytime, and pay by usage with no per-seat pricing β€” so you can deploy anywhere: your cloud, on-premise, GovCloud, or fully air-gapped.

  • You own all the code and the data

    Full source code under a perpetual license, running on your infrastructure. Not API access to someone else's platform β€” the stack itself is yours.

  • Model-agnostic

    Run any LLM β€” Claude, GPT, Gemini, Llama, Command, or your own fine-tune β€” and switch providers without rewriting the platform.

  • No per-seat pricing

    Usage-based billing against a budget cap you set. Cost tracks what your organization actually uses, not how many people you employ.

  • Deploy anywhere

    Your cloud, your VPC, on-premise, GovCloud, or a fully air-gapped network with no outbound connectivity.

1.6M+ users across 400+ organizations run the platform this way, including NVIDIA, MIT, and Syracuse University.

ibl.ai is family-owned and operated from New York, NY β€” a U.S.-headquartered, domestically-owned long-term partner, not a vendor that sells licenses and moves on.

Related Articles

Constrained Decoding Models Are Not a New Architecture

ScaleDown launched a family of task-specific models it calls Constrained Decoding Models in mid-October 2026. Constrained decoding is a well-documented decoding-time technique, not a new architecture β€” and on ScaleDown's own benchmark page, its paid extraction model leads GLiNER2.5, a free Apache-2.0 model anyone can download, by 0.2 percentage points.

Mikel AmigotOctober 16, 2026

Fine-Tunes Beat Frontier Models. Not Junior Analysts.

The claim going around financial services is that open-weight fine-tunes now do the work banks pay junior analysts for. Half of that is measured and true: Bridgewater's Qwen3-235B fine-tune hit 84.7% accuracy at 13.8x lower inference cost than frontier models. The other half is also measured, and it is false β€” on GAUGE, the benchmark graded against 1,001 real professional valuations, the best agent scored 53.4 against a junior-analyst mean of 66.0.

Jaione AmigotOctober 16, 2026

A 9B Fine-Tune Beat Opus 4.5. Who Holds the Weights?

Coinbase post-trained Alibaba's open-weight Qwen3.5-9B on its own Onramp fraud data and reported beating Claude Opus 4.5 on all four metrics of its internal benchmark, with 55% lower serving latency and under $100 of training compute β€” and the more interesting half of the story is Part 2, where every newer frontier release scored worse than its predecessor on that same benchmark.

Mikel AmigotOctober 14, 2026

When Three Labs Pace the Frontier, Your Roadmap Slows

Dario Amodei published "We Must Pace the Frontier" on September 12, 2026 and Altman and Musk agreed within a day. He asks for slack rather than a halt, arguing a focused 1-2 year effort on interpretability and evaluation could close the gap; NIST measured open weights trailing by 8 months.

Miguel AmigotSeptember 17, 2026

See the ibl.ai AI Operating System in Action

Discover how leading universities and organizations are transforming education with the ibl.ai AI Operating System. Explore real-world implementations from Harvard, MIT, Stanford, and users from 400+ institutions worldwide.

View Case Studies
Work with our team

Pilots, deployment, and full ownership

Every engagement is scoped to the work: you integrate ibl.ai with your own data, deploy it on your own infrastructure, and the engineering hours scale with the scope β€” so the price tracks the scope, not your headcount. Most customers keep us on afterwards for platform updates, new agents and integrations, and ongoing services.

Start here

Pilot

from $15K

fixed scope Β· fixed timeline

A time-boxed proof of value on your real data β€” not a slide deck.

Best for: Teams that want to see ibl.ai working before committing.

  • Deployed on your infrastructure or our cloud
  • 1–2 production agents wired to a slice of your data
  • One integration (LMS / SIS / SSO / data source)
  • Weekly working sessions with our engineers
  • Pilot fee credits toward a full engagement
Scope a pilot
Most common

Integration & Deployment

$25K – $80K

one-time fee Β· scoped to the work

Full deployment integrated with your data and systems. Engineering hours scale with scope.

Best for: Organizations rolling ibl.ai out across a department, campus, or business unit.

  • Platform deployed in your VPC, on-prem, or air-gapped
  • Integrated with your data + identity (SSO / SAML)
  • Multiple custom agents built to your workflows
  • Engineering hours proportional to scope
  • You own the data Β· run any LLM you choose
Plan a deployment
Full ownership

Codebase Transfer + Custom AI Engineering

Custom quote

perpetual license Β· you own the stack

We transfer the full source code. You own and self-host the entire platform β€” outright.

Best for: Organizations and enterprises that benefit from perpetual ownership and sovereignty.

  • Complete source-code transfer + perpetual license
  • Dedicated AI engineering team on your roadmap
  • Custom agents, models, and integrations to spec
  • Air-gapped capable Β· zero vendor lock-in
  • Family-owned, New York–based long-term partner
Talk about ownership
You own the code and data Run any LLM β€” Claude, GPT, Gemini, Llama Family-owned & operated from New York, NY