AI is moving at an absolutely ridiculous pace. It seems like every week there’s another breakthrough, another model, or another research paper claiming to change everything we thought we knew about artificial intelligence. But every once in a while, something comes along that genuinely makes me stop and think. Recently, I came across a series of experiments conducted by researchers at MIT involving something called Weight-Space Programming. And honestly, this one really blew my mind. The researchers demonstrated that a powerful AI model, OpenAI’s Astra, could do something rather extraordinary. It could inspect the internal weights of other neural networks, figure out what those networks were doing, modify their weights to change their behavior, and even generate entirely new neural networks from scratch. No traditional training. No gradient descent. No millions of training examples. Just an AI model directly manipulating the numerical structures that make other AI models work. In my opinion, this could become one of the most interesting developments in AI since the emergence of agentic harnesses. But before we get into the experiments, let’s take a step back and understand why this matters. How Do We Actually Build an AI Model? Most modern AI systems, including ChatGPT and Claude, are built using a type of neural network. At a high level, you can think of a neural network as a gigantic mathematical structure containing billions or even trillions of numerical values. These numbers are called weights. They are typically represented as floating-point numbers, and collectively, they encode the patterns and information the model has learned during training. The interesting thing is that these weights are completely incomprehensible to most human beings. If you were to open up the raw weights of a modern AI model, you wouldn’t find neatly organized instructions explaining how to write Python code, solve mathematical problems, or answer questions about history. You would find enormous collections of numerical values. Yet somehow, all of the model’s learned capabilities are encoded in these numbers. Traditionally, creating an AI model involves a process called training. And when we want to improve or modify an existing model, we often use a related process called fine-tuning. Both approaches involve feeding the model enormous amounts of training data. An algorithm called gradient descent then gradually adjusts the model’s weights based on those examples. Essentially, the algorithm makes trillions upon trillions of tiny numerical adjustments, gradually shifting the model’s behavior toward the results we want. The problem? This process is incredibly computationally expensive. Training a large AI model requires massive data centers packed with specialized AI chips, consuming enormous amounts of electricity and computing resources. And this is where Weight-Space Programming proposes something radically different. What if we could skip much of that traditional training process and simply have another AI model directly manipulate the weights? Instead of relying on gradient descent to slowly adjust a neural network, we could give a powerful AI model access to the network’s internal weights and ask it to analyze, understand, and modify them directly. Sounds like science fiction. But that’s essentially what these researchers started demonstrating. Let’s look at some of the experiments. AI Can Reverse-Engineer Other AI Models One of the most fascinating capabilities demonstrated was the ability to inspect the weights of an existing neural network and figure out what that network was actually doing. To test this, researchers trained four relatively small neural networks to play four classic arcade games: * Breakout * Pong * Pac-Man * Freeways They then gave Astra the raw weights of each neural network. But here’s the interesting part. They didn’t tell Astra which games were involved. They also didn’t allow Astra to actually run the neural networks to observe their behavior. Astra could only inspect the numerical weights. And somehow, it correctly identified all four games, with confidence levels above 95%. Think about that for a moment. Imagine handing someone a massive spreadsheet containing millions of seemingly random numbers and asking them to figure out which video game those numbers were designed to play. That’s essentially what Astra accomplished. And the researchers took this experiment even further. They trained three small language models on three different types of data: * English literature * Japanese literature * Python programming code Again, Astra wasn’t allowed to prompt or run these models. It couldn’t even inspect their input and output layers. It could only examine their internal weights. And somehow, Astra correctly identified the training language of all three models. Even more impressively, it identified the induction heads inside each network. Induction heads are specialized attention mechanisms that help transformer models recognize patterns they’ve encountered previously. For example, if a model sees a particular sequence of words or symbols, induction heads can help it recognize and reproduce patterns that appeared earlier in the context. Essentially, Astra was able to reverse-engineer parts of the internal computational circuitry of these neural networks just by examining their weights. This is a pretty remarkable development. One of the biggest challenges in AI research is understanding what actually happens inside these enormous neural networks. We know how to train them, and we can observe their inputs and outputs. But understanding exactly how their internal components work is an entirely different problem. If AI models can help us interpret these internal structures, we could potentially make significant progress in understanding the black box of artificial intelligence. AI Can Perform Brain Surgery on Other AI Models Now, identifying what another neural network does is already impressive. But what if we could actually change its behavior? That’s another capability the researchers demonstrated. In one experiment, they trained a neural network to control a car driving up a ramp. Unfortunately, the AI had a problem. The car would repeatedly drive straight into the ramp and fail to climb it. The researchers gave Astra the network’s weights, a description of the environment, and a recorded example of the failure. Astra analyzed the situation and figured out what was going wrong. The car needed to reverse before accelerating so it could build up enough momentum to climb the ramp. It then directly modified the neural network’s weights. And here’s the crazy part. It only needed to modify approximately 3.5% of the weights to fix the problem. The resulting network successfully completed the task. This is essentially like performing brain surgery on another neural network. Rather than retraining the entire model from scratch, Astra identified the problematic behavior and made a targeted modification to the underlying numerical structure. But the researchers took this idea much further. Fixing the reasoning loops in an 800-million-parameter model In another experiment, researchers took an open-weight model called Qwen3.5 with approximately 800 million parameters. Their goal was to improve its mathematical reasoning capabilities. However, Astra was prohibited from using traditional training techniques such as gradient descent and backpropagation. It could inspect Qwen’s weights and prompt the model to observe its behavior. And during this process, Astra discovered something interesting. The Qwen model frequently got stuck in reasoning loops. It would repeatedly generate the same thoughts without making meaningful progress toward an answer. Think of it as an AI model getting stuck in an infinite loop. Astra identified problematic patterns in the model’s weights and directly modified them. And the number of weights it needed to change was surprisingly small. Less than 0.1% of the model’s total weights. The results were pretty remarkable. On the MATH-500 benc… Get full access to AsianDadEnergy's Newsletter at asiandadenergy.substack.com/subscribe
