acceptodds
Under review as a conference paper at ICLR 2027

Agentic Contract-Based Reactive Synthesis for Multi-Agent Systems

Abstract

Large language models (LLMs) are increasingly being used for natural language (NL)-guided robot control, promising to help solve challenging design problems, such as automatically decomposing tasks and generating plans for multi-robot systems. However, existing LLM-based pipelines are mostly limited to either proposing and testing promising task decompositions, or performing verification of simple, single-agent controllers and plans. Rigorous verification layers that can ensure the correctness of multi-agent behaviors at scale in LLM-aided reactive system synthesis have been elusive. In this paper, we present an agentic compositional reactive synthesis framework for multi-agent systems. Given a system architecture and NL requirements, a Translator converts the requirements into linear temporal logic (LTL) specifications, while a Decomposer further structures them into a system-level assume-guarantee contract and a set of component-level contracts. The Decomposer is connected in a loop with a contract-based verification layer that performs a set of checks, including whether the generated contracts match the translated specification, whether the composition of component-level contracts refines the system contract, and whether each component-level contract is realizable by a reactive controller. Each failed check returns a traceable witness that localizes the responsible contracts for automatic rule-based or LLM-guided repair, until all checks pass. Our verification layer also includes the generation of runtime monitors from contracts, which can be used to further validate the synthesized controllers in their operational environment in simulation. Evaluation on three tasks motivated by multi-robot coordination problems in accessing limited resources shows the effectiveness of combining LLM guidance with hierarchical contract-based decomposition towards scalable and verified generation of multi-agent controllers from NL requirements.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
LLM agents, contract-based design, reactive controller synthesis, linear temporal logic, cyber-physical systems

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_VF8vOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2(+1)
Presentation
2
Soundness
3
Read review
Paper summary

The paper describes a framework that uses LLMs to assist in automated synthesis of control policies for multi-agent systems from user prompts translated to formal temporal logic specifications. In particular, LLMs are used to translate user intent described in natural language to temporal logic (specifically GR1 fragment). Then to handle multi-agent aspect, assume-guarantee framework is used, where contracts for individual agents are generated using LLMs. A variety of checks are implemented using symbolic tools from formal methods literature. Policies are finally synthesized for individual agents from the decomposed GR1 specifications using tools for reactive synthesis. The framework is implemented and evaluated on some simple case studies.

Critical strengths

Overall methodology is sound. Basically a neurosymbolic architecture where LLMs help in tasks that are challenging for humans (writing formal specs, decomposing spec into assume guarantee contracts) and classical symbolic tools are used to assure "correct by construction" guarantees (for instance, extracting finite-state control policy from GR1 spec for an individual agent).

Critical weaknesses

The framework puts together multiple pieces that have been studied separately and well understood. I did not find any technical novelty in the method itself. Such a paper should IMO be evaluated on the basis of how strong the experimental evaluation is. All three case studies seem relatively simple. The agents are symmetric, and the main coordination requirement is some form of mutual exclusion. This is exactly the case where I would know how to write a contract for an agent myself. The fact that it then scales in number of agents is unsurprising. What would be really cool if the authors demonstrate that the LLM is able to generate contracts for "complex" tasks where there is some subtlety in finding the right assumptions and guarantees.

Questions for authors
  1. Is there an example of an LLM generated contract that you found surprising/interesting.
  2. There are no baselines. Robot learning is developing rapidly with RL / learning from demonstrations / VLMs / VLAs ... Which of these are relevant for the high-level problem (say the Charging Problem), and how do they compare with your method (or where do they actually fail in practice)
1 comment

Thank you for the rebuttal. It does address some of the concerns raised in my review, and I am happy to raise my score to 3.

Reviewer_z8hPOpenReview ↗
Rating
2
Confidence
1
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper uses LLMs to convert natural-language requirements into formal, logic specifications and then split them into contracts in a multi-robot system. They also use various verifiers to check, detect, and fix faulty contracts. Experimental results on multi-robot system with limited resources show that the proposed method improves the success rate.

Critical strengths
  1. The pipeline handles some subtle pitfalls of GR(1) that are easy to miss, such as contract as a controller can satisfy without actually doing anything. The method is a reasonable design, where LLMs handles the hard and challenging decomposition task, while the formal checks provide the guarantees.

  2. The experimental results show these checks indeed matter. They also provide an analysis of violations, which is informative of how effective each check is.

Critical weaknesses
  1. The evaluation is a bit narrow. The environments used in the experiments are variations of the same problem, where robots take turns. Also, the paper compares only against the weaker versions of its own pipeline rather than existing LLM-based planners or LLM + verifiers methods.

  2. The guarantees are overstated. The translation from natural language to logic specifications is not verified, so the controller is only correct with respect to the LLM's translation rather than the original requirements. More experiments are required to demonstrate this. Also, the scaling to large teams seems to be a result of the hand-arranged hierarchies without the LLM rather than the proposed framework.

  3. The technical contribution is weak. The checks in the pipeline mainly come from the prior work on contracts, especially GR(1). The paper's main contribution seems to use LLM to chain these checks into a loop, which is incremental. The paper should describe their contribution more clearly.

Questions for authors

See weaknesses.

2 comments

Thank you for your response. I will maintain my score.

Thank you for reading our responses. In the rebuttal, we tried to address each of the three raised weaknesses:

  1. Evaluation scope. We added a three-arm relay task on RoCoBench and three external baselines: SMART-LLM, monolithic synthesis with Slugs/ltlsynt, and LAD-VF.
  2. Guarantees and hierarchy. We evaluated the Translator, and 385 of 396 formulas were correct. We also clarified that the hierarchy is built automatically and fixed before synthesis.
  3. Contribution. We clarified the witness-guided repair. With the same checks, it raises task completion from 43% (pass/fail feedback only) to 83%.

If there are concerns we have not yet addressed, we are glad to give further clarification or additional results before the discussion period ends.

Reviewer_h6ppOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes a framework to automatically generate and formally verify controllers for multi-agent systems (robots working together on a task) based on natural-language task requirements. The framework first uses an LLM-based Translator to convert natural-language requirements into Linear Temporal Logic (LTL) specifications using predefined atomic propositions. Another LLM-based Decomposer then generates a hierarchy of LTL-based contracts for individual components, given the specifications, system architecture, and atomic propositions. The generated contracts go through three static verification stages: Specification Grounding, Compositional Reasoning, and Controller Realization, followed by Runtime Conformance during execution. These stages use formal verification tools to check that the contracts have proper syntax, collectively satisfy the overall LTL requirements, do not contradict one another, and can be implemented by individual robots. Failed checks produce detailed feedback that guides rule-based or LLM-based repairs.

The authors evaluate their framework on three multi-robot coordination tasks involving a shared warehouse dock, a single-lane corridor, and a charging station. Across 10 runs per task, the proposed framework achieves an average task-completion rate of 83%, compared to 47% without formal verification and 43% with only pass/fail verification feedback.

Critical strengths

Effective integration of formal verification into controller generation to coordinate multi-robot. The framework checks LLM-generated contracts rather than directly trusting their correctness, and can use verification failures to guide repairs, to ensure multi-robot coordination can be completed effectively.

Promising results. The empirical results demonstrated 83% task completion v.s. 47% without their framework.

Scalability through hierarchical contract. The approach demonstrates the practical advantages of breaking large coordination problems into smaller, reusable LTL components, and show that it better with more robots involved.

Critical weaknesses

The evaluation primarily compares different configurations of the proposed framework, while Appendix C compares against several fixed coordination policies. Could the authors clarify whether existing LLM-based multi-robot planning or formal controller synthesis approaches could serve as additional baselines? If direct comparisons are not feasible because of differences in their objectives, it would be helpful to explain these distinctions more.

Limited evaluation on complex coordination tasks. The main evaluation focuses on three similar scenarios involving robots coordinating access to shared resources. Also the scalability experiments demonstrate improvements with increasing numbers of robots, and not the complexity of the tasks which can yield more states.

Unverified natural-language translation. The framework's correctness guarantees depend on the accuracy of the initial natural-language to LTL translation, which is generated by an LLM but not independently verified. Although the authors acknowledge this limitation.

Questions for authors

In the scalability experiments, the authors introduce additional levels of arbiters to support larger numbers of robots. However, the framework assumes a predefined system architecture. Can the author clarify if the number of arbiters is something that the framework can adjust as a parameter?

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.