Coding agents that discover provably safe control policies

What the work claims

This is a primary results paper in robotics and combinatorial optimization, and its claim is unusually concrete. The authors demonstrate policy search in code space, abbreviated PSCS: instead of a human designing an algorithm or a reinforcement-learning system tuning opaque weights, an autonomous coding agent iteratively proposes, implements, evaluates, diagnoses and refines actual source code, guided by simulation feedback and explicit correctness verification.¹ Two case studies are reported. In the first, on a demanding map from the 2024 League of Robot Runners competition, a two-day search produced a policy that exceeds the stronger of two locally reproduced competition entries by 35.0 percent in mean throughput on the densest instance, and the same policy generalizes to unseen map instances.¹ In the second, in a high-fidelity simulation of an operating KNAPP warehouse with irregular lanes, continuous robot geometry and asynchronous motion, a week-long search discovered what the authors call an entirely new class of algorithm that outperforms a calibrated proprietary solution by 58.9 percent in throughput on the facility where that solution was calibrated, and beats it on the other five layouts as well.¹

The boldest element is not the performance. Under stated assumptions, the authors prove the second discovered policy is collision-free and completes, in finite time, every accepted goal that is not withdrawn or replaced.¹ A machine searched the space of algorithms and returned not just a strong controller but a certificate. Weight the claim appropriately: this is a preprint, evaluated in simulation and on one competition benchmark, not on physical robots. But the workflow and its cost are documented precisely, which is more than most agentic-AI claims offer.

How it works

The problem domain is lifelong multi-agent pathfinding: hundreds of robots must continuously accept new transport tasks, assign them, and route without collisions under a strict real-time compute budget. The first case uses the League of Robot Runners 2024 benchmark, a synchronous grid environment with 100 to 800 robots, evaluated on identical hardware with a one-second execution budget per step and eight paired trials per instance.¹ The human team seeded the search with existing planner code and objectives. The coding agent then ran an engineering loop: profile the current policy against failure modes, form a hypothesis, implement the change, test it on thousands of simulated tasks, and keep or revert. The reported search converged in 42.3 wall-clock hours, consuming 3.5 million output tokens, at a compute cost of roughly 700 dollars.¹ The resulting policy, which the authors name PLATM, couples a task dispatcher that balances assignments using a rotation-aware cost metric with a motion planner that switches strategy with traffic density, coordinating one step at a time on crowded maps and using windowed group replanning on sparser ones.¹

The second case is the governance-relevant one. The agent was seeded only with a design specification: build an algorithm that, under stated assumptions, provably completes every accepted goal and never collides. Over roughly a week of search against the KNAPP warehouse simulator, it produced CGAR, an algorithm with a deliberately layered architecture. A safety layer maintains a recovery plan back to a core route network at every decision, which is what makes the formal progress guarantee possible; a throughput layer optimizes traffic flow on top without being able to void that guarantee.¹ Theorem 1 states that under the stated structural assumptions, checked at runtime, every execution is collision-free, a recovery plan exists at every decision, and every accepted, non-withdrawn goal completes in finite time.¹ Crucially, the deliverable is ordinary source code: the authors note it incurs zero neural inference latency at runtime and can be read, audited and formally verified like any symbolic program.¹

The human role deserves precision. The coding agents, which the paper identifies as Codex 5.6 Sol and subsequently Codex Astra, with auxiliary models consulted for code review and diagnostics, did the proposing, implementing and diagnosing; the human authors set objectives and constraints, steered the search, and the final results passed explicit validity checks.¹ This is not an autonomous scientist. It is a very fast junior engineer with a theorem prover for a conscience, working under a human supervisor whose steering sessions the authors describe as an important methodological variable rather than incidental scaffolding.

Where a skeptic should push

The most load-bearing assumption is that a proof about a policy, verified against a simulator, says something about the physical world. Every formal guarantee in this paper is conditional on stated assumptions and on the runtime checks being correctly implemented, and the evaluation environment is a simulation whose fidelity to real warehouses the paper does not establish.¹ The proof does not say the warehouse will work. It says the code meets its specification, where the specification was written to be provable. That distinction, between verified-against-model and verified-against-reality, is exactly the distinction that will be blurred when this paradigm is marketed to regulated domains.

Second, the baselines are more flattering than the abstract suggests on a close read. The 35.0 percent figure is measured against a locally reproduced competition entry, meaning a re-implementation by the authors, not the original winning system, and the 58.9 percent is against a proprietary system on the single facility where that system was calibrated; on the other five layouts the proprietary baseline was, in the paper's words, uncalibrated.¹ The discovered policy transfers across facilities while the proprietary one needed per-floorplan manual calibration, which is a genuinely interesting robustness property, but the headline number comes from the fairest possible comparison for the new method. Third, the authors themselves flag the agentic-scaffold risk: because the search was human-directed rather than a fixed harness, results may partly reflect the steerer's skill, and rigidly encapsulating search logic risks overfitting to the limitations of a specific model release.¹ A safety case that silently depends on which version of which vendor's model wrote the code is a new kind of version skew, and the paper's own observation that the discovered codebase accumulates tightly coupled, hard-to-audit heuristics shows the interpretability advantage is a tendency, not a guarantee.¹

Verified policy search meets living-tissue control

The opportunity for anyone running closed loops around living neural tissue is real and specific. Stimulation policies for organoid systems today are hand-tuned: a graduate student sweeps optogenetic or electrical protocols, and the argument that a given training regime is safe, or even that it does what is claimed, is an empirical shrug backed by a handful of preparations. PSCS points at a different shape: a machine searches the space of candidate policies and returns code whose load-bearing properties are provable, with the certificate as a durable artifact that can be archived, diffed, audited and attached to a dataset. The proof-carrying-controller idea is no longer a control-theory aspiration; this paper shows the discovery and certification loop working end to end on a hard coordination problem, at a cost of hundreds of dollars.¹ For a field whose central reproducibility problem is that the experimenter is part of the apparatus, a controller whose safety properties can be checked by a third party without re-running the experiment is a genuine upgrade in accountability infrastructure.

The threat is equally specific, and it starts with the transfer property the paper celebrates. CGAR is topology-agnostic: one synthesized policy transfers across six warehouse layouts while the incumbent needed manual calibration per facility.¹ In a warehouse, transfer is a feature. Across living-tissue platforms it is the failure mode to be governed against. Organoid batches differ in lineage, age, density and prior stimulation history; a policy discovered on one batch will run on another, and the formal certificate says nothing about the new tissue, because the certificate was proved against a model of the old one. The temptation will be to treat the machine-checkable artifact as if it certifies the biology, and the more impressive the certificate looks, the stronger that temptation. This is certification theater in its most credible costume: a real theorem, about the wrong system, displayed where a welfare argument belongs.

The moral-status dimension follows from what the certificate counts. A progress-and-collision proof defines which behaviors are observable and normatively loaded: goal completion and non-collision. Those are the properties a vendor can prove, so those become the properties a platform claims, and a welfare-relevant property that resists formalization, such as whether a stimulation regime drives the tissue toward pathological synchrony, simply does not appear in the artifact. The certificate quietly sets the boundary of what the governance conversation is allowed to notice. Finally, the access angle: the entire pipeline, frontier coding agents, an industrial-grade simulator, a week of search, ran inside a vendor-university consortium and depends on specific model releases.¹ Capability discovery of this kind concentrates wherever the search loop and the simulator live. If closed-loop tissue computing adopts PSCS-style policy discovery, the ownable asset is not the stimulation hardware or even the policy. It is the search environment and the validity-check suite, and whoever operates those decides what counts as a verified controller for everyone else's tissue.

The bottom line

Established, within the limits of a simulation-based preprint: coding agents can autonomously discover algorithms that beat strong expert and proprietary baselines on hard coordination problems, at trivial cost relative to human engineering, and can return the discovery as auditable source code with a formal safety and progress certificate.¹ Not established: that these policies transfer to physical systems, that the human-steered workflow is reproducible across teams and model releases, or that the proof assumptions survive contact with any real deployment. What would confirm the paradigm: an independent group reproducing the workflow on a different domain with a different model release, and a physical-robot demonstration where the proved properties hold. What would break it: evidence that results hinge on one vendor's models or on steerer skill, or that discovered policies fail the moment the simulator's fidelity gap is exposed. For living-tissue computing the verdict is asymmetric: adopt the artifact-based safety case eagerly, and treat every certificate as a claim about a model, never about the tissue, until the field builds the batch-level validation layer that would make the transfer legitimate.