NCP: Verifier-Guided Optimization of Weight-Space Control Policies

Ekrem AksoyarXiv 2026 · arXiv

TL;DR

The Neural Control Plane (NCP) is a framework that treats Large Language Model (LLM) weights as a programmable "flow table," similar to software-defined networking. It automatically synthesizes, tests, and applies temporary weight-space interventions to improve model behavior (like reducing repetition) in a verifiable, transactional manner without permanently altering the base model.

What Problem Does This Paper Address?

Current methods for adapting LLMs—like prompting or fine-tuning—often fall into two extremes: they are either too superficial to fix deep behavioral issues or too permanent and expensive to iterate on quickly. Furthermore, the dream of "Recursive Self-Improvement" (RSI) requires a structured way for a model to observe its own failures and safely modify its own "code" (its weights).

NCP addresses the need for a Control Plane for LLMs. It separates the "Data Plane" (standard inference) from a "Control Policy" that decides which temporary weight patches to apply based on the current input's neural activations. This allows for fine-grained, inference-time adaptation that is both inspectable and reversible.

Methods

The authors draw a direct analogy to OpenFlow in networking. The system consists of several key components:

  • Neural Flow Table: A versioned database of "rules." Each rule consists of an activation-based trigger (a "predicate") and a specific weight modification (an "action").
  • W-ISA (Weight-Space Instruction Set Architecture): A companion execution layer that handles "transactional" weight edits. It applies a change, runs inference, and then restores the original weights, ensuring no permanent "weight drift."
  • Candidate Synthesis: When the model fails a task, NCP extracts an "activation profile" (the difference between failure and success states) to create new intervention candidates.
  • The Verifier: A gatekeeper that evaluates candidates against validation tasks and a general language-modeling corpus (to ensure the "patch" doesn't break the model's general intelligence).

The synthesizer uses specific templates for these interventions, as shown in the table below:

The three primary types of weight-space interventions synthesized by NCP.

Datasets

The paper uses a microbenchmark approach to validate the architecture:

  • Base Model: SmolLM-135M-Instruct, a tiny but capable model used for rapid iteration.
  • Reasoning Fixture: A handwritten set of 9 questions (split into development, validation, and test) covering arithmetic, sequence continuation, and object counting.
  • WikiText-2: A standard language modeling dataset used to calculate perplexity (PPL) and ensure interventions don't degrade general performance.

Key Insights and Ideas

  • Weight-Space Programming: The authors argue that weights should be viewed as an interface that can be read from and written to programmatically, rather than just a static pile of numbers.
  • Activation-Conditioned Rules: By triggering interventions only when specific neural patterns are detected, NCP can apply "surgical" fixes that only activate when the model is likely to fail.
  • Separation of Concerns: By decoupling the synthesis of a fix from its admission (verification), the system prevents "hallucinated" improvements from entering the active policy.
  • Transactional Integrity: The use of W-ISA to restore weights after every request is crucial for stability, preventing the "catastrophic forgetting" often seen in continuous fine-tuning.

Key Results

In the SmolLM experiment, the system synthesized three candidates to address failures in the reasoning tasks. While none of the candidates met the strict "must improve accuracy" gate for admission to the active policy, the experiment demonstrated the system's ability to precisely measure and archive behavioral changes.

Specifically, one MLP projection candidate significantly reduced token repetition without hurting general model performance:

Experimental results showing how different candidates affected repetition and perplexity. Note that despite reducing repetition, they were archived because they didn't improve exact-answer accuracy.

As seen in Figure 2, the MLP projection reduced the validation repetition fraction from 0.4133 to 0.2191 while actually slightly improving perplexity (-0.057%).

Limitations and Future Work

  • Scale: The current study is a "microbenchmark" on a 135M parameter model. Scaling this to 7B+ parameter models will test the overhead of the W-ISA execution layer.
  • Deterministic Synthesis: Currently, the rules are synthesized via a deterministic Python procedure. The authors suggest that future versions could use the LLM itself to "write" more complex weight-space programs.
  • Task Complexity: The reasoning tasks used were very simple. Testing NCP on complex, multi-step reasoning chains is a necessary next step for proving its utility in RSI.
  • Admission Logic: The current gate is very conservative (requiring zero regressions in accuracy). Developing more nuanced, probabilistic admission criteria could allow for faster policy evolution.

Summary updated

Abstract

We present the Neural Control Plane (NCP), a closed-loop system that observes language-model execution, synthesizes candidate weight-space intervention rules, evaluates them, and maintains a versioned table of admitted policies. NCP separates a pretrained model's inference data plane from the control policy that selects temporary parameter interventions. W-ISA supplies transactional execution and parameter restoration; NCP supplies telemetry, candidate synthesis, admission criteria, priorities, and rule lifetime management. The optimization state consists of active rules and an archive of evaluated candidates, while base-model parameters are restored after each request. In a local SmolLM-135M-Instruct experiment, NCP generated three candidates from development telemetry and evaluated them on separate task examples and a 4,095-target WikiText-2 slice. One projection reduced validation token repetition from 0.4133 to 0.2191, with a perplexity change of -0.0574%. All candidates produced zero newly correct exact answers, so the configured admission gate archived all three and retained the original active policy. Fresh-process repetition and saved-table resumption reproduced the measured outcomes. NCP provides an executable framework for studying recursive self-improvement at the control-policy level through explicit synthesis, verification, and state transitions.
BibTeX
@misc{aksoy2026ncp,
  author = {Ekrem Aksoy},
  title = {{NCP: Verifier-Guided Optimization of Weight-Space Control Policies}},
  year = {2026},
  eprint = {2611.13236},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.13236},
}
Figure