Your Name

Agentic quantum many-body physics

2026-09-26T00:00:00+00:00

Our agentic AI system consists of two interacting loops: a scientist loop that decides what to investigate, and an engineer loop that keeps the experiment running.

Figure 2. The scientist loop and the engineer loop, and how they interact. The experiments the outer loop designs run on the apparatus the inner loop keeps stable.

The scientist loop

The scientist loop follows the logic of experimental research: ask a question, formulate a hypothesis, design and conduct an experiment, and use the results to decide what to investigate next.

Closing this loop requires both creativity and scientific judgment — especially the ability to identify which experiment would teach us something new. Improving its capabilities requires broad understanding and reasoning in quantum many-body physics.

While current LLMs can carry out parts of this process with appropriate context engineering, they do not yet consistently demonstrate the depth of insight that leading physicists bring to scientific discovery. We believe fine-tuning on experimental experience could help bridge this gap.

The engineer loop

The engineer loop makes such scientific exploration possible. It monitors the apparatus, diagnoses faults from their symptoms, chooses and applies a fix, and checks whether normal operation has been restored.

This requires detailed knowledge of the particular experiment — the practical experience that researchers often describe as intuition. We have already demonstrated this kind of autonomous troubleshooting on our working experiment through context engineering.

Previously: Neutral-atom arrays and AI, in both directions.

Neutral-atom arrays and AI, in both directions

2026-09-24T00:00:00+00:00

Neutral-atom tweezer arrays let us hold individual atoms with laser light, arrange them into patterns, and control how they interact (Barredo et al., 2016; Endres et al., 2016; Kaufman & Ni, 2021). This makes them powerful tools for studying quantum many-body physics: how interacting quantum particles collectively produce behavior that cannot be understood by considering each particle alone (Browaeys & Lahaye, 2020). These collective effects underlie phenomena such as magnetism and superconductivity, making their study important for understanding materials and developing future quantum technologies (Keimer & Moore, 2017). They also raise fundamental questions about how complex behavior emerges from simple physical laws — questions that can become extraordinarily difficult for conventional computers to answer (Georgescu, Ashhab & Nori, 2014).

Rydberg arrays have already realized many-body dynamics and quantum phases at the scale of hundreds of atoms (Bernien et al., 2017; Ebadi et al., 2021; Scholl et al., 2021), including signatures of topological spin liquids (Semeghini et al., 2021) and continuous symmetry breaking in the dipolar XY model (Chen et al., 2023).

Figure 1. The basic building blocks of a typical neutral Yb atom array system. Click to open at full size.

AI for science

In Figure 1, we outline the basic building blocks of a typical neutral Yb atom array system. Behind the precisely controlled atomic qubits is a complex apparatus. Lasers, electronics, and imaging systems must work together with precise timing, while experimental conditions must remain stable. Keeping this apparatus operating reliably requires sustained attention from experienced engineers and physicists, making round-the-clock operation demanding in both time and personnel.

Maintaining and running the experiment with the help of AI is therefore a natural idea, with early demonstrations already in cold-atom experiments (Wigley et al., 2016), and is itself a frontier problem at the interface of AI and physical science (Carleo et al., 2019).

The more ambitious step is from operating the experiment to doing science. An autonomous scientist would need to ask important questions, choose experiments that distinguish between possible answers, interpret the results, and revise its understanding when the evidence disagrees. Our long-term goal is to connect these abilities into a continuous loop, allowing AI to explore a quantum system at a rate never seen before in pursuit of new discoveries.

A first step toward this loop is to give the AI a learned model of the experiment itself, one that it can query millions of times while the apparatus runs only the most informative experiments. This rests on a division of labor: classical machine learning makes predictions and proposes protocols cheaply (Carrasquilla & Melko, 2017), while the quantum simulator verifies them against physical reality, including in regimes where no classical check exists. Theory supports this split, since for local observables the difficulty lies in generating the data rather than in learning from it (Huang, Kueng et al., 2022; Huang, Chen & Preskill, 2023).

The dipolar XY model shows why this matters. Its phase diagram on frustrated lattices is rich and largely beyond classical methods (Yao et al., 2018), yet experimental realizations are noisy, with finite temperature, positional disorder, and imperfect state preparation. A model trained on the device learns the physics and the noise together, which lets us separate the two (Ito et al., 2026) and design experiments that reach the phases of interest despite these imperfections.

A concrete target

Recent numerical studies predict that the dipolar XY model on a breathing kagome lattice hosts a gapped chiral spin liquid (CSL), a topological phase that has not yet been observed (Machado, Chern, Zaletel & Yao, 2026).

We use our Yb Rydberg quantum simulator, which offers tunable geometry and site-resolved addressing, to train a machine-learning model on the map from local control parameters (site-resolved fields and triangle-level breathing) to measured local observables, including scalar spin chirality on each triangle. Following Lewis et al. (2024), the model exploits geometric locality. For gapped ground states within a single phase, this makes the required number of training configurations grow only logarithmically with system size.

Where tensor-network results exist, they serve as a calibration benchmark for the full pipeline. Because the model is trained on the actual device, it also captures non-idealities such as residual temperature, positional disorder, and diabatic errors. We then use it to design preparation protocols — local-field ramps, anyon-pinning potentials, and edge geometries — that bring the experiment into the CSL regime and extend studies beyond the reach of classical simulation.

Science for AI

But the relationship can also run in the other direction: quantum many-body experiments using neutral atom arrays can help us train better AI.

AI’s progress in mathematics (Trinh et al., 2024) motivates a natural next challenge: learning science through interaction with the physical world. A practical obstacle is the time required to obtain experimental feedback. Many materials-synthesis and biological workflows involve waiting for samples to form, reactions to finish, or organisms to grow (Szymanski et al., 2023). These processes constrain how quickly an AI can test its ideas and accumulate experience.

Neutral-atom arrays offer a different experimental rhythm. Integrated hardware and electronic control allow experimental conditions to be changed through software and measurement sequences to be repeated automatically. The system has the potential of producing high-quality snapshots of quantum evolution at rates from 10 Hz (Li et al., 2026) to 1000 Hz (Zeng et al., 2026). Together with records of the controls and conditions that produced them, these measurements could provide a rich, rapidly growing resource for training scientific models.

Our aim is to use this experimental experience to fine-tune capable open-weight models and develop reinforcement-learning methods grounded in measured outcomes (Guo et al., 2025), turning experience into lasting improvements in the models themselves. Improved models would guide further experiments, whose results would support subsequent rounds of training. Recent work on verifiable LLM agents for quantum many-body simulation (Deng et al., 2026) suggests that grounding in checkable physical outcomes is key to making such models reliable.

This combination of scientific depth, programmable control, and high data throughput makes quantum many-body physics a compelling setting for training scientific AI. Beyond advancing the field itself, we want to explore whether learning how collective behavior emerges from microscopic interactions can help models develop a deeper understanding of the physical world beyond humankind. How broadly that understanding might transfer remains an open question, but the possibility of gaining new insights into complex real-world systems is a central motivation for this effort.

Next: Agentic quantum many-body physics, on the two loops that make this work.

Example: a weekly progress log

2026-09-18T00:00:00+00:00

This is a placeholder showing one format that works well for progress logs. Rewrite it with real content and delete this line. The structure below — question, attempt, result, next step — is worth keeping: it’s fast to write weekly, and it stays readable months later when you’ve forgotten the details.

The question

[What were you actually trying to find out this week? One or two sentences. Being specific here is what makes the post worth re-reading later.]

For context: [the minimum background a reader outside your group needs — what the apparatus does, what the measurement is]. The problem is that [the specific failure mode or bottleneck].

What I tried

[The approach, at the level of detail you’d tell a labmate at the whiteboard.]

The model is a [architecture] trained on [data — how much, collected how], minimising

\[\mathcal{L} = \sum_{i} \left( y_i - \hat{y}_i \right)^2 + \lambda R(\theta)\]

where [define your terms]. Training details: [optimiser, learning rate, epochs, hardware, wall-clock time].

# The bit that mattered, not the whole script.
model = build_model(n_features=X.shape[1], hidden=(64, 64))
history = model.fit(
    X_train, y_train,
    validation_data=(X_val, y_val),
    epochs=200,
    callbacks=[EarlyStopping(patience=20, restore_best_weights=True)],
)

What happened

[The result. Include the number, and include the error bar.]

Configuration	[Metric]	Note
Baseline	[value]	[what it is]
This week	[value]	[what changed]

[Then the honest part: what’s still wrong, what you don’t trust yet, which control you haven’t run. Posts that only report wins are much less useful to your future self than ones that record the doubts.]

What’s next

[Concrete next step]
[Another one]
[The control experiment you know you’re avoiding]

Open questions

[Things you’d genuinely like an answer to. If anyone ever reads this blog, this is the section that gets you an email.]

How to write a post on this site

2026-09-05T00:00:00+00:00

This post is a reference. Everything below renders on the live site, so you can compare what you see here against the source in _posts/2026-09-05-how-to-write-a-post.md. Delete it whenever you like.

Making a new post

Create a file in _posts/ named YYYY-MM-DD-some-slug.md. The date in the filename is required — Jekyll uses it to order posts and to build the URL. Start the file with a front matter block between --- lines:

---
title: "Your title here"
description: "One sentence. Shows on the blog index and in link previews."
date: 2026-09-05
tags: [calibration, ml]
math: true      # only if the post contains equations
---

Only title and date are strictly required. description is worth writing every time: it’s what people read on the index page and what appears when someone shares the link.

A post is a draft as long as its date is in the future — it won’t appear on the site until that date arrives. To keep a genuinely unfinished post out of the build, put it in a _drafts/ folder instead and preview it with bundle exec jekyll serve --drafts.

Math

Set math: true in the front matter, then write LaTeX between $$ delimiters. Keep it on one line inside a sentence and you get inline math, like $E = mc^2$ here. Put it in its own paragraph and you get a centred display equation:

\[\mathcal{L}(\theta) = \frac{1}{N} \sum_{i=1}^{N} \left\| y_i - f_\theta(x_i) \right\|^2 + \lambda \|\theta\|^2\]

Environments work too, so you can align multi-line derivations:

\[\begin{aligned} \langle \hat{H} \rangle &= \int \psi^* \hat{H} \psi \, dx \\ &= \sum_n E_n |c_n|^2 \end{aligned}\]

Note that $$ is the delimiter for both inline and display math here — unlike some LaTeX setups, a single $ does nothing. Whether you get inline or display output depends only on whether the math sits inside a paragraph or stands alone as its own block.

Rendering is done by KaTeX, which is fast but supports a smaller command set than full LaTeX — check the list of supported functions if something doesn’t render. A command KaTeX doesn’t know shows up in red rather than breaking the page.

Because nothing here treats a lone $ as math, dollar signs in prose and in code are safe: echo "$HOME" renders literally, and so does a bare $5.

Code

Fence a block with triple backticks and name the language for syntax highlighting:

import numpy as np
from scipy.optimize import curve_fit


def lorentzian(x, x0, gamma, amplitude, offset):
    """Single Lorentzian lineshape, the usual parameterisation."""
    return offset + amplitude * gamma**2 / ((x - x0) ** 2 + gamma**2)


def fit_resonance(freqs, signal, guess):
    popt, pcov = curve_fit(lorentzian, freqs, signal, p0=guess)
    # Diagonal of the covariance matrix gives the 1-sigma parameter errors.
    perr = np.sqrt(np.diag(pcov))
    return popt, perr

Inline code uses single backticks: curve_fit.

Figures

Put images in assets/img/, then use the figure include, which handles the caption and the accessibility text for you:

{% include figure.html
   src="/assets/img/loss-curve.png"
   alt="Validation loss against training step, falling steeply then flattening"
   caption="Validation loss across three seeds. Shaded band is ±1σ."
   width="wide" %}

width is optional: omit it for text-column width, "wide" to spill past the column (good for plots), "full" for edge-to-edge.

Always write the alt text. Describe what the figure shows, not that it’s an image — “validation loss falls then plateaus after 3k steps” is useful; “plot” is not. It’s what screen readers announce and what search engines index.

A plain Markdown image works too, without the caption: ![description](/assets/img/thing.png).

Tables

Numbers get tabular alignment automatically, so columns line up:

Method	RMSE (mK)	Runtime (s)
Linear baseline	12.40	0.3
Gaussian process	4.15	88.0
Small MLP	4.02	2.1

Other bits

Blockquotes are good for pulling out a result, or quoting a paper you’re arguing with.

Lists work as you’d expect:

Ordered lists for procedure.
Second step.
- Nested items are fine.

You can also drop in raw HTML anywhere, which is how the callout box on the About page is built:

Note The markdown="1" attribute is the important part — without it, kramdown leaves the contents of an HTML block alone and your Markdown won’t render.

Previewing before you publish

bundle exec jekyll serve --livereload

Then open http://localhost:4000. Pages rebuild as you save. The one exception is _config.yml — changing that needs a restart.