On July 2, a team from the University of Waterloo, Cornell, and Harvard released PAW (Program-as-Weights), a system that treats large language models as one-time compilers rather than per-query APIs. The result: task-specific logic compiles into 23MB adapter files that run entirely offline on a 600-million-parameter model, matching the accuracy of querying Qwen3-32B — a model fifty times larger.

The Economics of "Fuzzy Functions"

The researchers identified a specific class of tasks they call fuzzy functions: problems that resist clean rule-based logic but don't need multi-step reasoning on every call. Examples: flagging critical lines in application logs, repairing malformed JSON, ranking search results by user intent, routing user messages to departments.

Today these run against hosted model APIs. A function called ten thousand times a day generates ten thousand API calls—each with latency, per-token cost, and a network dependency. That cost accumulates at production scale.

PAW reframes it: use the large model once, at "compile time," to generate a function-specific adapter. Every subsequent call runs on a small, frozen local model that loads that 23MB file from disk.

The Pipeline: Two Phases

Compilation: A 4-billion-parameter "compiler" model—trained on FuzzyBench, a new 10-million-example dataset covering 800+ fuzzy task categories—converts a natural-language spec into a LoRA (Low-Rank Adaptation) adapter. The compiler generates a pseudo-program first, then a LoRA compiler emits the final adapter file. LoRA represents weight updates as compact matrices instead of modifying all parameters; in PAW's case, one 23MB file per function.

Execution: A frozen 600-million-parameter interpreter (quantized Qwen3-0.6B, ~430MB in GGUF format) loads the compiled adapter and processes every call locally. The interpreter never changes; only the 23MB per-function adapter swaps between tasks.

On the FuzzyBench benchmark, the 0.6B interpreter running PAW adapters achieved 73.78% exact match versus 68.70% for direct Qwen3-32B prompting. It also outperformed full fine-tuning of the same 0.6B base model by 15.4 percentage points and the strongest fixed LoRA baseline by 21.7 percentage points.

Hardware: The system ran at 30 tokens per second on a MacBook M3, offline, using roughly one-fiftieth the memory of running the full 32B model.

A smaller GPT-2-based variant also allows the system to run entirely client-side in a browser via WebAssembly, with no server required.

Why This Matters for Production

PAW's real significance isn't the benchmark number—it's the architectural shift. Instead of calling a hosted API on every invocation, you compile once and pay the cost of running a 600M model locally on every subsequent call. For practical purposes, that cost approaches zero compared to frontier API pricing.

Compiled artifacts are static files. Unlike a prompt sent to a hosted API—where a model update can silently change behavior—a PAW artifact produces consistent outputs across time, software versions, and hardware configurations. This is critical for reproducibility, compliance, and testing.

The system also enables deployment where cloud connectivity is unavailable: edge hardware, on-premises enterprise infrastructure, air-gapped networks, or latency-sensitive applications where network round-trips are unacceptable.

The researchers demonstrated five production use cases: event-driven log monitoring, intent-based site navigation (custom classification), semantic search reranking, a tool-calling pipeline that scored 93% on standard agentic evaluation, and a multilingual word-guessing game.

On the Qwen3-0.6B Choice

The team chose Alibaba's Qwen3-0.6B as the interpreter backbone. Alibaba is subject to China's National Intelligence Law (2017), which requires cooperation with state intelligence work. However, PAW is designed for local, offline deployment—when you download the weights and run inference locally, no data reaches Alibaba's servers. The legal obligation doesn't create a data-routing risk for self-hosted PAW as described.

Developers in government, defense, or regulated industries should still evaluate whether using a Qwen3-based backbone is appropriate, and may want to explore Western-developed model alternatives.

The Open Question

FuzzyBench—the benchmark used to validate PAW—was designed and released by the same team that built PAW. Independent evaluation on third-party benchmarks and production workloads is necessary before treating these numbers as externally validated. It remains unclear whether the approach generalizes beyond fuzzy functions or whether compiled adapters remain robust to distribution shift, adversarial inputs, or tasks requiring genuine multi-step reasoning.

How to Try It

The full code, FuzzyBench dataset, and pre-trained compiler model are publicly available on the PAW GitHub repository. The team has published an agent integration guide and a skills package for AI coding assistants. A live project site at programasweights.com features interactive browser demos of PAW artifacts running via WebAssembly.

The paper itself hit the top position on HuggingFace Papers of the Day within 24 hours and accumulated 92 GitHub stars in the hours following publication—signal that practitioners are watching this one closely.

What This Means for Your Stack

If you're running classification, parsing, routing, or JSON repair tasks against Claude or GPT APIs today, PAW offers a concrete path to eliminate those per-token costs and network latency. The tradeoff: you're constrained to tasks that fit the fuzzy-function envelope, and you're running on a 600M model instead of a frontier model—which works for narrow, well-defined tasks but won't handle open-ended reasoning or broad knowledge requirements.

For edge deployments, air-gapped environments, or production systems where API availability or cost is a constraint, this changes the economics of what you can afford to do locally.

Sources: