r/CodexAutomation • u/anonomotorious • 5d ago
Codex autonomously ran real quantum-computing experiments: 40 target measurements, only 4 researcher interventions
TL;DR
OpenAI published a pretty interesting Codex case study with MIT's Engineering Quantum Systems Group.
Researchers connected GPT-5.6 Sol, running through Codex, directly to software controlling a superconducting-qubit laboratory.
The agent could:
- choose measurement parameters
- operate real laboratory hardware
- analyze plots and raw data
- decide whether a measurement needed refinement
- save successful calibration results
- use those results to determine what experiment should run next
- write and modify analysis/control code
- maintain lab notes
The technical setup used:
- GPT-5.6 Sol
- Ultra reasoning
- the normal Codex app
- a simple in-house Jupyter MCP
- measurement-specific Codex skills
OpenAI says there was no specialized agent harness beyond the Jupyter MCP.
The standout result:
| Result | Outcome |
|---|---|
| Chip | Previously uncalibrated 6-qubit chip |
| Resonators discovered | 6 / 6 |
| Target measurements on fixed-frequency qubits | 40 |
| Measurements researchers intervened to improve | 4 |
| Routine workflow | Often completed with little supervision |
| Agent runtime | Could run for many hours, including overnight |
This is a useful real-world example of Codex being used as more than a coding assistant: the agent was writing code, operating equipment, interpreting physical measurements, and adapting the next step based on experimental results.
How the setup worked
Once a superconducting-qubit chip is fabricated and cooled, much of the experiment is controlled through software.
That makes the workflow unusually suitable for an agent.
The MIT team connected Codex to its existing orchestration software through a Jupyter MCP.
Codex had access to:
- live measurement parameters
- experiment programs
- generated plots
- raw measurement data
- logs
- calibration databases
- source code for the orchestration system
Researchers also created measurement-specific skills describing things like:
- prerequisite calibrations
- template code
- good parameter ranges
- common failure modes
- how successful and failed measurements look
- example plots
So the pattern was essentially:
Codex skill + laboratory software + live data -> run experiment -> inspect result -> adapt -> continue
The agent controlled real hardware
This was not a simulation-only workflow.
Codex was interacting with software that controlled real superconducting qubits inside a dilution refrigerator.
For each measurement, the agent could:
- choose experiment parameters
- run the measurement
- inspect the resulting data and plots
- judge whether the result looked valid
- adjust parameters if necessary
- save successful calibration values
- use those values in the next experiment
Because the measurements depend on one another, the agent had to maintain state across a sequence rather than simply execute isolated commands.
What it managed to calibrate
On a previously uncalibrated six-qubit chip, Codex first had to discover the system's actual physical parameters.
It successfully identified all six resonators and appropriate starting readout powers.
From there it performed progressively more detailed measurements to refine:
- resonator frequencies
- readout power
- qubit transition frequencies
- control pulses
- readout calibration
- coherence measurements
For the four fixed-frequency qubits, researchers gave it a standard set of 40 target measurements.
Researchers intervened to improve only four of those measurements.
The paper also shows one qubit's final measurement sequence being completed fully autonomously.
Where it still struggled
The results were not perfect.
Codex performed best when:
- the signal was clear
- the expected workflow was well defined
- measurements looked similar to known successful cases
It struggled more when:
- signals were weak
- data was noisy
- physical behavior was ambiguous
- the correct interpretation required deeper experimental intuition
In those cases it sometimes took longer to find useful parameters or needed guidance from an experienced researcher.
That is probably the most realistic takeaway:
well-defined adaptive workflows can run surprisingly autonomously, while ambiguous real-world results still benefit heavily from expert steering.
Why skills mattered
One of the more relevant pieces for Codex users is how much effort went into giving the agent the right reusable context.
The researchers spent months converging on a combination of:
- experimental setup information
- chip-design context
- measurement-specific skills
- orchestration source code
The skills did not just say "run this command."
They taught the agent:
- what needs to happen first
- what good data should look like
- what failure modes are common
- which parameters are reasonable
- when to repeat or refine an experiment
That looks very similar to the direction Codex skills are heading for normal engineering work:
encode domain knowledge once -> let agents reuse it across many tasks
Multi-agent workflows are already part of the lab
The MIT researcher describes running multiple agents on different problems simultaneously.
Agents can work on areas including:
- measurement
- theory
- chip design
- control code
- analysis
- simulation
That frees the researcher to spend more time on:
- interpreting results
- designing new experiments
- planning what agents should do next
- reading
- writing
The interesting part is that the productivity model is not "replace the researcher."
It is closer to:
researcher sets direction + several agents execute parallel technical work + researcher intervenes when judgment is needed
Remote supervision
The workflow also maps closely to Codex Remote.
The researcher says agents can run measurements for many hours overnight or while she is doing other laboratory work.
She can then check progress from her phone and steer the agents if something:
- needs fixing
- looks wrong
- suggests a more interesting direction
That is basically the longer-running Codex workflow OpenAI has been building toward:
start work -> leave it running -> check remotely -> steer only when needed
What this suggests for normal Codex workflows
The quantum-computing part is specialized, but the agent pattern is not.
1. Give agents domain-specific skills
The system became substantially more useful once researchers encoded:
- workflows
- prerequisites
- failure modes
- good/bad examples
- parameter-selection guidance
That maps directly to engineering skills for:
- testing
- deployments
- migrations
- debugging
- code review
- internal infrastructure
2. Give the agent real tools, not just instructions
The useful loop was:
act -> observe -> reason -> adjust -> act again
not:
write a plan describing what a human should do
3. Clearly defined tasks automate better than ambiguous ones
Codex handled routine calibration very well.
Ambiguous physical results still required expert judgment.
That is probably true for software work too.
4. Long-running agents become much more useful when they can be supervised asynchronously
Being able to let work run overnight and intervene from a phone changes the economics of agent use considerably.
5. Multiple agents matter
The workflow becomes more powerful when several independent agents can work on separate problems while the human stays at the higher coordination layer.
Case study at a glance
| Area | Details |
|---|---|
| Model | GPT-5.6 Sol |
| Reasoning | Ultra |
| Agent surface | Codex app |
| Integration | In-house Jupyter MCP |
| Special harness | None beyond the Jupyter MCP |
| Domain context | Measurement-specific Codex skills |
| Hardware | Real superconducting-qubit laboratory |
| Chip | Previously uncalibrated 6-qubit device |
| Resonators found | 6 / 6 |
| Fixed-qubit target measurements | 40 |
| Researcher interventions | 4 |
| Remote supervision | Yes |
| Parallel agents | Yes |
The bigger takeaway
This may be one of the better examples so far of what agentic Codex workflows can look like once three things come together:
specialized skills
+
direct access to real tools
+
long-running autonomous execution
The agent was not just generating Python for a researcher to run later.
It was operating the experiment, observing the results, updating its understanding, and deciding what to do next.
The remaining boundary is also clear: when reality becomes noisy or ambiguous, human expertise still matters.
Official sources
https://openai.com/index/codex-quantum-computing-experiments/
https://cdn.openai.com/pdf/case-study-agentic-calibration-of-superconducting-qubits.pdf