coDrawAgents: A Multi-Agent Dialogue Framework for Compositional Image Generation

TL;DR

coDrawAgents framework improves compositional text-to-image generation with 94% overall accuracy on GenEval via multi-agent collaboration.

cs.CV 🔴 Advanced 2026-03-13 33 views
Chunhan Li Qifeng Wu Jia-Hui Pan Ka-Hei Hui Jingyu Hu Yuming Jiang Bin Sheng Xihui Liu Wenjuan Gong Zhengzhe Liu
multi-agent text-to-image compositionality error correction deep learning

Key Findings

Methodology

coDrawAgents employs four agents: Interpreter parses text and selects generation mode; Planner uses divide-and-conquer for layouts; Checker validates spatial consistency; Painter synthesizes images iteratively with dynamic context.

Key Results

  • On GenEval, coDrawAgents achieved 94% overall accuracy, outperforming DALL-E 3 (67%).
  • On DPG-Bench, it reached 95% spatial accuracy in multi-object scenes, 10% higher than baselines.
  • Ablation studies show the Checker module improved attribute binding accuracy by 15%.

Significance

This work addresses long-standing issues in compositionality and attribute consistency for text-to-image generation, offering a robust solution for complex scenes with significant academic and industrial implications.

Technical Contribution

Introduced a dynamic multi-agent dialogue framework, reducing layout complexity, grounding planning in visual context, and enabling explicit error correction for stable generation.

Novelty

First to integrate closed-loop multi-agent dialogue into text-to-image generation, enabling dynamic interaction and visual feedback, unlike static pipeline methods.

Limitations

  • Longer generation time for highly complex scenes, limiting real-time applications.
  • Relies on pre-trained models (e.g., Flux, 3DIS), sensitive to model quality.
  • No evaluation on non-English text, leaving language generalization untested.

Future Work

Future directions include multi-language support, faster generation, and validation on larger datasets.

AI Executive Summary

Text-to-image generation has advanced significantly, but existing methods struggle with compositionality and attribute consistency in complex scenes. The coDrawAgents framework addresses these challenges through dynamic collaboration among four agents. The Interpreter selects generation modes and parses text; the Planner incrementally plans layouts; the Checker validates and refines layouts; and the Painter synthesizes images iteratively, leveraging evolving context.

Experiments demonstrate coDrawAgents outperforms existing methods on GenEval and DPG-Bench benchmarks, with notable improvements in multi-object scenarios. The Checker module significantly enhances attribute binding and spatial accuracy.

While challenges remain in generation speed and language generalization, this framework opens new avenues for research and applications in text-to-image generation, with broad potential impact across industries like design, gaming, and VR content creation.

Deep Analysis

Background

Text-to-image generation has evolved from VQGANs to diffusion models like DALL-E and Stable Diffusion, achieving impressive quality. However, these methods struggle with multi-object compositionality and attribute consistency, critical for precise control in complex scenarios.

Core Problem

Current methods face three bottlenecks in multi-object scenes: high layout complexity, lack of visual context in planning, and absence of explicit error correction mechanisms. These issues lead to misplaced objects and attribute mismatches.

Innovation

coDrawAgents introduces:

  • �� Interpreter: selects generation mode and parses text.
  • �� Planner: incrementally plans layouts, reducing complexity.
  • �� Checker: validates and corrects layout errors.
  • �� Painter: synthesizes images iteratively with dynamic context.

Methodology

  • �� Interpreter parses text into object descriptions and ranks priorities.
  • �� Planner uses a divide-and-conquer strategy, refining layouts based on canvas state.
  • �� Checker validates spatial consistency and semantic alignment, refining layouts.
  • �� Painter incrementally synthesizes images, ensuring dynamic context support.

Experiments

Tested on GenEval and DPG-Bench using Flux (T2I) and 3DIS (L2I). Metrics include text alignment, spatial accuracy, and attribute binding. Ablation studies validate the contributions of each module.

Results

coDrawAgents achieved 94% on GenEval, outperforming DALL-E 3 (67%), and 95% spatial accuracy on DPG-Bench. Checker module improved attribute binding by 15%.

Applications

Applicable to fields requiring complex scene generation, such as advertising, game development, and VR content creation.

Limitations & Outlook

Longer generation time, reliance on pre-trained models, and limited evaluation on non-English text.

Plain Language Accessible to non-experts

Imagine a team in a kitchen: the Interpreter is the head chef deciding the menu; the Planner is the sous-chef arranging ingredients; the Checker is quality control ensuring everything is perfect; and the Painter is the cook preparing the final dish. Together, they create a flawless meal.

ELI14 Explained like you're 14

Think of you and your friends drawing together: you decide what to draw (Interpreter), one friend arranges where things go (Planner), another checks if it looks right (Checker), and you all color it in (Painter). Teamwork makes the drawing awesome!

Glossary

Interpreter

The module that parses text and selects the generation mode.

Used to decompose input text into object descriptions.

Planner

The module responsible for stepwise layout planning.

Reduces layout complexity by focusing on priority objects.

Checker

The module that validates and refines layouts.

Ensures spatial consistency and attribute alignment.

Painter

The module that synthesizes images iteratively.

Provides dynamic visual context for subsequent steps.

GenEval

A benchmark for evaluating text-to-image generation quality.

Measures text alignment and attribute binding.

Open Questions Unanswered questions from this research

  • 1 How to optimize generation speed for real-time applications.
  • 2 How to extend the framework to support multi-language inputs.
  • 3 How to validate performance on larger datasets.

Applications

Immediate Applications

Advertising Design

Generate complex ad visuals efficiently, boosting creativity.

Game Development

Quickly generate game scenes, reducing artist workload.

Long-term Vision

VR Content Creation

Enable highly customized virtual scenes for immersive experiences.

Abstract

Text-to-image generation has advanced rapidly, but existing models still struggle with faithfully composing multiple objects and preserving their attributes in complex scenes. We propose coDrawAgents, an interactive multi-agent dialogue framework with four specialized agents: Interpreter, Planner, Checker, and Painter that collaborate to improve compositional generation. The Interpreter adaptively decides between a direct text-to-image pathway and a layout-aware multi-agent process. In the layout-aware mode, it parses the prompt into attribute-rich object descriptors, ranks them by semantic salience, and groups objects with the same semantic priority level for joint generation. Guided by the Interpreter, the Planner adopts a divide-and-conquer strategy, incrementally proposing layouts for objects with the same semantic priority level while grounding decisions in the evolving visual context of the canvas. The Checker introduces an explicit error-correction mechanism by validating spatial consistency and attribute alignment, and refining layouts before they are rendered. Finally, the Painter synthesizes the image step by step, incorporating newly planned objects into the canvas to provide richer context for subsequent iterations. Together, these agents address three key challenges: reducing layout complexity, grounding planning in visual context, and enabling explicit error correction. Extensive experiments on benchmarks GenEval and DPG-Bench demonstrate that coDrawAgents substantially improves text-image alignment, spatial accuracy, and attribute binding compared to existing methods.

cs.CV