Autonomous discovery of accelerator commissioning algorithms

The Science of Getting Things Started

Imagine a massive, ultra-precise machine built to shoot beams of light so bright they can see individual atoms. This is a particle accelerator, and specifically, a "light source" used by scientists to study the building blocks of our world. But building these machines is like assembling a giant, three-dimensional puzzle where every piece must be perfectly aligned. If even a tiny part is slightly off, the beam of particles won't stay on track, and the machine won't work.

Before scientists ever turn on the real machine, they build a "digital twin"—a perfect computer simulation. They use this simulation to practice how to turn the machine on, a process called "commissioning." It's like a flight simulator for pilots, but instead of flying a plane, they are trying to catch a beam of particles and keep it from crashing. The tricky part is that every time the design of the machine changes, the "playbook" for how to start it up becomes useless. Experts have to spend months rewriting these playbooks by hand, testing them in the computer, and hoping they work. It's slow, expensive, and limits how fast scientists can design better machines. The big question is: Can we teach a computer to write its own playbook?

The Self-Teaching Code Detective

This paper introduces a clever new way to solve that problem using an "autonomous research loop." Think of it as a digital apprentice who doesn't just follow instructions but actually learns how to write the instructions themselves. In this experiment, a computer agent (powered by advanced language models) was tasked with writing the code needed to successfully capture a beam of particles in a simulated accelerator called the ALS-U accumulator ring.

Here is how the loop works, step-by-step:

1. The Proposer: The agent looks at the current "best" code for catching the beam and suggests a change. Maybe it deletes a step that seems too slow, or adds a new trick to fix a specific error.
2. The Reviewer: A separate, strict computer program checks the agent's suggestion. It makes sure the agent isn't violating constraints (like peeking at the answer key or breaking the rules of physics). If the code is safe, it gets a pass.
3. The Tester: The code is run against a "test drive" of 50 different simulated machine scenarios, each with random glitches and errors.
4. The Decision: If the new code catches the beam faster or more reliably than the old one, it becomes the new champion. If it fails, it's tossed out.

The researchers tested this loop on a specific task: RF beam capture. This is the moment when the machine tries to grab a beam of particles and hold it steady. The goal was simple: catch the beam using as few "injections" (attempts to shoot the beam in) as possible.

What They Found

The results were surprisingly effective. The researchers started with a human-designed "expert" procedure that took an average of 207.5 injections to successfully capture the beam. After the autonomous loop ran its course, the best computer-generated algorithms reduced this number dramatically. The most capable AI models managed to get the job done in just 20.3 to 27.5 injections. That is a massive improvement, turning a slow, cautious process into a rapid, efficient one.

The paper suggests that the AI didn't invent a completely new way of physics; instead, it got very good at trimming the fat. It removed cautious, redundant steps that humans had added for safety and figured out the absolute minimum number of moves needed to succeed. One particularly clever move the AI discovered was a "recovery trick" that nudged the beam away from a crash point, saving the most difficult test cases.

The study also looked at how much help the AI needed to get started. They found that giving the AI a "helper library"—a toolbox of pre-written code snippets based on known physics—was the most important factor. With this toolbox, even the less powerful AI models could build a working procedure from scratch. Without it, the weaker models struggled to capture the beam at all, while the smarter models could still do it, but they took about ten times longer to figure it out. This suggests that while smarter AI can learn more on its own, having a good set of building blocks makes the process much faster for everyone.

Balancing Speed and Perfection

Finally, the researchers asked a more complex question: What if we want to balance speed with quality? Sometimes, you want to catch the beam fast, even if the machine isn't perfectly calibrated. Other times, you want to take your time to fix all the errors in the machine's sensors and magnets.

In a second experiment, the AI was asked to optimize for two goals at once: catch the beam quickly and fix as many machine errors as possible. Instead of finding just one "best" answer, the loop discovered 16 different algorithms that represented different trade-offs.

• One algorithm was the "speed demon," catching the beam in 679 injections but doing very little to fix machine errors.
• Another was the "perfectionist," taking 1,371 injections but fixing about two-thirds of the machine's errors and identifying broken sensors.

This is a huge shift. Instead of a human expert having to manually design and test dozens of different versions of a startup procedure, the computer can now generate a whole menu of options. Operators can then choose the one that fits their current needs—whether they need to get the machine running fast for a quick test, or take their time to ensure everything is perfectly tuned for a major experiment.

The Bottom Line

This paper demonstrates that we can move beyond just simulating human-designed procedures. We can now use simulations as a laboratory where AI agents actively discover and improve the algorithms that run our machines. While this was tested in a computer simulation, the results suggest that in the future, these autonomous loops could help scientists design better accelerators faster, reducing the time and cost required to get these massive machines up and running. The paper doesn't claim this solves everything yet, but it shows a clear path toward a future where computers help us figure out how to turn them on.