An MIT researcher has been using OpenAI’s GPT-5.6 Sol to autonomously run quantum computing experiments. Not just generate code or suggest approaches. Actually run the experiments, analyze the results, and adjust the hardware.

This is from OpenAI’s own case study, which details how the model handles tasks like qubit calibration. That’s work that normally requires a physicist who understands both quantum mechanics and low-level hardware control. The model is doing it without human intervention in the loop.

The implications are obvious. If AI can handle this kind of experimental iteration, the bottleneck in research shifts from “can we run enough experiments” to “do we have enough compute and lab access.” For fields where experiments are cheap to run but expensive in researcher time, that changes the math significantly.

What This Actually Looks Like

The workflow is what you’d expect from autonomous coding agents, just applied to quantum hardware instead of web apps. The model gets access to the quantum system through Codex, OpenAI’s experimental interface. It writes control sequences, executes them, reads the measurement results, and adjusts based on what it sees.

Qubit calibration is a good test case because it’s iterative and well-defined. You’re trying to find control parameters that maximize qubit coherence and gate fidelity. There are known techniques, but they require running lots of variations and analyzing the data. That’s exactly the kind of task where throwing more iterations at the problem helps.

The question is whether the model is just executing a known calibration routine or actually making decisions about which experiments to run next. Based on the case study, it seems to be doing some of both. It follows standard procedures but also adapts based on intermediate results.

The Quantization Reality Check

Speaking of models doing real work, someone actually benchmarked the Qwen3.8 27B model at different quantization levels. The results from Quesma are worth looking at if you’re trying to run large models on consumer hardware.

The short version: 4-bit quantization holds up reasonably well. 1-bit quantization collapses completely. That’s not surprising, but it’s useful to have actual numbers.

The 4-bit version maintains most of the model’s capabilities while cutting memory requirements by roughly 75%. That makes the difference between “runs on an expensive server” and “runs on a decent workstation.” For local deployment or edge cases, that matters a lot.

The 1-bit results are bad enough that you shouldn’t bother. The benchmark shows massive degradation across every task they tested. You’re not saving money if the model can’t actually do the work anymore.

When Coding Agents Bury The Lede

Here’s a different kind of practical problem: coding agents that produce too much output. Someone built a skill called “I-have-ADHD” specifically to force agents to put the answer first instead of burying it in explanatory text.

This is a real UX issue with AI coding tools. You ask a specific question, and the model gives you three paragraphs of context before getting to the actual answer. Sometimes that context is helpful. Often it’s just in the way.

The skill works by prepending instructions to your prompts that emphasize brevity and front-loading the key information. It’s a simple idea, but the fact that someone felt the need to package it as a reusable tool suggests the problem is common enough to be annoying.

It’s also a reminder that we’re still figuring out how to interact with these tools effectively. The defaults optimized for general helpfulness don’t always match what you need when you’re in the middle of debugging something.

The Pattern Here

All three of these stories point to the same shift. AI coding tools are moving from “helps you write code faster” to “autonomously handles entire classes of tasks.” The quantum computing work is the most dramatic example, but it’s the same pattern everywhere.

That creates new opportunities and new problems. The opportunity is obvious: automate tedious work, run more experiments, move faster. The problem is that we’re still learning what these tools are actually good at versus what they fail at in subtle ways.

The quantization benchmarks are useful precisely because they put numbers on the tradeoffs. You can make informed decisions about which version to deploy because someone measured the actual degradation.

The “I-have-ADHD” skill exists because the default behavior of coding agents doesn’t match how developers actually want to consume information. We need more of that kind of practical feedback loop, less hype about what’s theoretically possible.

If AI is going to run our quantum experiments, we should probably figure out how to make it answer questions clearly first.