LLM Lifts Classifier F1 From 45% to 82% by Editing Weights, With No Training

Imagine a classifier that confuses cats with dogs, and there is neither data nor time for new training. Usually an ML engineer hunts for a bug in the dataset, changes the architecture or launches another training cycle. In the experiment described here, this job was handed to a large language model: it was given access to the weights of a small neural network, allowed a limited number of validation runs and asked to improve the result directly.

The outcome looks impressive: the classifier's F1 rose from 45% to 74% after the work of one LLM, and to 82% after deeper changes made by another. But the phrasing "a model reads another model's brain" is more of a hindrance here. No universal language of weights has emerged yet. The LLM relied on known architectures, familiar interpretability methods and feedback from metrics.

How it worked

The test subject was MobileNetV3-Small, which sorted images into three classes: cats, dogs and other animals. After each edit, the LLM could run inference and see whether the metric had improved. It was given ten such attempts in total.

The first strategy turned out to be fairly simple: modify the classifier's last layer, where features are turned into class probabilities. This helped, but it said almost nothing about any ability to understand the network's internal structure. When the last layer was declared off limits, the LLM went deeper: it found channels producing harmful signals and replaced their outputs with averaged values. After that, F1 reached 82%.

In everyday terms, it resembles repairing a remote with dozens of buttons. The technician doesn't have to understand every transistor. They press buttons, measure the result and gradually find the component that corrupts the signal. The difference is that an LLM can write the script for such a check itself, read the model's structure and choose the next edit.

Where the magic ends

The experiment does not prove that an LLM understands an arbitrary array of weights as a language of its own. The architectures of popular models, layer names and mechanistic interpretability methods are thoroughly described in open source code and scientific publications. All of this could have ended up in the large model's training data.

Furthermore, feedback played an important role. When an LLM is allowed to change weights repeatedly and watch the metric, the process starts to resemble trial-and-error optimization. If the validation set is small or used incorrectly, the agent can tailor its changes to it. Improvement on an independent dataset reduces this risk, but does not remove the need to reproduce the experiment.

Claims about identifying a model's purpose from its weights alone should also be read with caution. The sizes of matrices, vocabularies and inputs often give away the architecture family. And a detailed description of input and output formats in the task can effectively hint at the network's purpose.

What to take into practice

The practical value here is not in "telepathy" between models. The value is in the emergence of an agent that can automate diagnostics and targeted repair of small neural networks. Such an approach will be useful for edge models, legacy classifiers and systems where the original dataset is lost or retraining is too expensive.

Developers should treat this as an experimental tool: keep the original weights, limit the number of iterations, separate the working set from the final test and check every change for robustness. Security teams will have to treat weight files as an executable asset: an agent with the right to modify them can not only improve a model but also quietly remove restrictions or embed new behavior.

The main shift is quite real. The LLM is becoming not just a code generator but an operator of ML tools. However, a large distance still lies between such an operator and an autonomous neurosurgeon.