🔢 mathematics

OptiLoop: Coordination-in-the-Loop Verification and Repair for LLM-Generated Optimization Agents

The paper introduces OptiLoop, a coordination-in-the-loop verification and repair pipeline that uses ADMM-style consensus runs to detect and fix semantic errors in LLM-generated optimization agents, significantly improving their alignment with global objectives and social outcomes compared to isolated local validation.

Original authors: Yujia Xu, Zhiheng Wang, Thi Dinh

Published 2026-05-28

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Yujia Xu, Zhiheng Wang, Thi Dinh

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are the manager of a massive, decentralized supply chain. You have dozens of independent vendors, each with their own private factories, costs, and rules. They don't want to share their secret recipes or financial data with you. However, they all need to agree on a shared plan (like how many items to ship) to keep the whole system running smoothly.

Traditionally, getting these vendors to agree requires a human expert to write complex computer code for each one, translating their business rules into mathematical formulas. This is slow, expensive, and prone to human error.

The New Idea: Let AI Do the Coding
The paper proposes using Large Language Models (LLMs)—the same kind of AI that writes essays or chat—to automatically write the code for these vendors. You simply tell the AI, "Here is my warehouse rule: I can only ship 100 boxes a day," and the AI writes the optimization program.

The Problem: The "Silent" Bug
Here is the catch: Just because the AI writes code that runs without crashing doesn't mean it's right.

Think of it like hiring a chef to cook a meal based on a verbal recipe.

Local Check: You ask the chef to taste the soup. They say, "It tastes fine!" and the pot doesn't explode. The code "compiles" and runs.
The Real Test: You serve the soup to a customer who has a specific dietary restriction. The chef, following a subtle misunderstanding of the recipe, adds a hidden ingredient that makes the customer sick. The soup was "executable," but it was semantically wrong.

In the paper's world, an AI-generated agent might run perfectly on its own but misunderstand a cost or a constraint. It might think "shipping costs" are a fixed fee rather than a fee per item. When it tries to coordinate with the central system, it makes bad decisions that look logical to itself but ruin the overall plan. These errors are invisible until the agents start talking to each other.

The Solution: OptiLoop (The "Rehearsal" System)
The authors created a system called OptiLoop to fix this. Instead of just checking if the code runs, they put the AI agent through a "rehearsal" before it goes live.

Here is how OptiLoop works, using a simple analogy:

The Script (Generation): The AI writes the code based on your text instructions.
The Dress Rehearsal (In-Loop Verification): Before the agent joins the real supply chain, it is paired with a "trusted partner" (a fixed, perfect computer program) for a short, simulated coordination game. They try to agree on a plan.
The Critique (Evidence Extraction): During this rehearsal, the system watches how the AI agent reacts.
- Does it get angry when the price goes up? (It should get cheaper to produce more).
- Does it agree to the plan, or does it keep shouting "No!"?
- Is it behaving like a rational business, or is it acting weird?
- The system looks for "behavioral red flags" that static code checks miss.
The Fix (Repair):
- Minor Glitch: If the code just has a typo or a missing number, the system patches it quickly (like a spell-check).
- Major Misunderstanding: If the AI fundamentally misunderstood the business logic (e.g., it thinks shipping is free), the system throws out the current logic and asks the AI to rewrite the entire mathematical "recipe" from scratch, using the feedback from the rehearsal to guide it.
The Memory (Learning): The system keeps a "notebook" of past mistakes. If it sees a similar confusing instruction again, it remembers, "Oh, last time the AI got confused by 'shared capacity,' so I'll warn it this time too."

The Results
The researchers tested this on 40 different complex supply chain scenarios.

Without OptiLoop: The AI agents got the right answer about 66% of the time.
With OptiLoop: The success rate jumped to 93%.

More importantly, when the AI did make a mistake, the "gap" between the bad plan and the perfect plan shrank dramatically. The system didn't just fix the code; it fixed the logic behind the code.

The Bottom Line
The paper argues that for AI agents making decisions in a team, you cannot just check if they can "run." You must watch how they behave when they are actually working with others. OptiLoop is a system that forces the AI to "rehearse" its role, catches the subtle misunderstandings that happen during that rehearsal, and fixes them before the real work begins.

Technical Summary: OptiLoop

Problem Statement

Decentralized decision-making problems, such as supply planning and resource allocation, require multiple parties to coordinate on shared decisions while maintaining privacy over their local objectives, constraints, and data. While Large Language Models (LLMs) offer a promising avenue for lowering the barrier to entry by generating local optimization agents from natural-language specifications, a critical gap exists in the verification of these agents.

Current approaches rely heavily on isolated execution (local validation) to verify generated code. However, in coordination settings, executability is insufficient. An LLM-generated agent may compile, solve, and pass local feasibility checks while being semantically wrong. Such errors include misrepresenting cost terms, mis-scoping constraints, or responding incorrectly to economic incentives. These semantic failures often remain invisible during isolated execution because the agent produces feasible, well-formed outputs. Instead, they manifest only during the coordination process as systematic behavioral failures, such as wrong-sign price responses, degenerate proposals, or unstable convergence.

Methodology: OptiLoop

The paper proposes OptiLoop, a pipeline for coordination-in-the-loop verification and repair. The core principle is to validate a candidate agent using the structured feedback signals produced by the coordination protocol itself, treating coordination trajectories as semantics-aware verification evidence.

The methodology is instantiated using an Alternating Direction Method of Multipliers (ADMM)-style consensus protocol. The pipeline operates through four stages:

Formulation and Code Generation: The system generates a structured mathematical formulation and executable solver code from a natural-language specification, augmented by a curated library of operations-research building blocks.
Lightweight Local Validation: The generated code undergoes syntax checks and local solve validation to catch basic execution or interface errors.
In-Loop Verification: The agent runs a short, bounded coordination episode against a fixed, trusted counterparty. This run extracts a coordination trajectory ( $\tau$ ) containing proposals, consensus variables, dual signals, penalties, residuals, and objective decompositions.
Evidence-Driven Diagnosis and Repair: The system combines behavioral checks (analyzing the trajectory for incentive response, degeneracy, and convergence) with static checks (analyzing code for anti-patterns like costs applied to fixed data). Based on this evidence report ( $E$ $E$ ), the system selects one of three actions:
- ACCEPT: The agent behaves coherently.
- CODEFIX: A localized implementation error (e.g., shape mismatch) is patched.
- REFORMULATE: A structural modeling error is identified, triggering a corrected-formulation repair where the mathematical model is revised and code is regenerated.

Additionally, OptiLoop incorporates episodic experience reuse, retrieving lessons from prior training instances to prevent recurring error patterns during generation.

Key Contributions

Coordination-in-the-Loop Verification: The paper formalizes a new validation principle for LLM-generated local optimization agents, shifting the focus from isolated execution checks to deployment-time feedback signals within the coordination loop.
The OptiLoop Pipeline: It operationalizes this principle via an ADMM-based consensus protocol, introducing a mechanism for diagnostic coordination episodes, structured evidence extraction, and an escalation strategy from localized code fixes to corrected-formulation repairs.
Empirical Validation: The authors provide a benchmark and ablation study demonstrating that coordination-in-the-loop verification exposes semantic failures missed by local validation and significantly improves correctness on held-out decentralized scenarios.

Results

The system was evaluated on 40 held-out test scenarios (out of a 80-scenario benchmark) involving supply-chain primitives with varying cost structures and constraints. The results compare four configurations:

Baseline-Gen: Generation only.
Baseline-LocalVal: Generation + local validation.
OptiLoop-Core: Baseline-LocalVal + coordination-in-the-loop verification and repair.
OptiLoop-Full: OptiLoop-Core + episodic experience reuse.

Key Metrics:

Objective Match: The percentage of scenarios where the generated agent reproduces the intended private objective behavior (within 0.1% tolerance).
Social Match: The percentage of scenarios where the final coordinated solution is within 0.1% of the centralized optimum.
Objective/Social Gap: The mean relative error of imperfect solutions.

Performance:

OptiLoop-Full improved Objective Match from 66.0% (Baseline-LocalVal) to 93.0%.
Social Match improved from 68.5% to 89.0%.
The Mean Objective Gap was reduced from 15.3% to 3.5%.
The Mean Social Gap was reduced from 7.6% to 2.0%.

Ablation studies revealed that while local validation catches basic execution errors, coordination-in-the-loop verification is necessary to detect semantic errors where the model solves successfully but encodes the wrong economics. Furthermore, static and behavioral evidence were found to be complementary; static checks caught missing cost parameters, while behavioral checks detected wrong-sign marginal responses. Episodic memory further reduced repair iterations and runtime by preventing recurring mistakes.

Significance and Limitations

The paper argues that for generated optimization agents deployed in decentralized decision loops, correctness must be validated in the loop itself rather than through isolated execution alone. The findings suggest that semantic failures often remain hidden until the agent interacts with coordination incentives.

The authors acknowledge several limitations:

Scope: The evaluation is matched to a specific onboarding setting (fixed coordinator and counterparty); transfer across different coordination stacks remains open.
Benchmark: The results are based on a bounded synthetic scenario suite; broader coverage and public benchmarks are needed to establish generalizability.
Efficiency: While episodic memory improves efficiency, the full pipeline is more expensive than simple generation or local validation, making it better suited for offline onboarding and pre-deployment verification rather than latency-sensitive settings.
Residual Failures: Approximately 7% of scenarios still fail, primarily due to novel cost structures (e.g., piecewise costs), ambiguous natural-language specifications, or complex constraint compositions that require clarification beyond the current verification scope.