CANDO: Cooperative Agentic Network for Layout Design Optimization
summary
The gist
Layout generation for real-world facilities is a complex problem involving reasoning over irregular site boundaries, heterogeneous orientations, access-aware placements…
In short
CANDO is a training-free multi-agent framework designed to generate optimal real-world facility layouts. It uses four specialized agents—Initializer, Verifier, Historian, and Planner—to iteratively refine a design configuration. The system maximizes a score based on meeting hard constraints (like non-overlap) and soft constraints (like compositionality), outperforming existing baselines.
Key concepts
- ALPS-Bench
- A new benchmark featuring 1,000 professionally annotated real-world facility layouts. It is designed to test layout generation on complex sites with irregular boundaries, heterogeneous orientations, and access requirements. It uses a structured design manual for scoring.
- CANDO Agents
- Four specialized agents work together: the Initializer creates a starting layout, the Verifier checks it against rules, the Historian tracks design changes over time, and the Planner drafts fixes. They cooperate to find an optimal configuration that balances various design goals.
- Hard Constraints (HC)
- These are non-negotiable rules for a layout, such as ensuring facilities do not overlap or stay within site boundaries. CANDO prioritizes meeting these constraints absolutely before optimizing other softer properties like proximity or orientation.
- Two-Phase Refinement Loop
- The process starts by generating a seed layout (Phase 1) using an LLM and geometric checks. Then, the four agents enter a loop where the Verifier selects the best candidate, the Historian provides context, and the Planner generates remediation plans to improve that candidate iteratively.
Terminology used across episodes
This episode discusses
- CANDO: Cooperative Agentic Network for Layout Design Optimization · Paper Radio
- ResPlan: A Large-Scale Vector-Graph Dataset of 17,000 Residential Floor Plans
- Theoretical guarantees on the best-of-n alignment policy
- AutoLayout: Closed-Loop Layout Synthesis via Slow-Fast Collaborative Reasoning
- DisCo-Layout: Disentangling and Coordinating Semantic and Physical Refinement in a Multi-Agent Framework for 3D Indoor Layout Synthesis
- LoRA: Low-Rank Adaptation of Large Language Models
- Mixtral of Experts
- LayoutGAN: Generating Graphic Layouts with Wireframe Discriminators
- MemGPT: Towards LLMs as Operating Systems
- LayoutCoT: Unleashing the Deep Reasoning Potential of Large Language Models for Layout Generation
- CoDe: Blockwise Control for Denoising Diffusion Models
- LayoutNUWA: Revealing the Hidden Layout Expertise of Large Language Models
- A-MEM: Agentic Memory for LLM Agents
- Evaluating Spatial Understanding of Large Language Models
- Qwen3 Technical Report
- ReAct: Synergizing Reasoning and Acting in Language Models
The paper
CANDO: Cooperative Agentic Network for Layout Design Optimization · Read on arXiv
Shell Information Technology International · Delft University of Technology
Layout generation for real-world facilities is a challenging problem, requiring reasoning over irregular site boundaries, heterogeneous orientations, access-aware placements, and motion-planning feasibility. Yet, most existing layout benchmarks in the generative AI space target simpler placements over rectangular domains and rely on distributional metrics such as FID and IoU that reward conformity to dataset priors, thus discounting design innovation. Motivated by these gaps, we introduce ALPS-Bench, a benchmark of 1,000 professionally annotated real-world facility layouts paired with an instance-specific scoring protocol grounded in a structured design manual. As a strong baseline for ALPS-Bench, we propose CANDO, a training-free multi-agent framework in which specialized agents iteratively refine layouts through a verification-grounded loop, concentrating reasoning on strategic spatial decisions. We demonstrate that CANDO surpasses state-of-the-art trained and LLM-based baselines on the widely adopted PubLayNet, RICO, and PKU-PosterLayout benchmarks, establishing cooperative agentic design as a broadly effective recipe for constraint-aware layout synthesis. Code and benchmark are available through our project page: https://shell-oss.github.io/cando/
Transcript
Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.
Tom: We're looking at the paper: "CANDO: Cooperative Agentic Network for Layout Design Optimization".
Jane: Here's the gist of the paper. Layout generation for real-world facilities is a complex problem involving reasoning over irregular site boundaries, heterogeneous orientations, access-aware placements, and motion-planning feasibility.
Tom: Existing benchmarks often focus on simpler placements over rectangular domains and utilize distributional metrics like FID and IoU, which reward conformity to dataset priors rather than design innovation.
Jane: To address these limitations, the authors introduce ALPS-Bench, a benchmark featuring 1,000 professionally annotated real-world facility layouts paired with an instance-specific scoring protocol grounded in a structured design manual.
Tom: As a strong baseline for ALPS-Bench, they propose CANDO, a training-free multi-agent framework.
Paper summary: Tom: So we’re looking at this paper called CANDO: Cooperative Agentic Network for Layout Design Optimization. It tackles the really hard problem of designing layouts for real-world facilities, which involves dealing with irregular site boundaries and different object orientations, plus making sure there's a way to get in and out of the place and move around.
Jane: Right, so most existing layout benchmarks focus on simpler rectangular areas and use metrics like FID or IoU that just reward fitting things into what the dataset already looks like, instead of actually trying new design ideas.
Lu: That’s exactly the gap they’re targeting. They introduce ALPS-Bench, which is a benchmark with one thousand professionally annotated real-world facility layouts and a set of rules based on a structured design manual to score them.
Meng: So, CANDO is their answer to that, right? It’s presented as this training-free multi-agent framework where different specialized agents work together to refine the layout configuration.
Lalam: Exactly. It sets up four specific agents: an Initializer, a Verifier, a Historian, and a Planner. The goal is to find the best configuration by maximizing some total weighted score based on both hard constraints and softer properties like how well it fits the design manual.
Tom: The way they define that aggregate score is interesting; it splits the total into two parts: one part checks if you met all those hard constraints, and another part looks at things like compositionality and orientation.
Jane: And they use a specific protocol for scoring compliance, where if you meet the hard constraints, there’s this weighted measure of how well those physical requirements are satisfied. It sounds like they are making sure the layout is actually physically possible before worrying about aesthetics.
Lu: The refinement loop is split into two phases: first, the Initializer uses a large language model to get a starting configuration based on similar layouts from development data, and then the four agents iteratively refine that seed.
Meng: I'm curious about how they handle the iteration part. Does it just keep tweaking things randomly, or does it have a systematic way of improving the design over time?
Lu: They are inspired by some blockwise sampling schemes from another system, and they use a deterministic tool for verification during the refinement process to select the best candidate at each step.
Jane: That’s important because it means they aren't just guessing; they are using these tools to check if a proposed placement actually makes sense according to the design manual.
Tom: Then you have this Historian agent keeping track of how the design has evolved, which feeds into the Planner, giving it context on what has been tried before.
Meng: And then there's the Planner drafting remediation plans based on all that history and feedback, using specialized sub-planners for things like hard constraints or flow. That sounds like a lot of coordination to manage.
Paper summary: Lalam: The final part is where the Generator takes those plans and translates them into actual revised candidate configurations by applying specific actions, like moving or rotating elements.
Tom: And they have this Supervisor Planner that looks at everything holistically and prioritizes actions based on category weights, making sure hard constraints always come first, even if the worker planners suggest something else.
Jane: So it’s a very structured way of letting the agents collaborate to solve this complex spatial optimization problem. It sounds like they are trying to build a system that doesn't just generate an image, but generates a feasible plan.
Lu: They deliberately offload the low-level geometric calculations to deterministic tools, which keeps the core AI reasoning focused on the strategic decisions about placement and orientation rather than doing all that hard math themselves.
Meng: That’s smart for deployment because running complex spatial reasoning models on real traffic at scale would be tough; separating the computation helps. But I wonder how much work goes into training those specialized worker planners?
Lalam: They use a Qwen model as the backbone, and the results show that even this simplified version achieves state-of-the-art mIoU and alignment on other benchmarks like PubLayNet and RICO.
Tom: That’s a strong result, especially because they achieved those high scores with what is essentially a training-free approach for the agentic framework itself. It suggests that the cooperative agentic design method is effective for this kind of constraint-aware synthesis.
Jane: What does this actually mean for someone who just listens to the show? It means that instead of a computer just guessing where things go, we're seeing a system that follows a set of explicit rules—like "this door must be reachable from the entrance"—and it systematically fixes those rules.
Lu: The implication is that this approach of structured cooperation among agents, combined with tool-grounded verification, is a solid recipe for layout synthesis problems where feasibility and adherence to complex manuals are key.
Meng: But I still have to ask about the scale; how reliable is this when you introduce novel constraints that weren't in the original design manual? Does it just break down?
Lalam: The authors state their limitations, saying that while they show strong performance on PubLayNet and RICO, they haven't fully tested its robustness against entirely new or unseen complex constraints outside of the structured manual.
Tom: So it’s a powerful tool for the problems it's designed for—real-world facilities with known constraints—but we need to be careful when applying it to completely unpredictable situations.
Jane: It’s a really cool way to think about AI design, moving away from just asking the model to "draw me a layout" toward building a system that can actually reason through the physics and access rules of the space.
Conclusion: Tom: So we're wrapping up CANDO, which stands for Cooperative Agentic Network for Layout Design Optimization.
Jane: It’s basically a system where different AI agents work together to figure out how to put things in a real space correctly, using a lot of rules from a design manual.
Tom: Yeah, the authors are showing that this framework can find layouts that actually fit those hard physical constraints, which is harder than just drawing something pretty.
Jane: What this means for us is that instead of just asking an AI to make a picture look good, we can build systems that respect real-world physics and access requirements.
Tom: Exactly. It's about moving from generating a design idea to generating a feasible plan that actually works in the real world.
Jane: And they are using this specific multi-agent setup with verification tools to make sure the plans they generate don't just look right, but are actually buildable or usable.
Tom: The results show it beats other methods on benchmarks like ALPS-Bench and even PubLayNet and RICO, which is a strong signal that the cooperation between agents is effective.
Jane: It’s not about one single smart model doing everything; it’s about specialized agents handling different parts of the problem, like one agent checking physical overlap while another looks at orientation.
Tom: The core idea they are pushing here is that breaking down a massive spatial problem into smaller, constrained tasks and letting agents collaborate on those tasks works really well.
Jane: But even with these good results, they admit that the system's performance depends heavily on how detailed the design manual is to begin with.
Tom: That’s a fair caveat. It suggests that while it’s great for structured environments like real facilities, if you throw totally novel shapes at it without clear rules, the whole system might struggle to find a solution.
Jane: So CANDO is really pointing toward a future where AI design isn't just about creative output, but about rigorous spatial reasoning and constraint satisfaction.
Tom: And that leaves us wondering how this kind of structured agent cooperation could translate to designing complex physical systems in manufacturing or logistics down the road.
More episodes
- 2506.10913-Choreographic Quick Changes: First-Class Location (Set) Polymorphism
- 2507.14812-A Black-Box Approach for Exogenous Replenishment in Online Resource Allocation
- 2507.15448-Frames over finite fields with respect to the Galois inner product and their connections to self-orthogonal and LCD codes
- 2508.21572-NewsReX: An Open-Source Multi-Framework for Neural News Recommendation
- 2509.17028-Impact of Packetization on Network Calculus Analysis
- 2510.17342-AoA Services in 5G Networks: A Framework for Real-World Implementation and Systematic Testing
- 2511.04088-Efficient and rate-optimal list-decoding in the presence of minimal feedback
- 2511.17264-Notes on Stack Machines and Quantum Stack Machines
- 2601.15318-On the closest balanced game
- 1905.10490-Finding new routes for integrating Multi-Agent Systems using Apache Camel