Multi-agent LLM systems for music composition deploy role-specialized agents for melody, harmony, accompaniment, and quality review, collaboratively producing symbolic music through iterative feedback loops.

Music composition requires coordinating multiple musical elements: melody, harmony, rhythm, instrumentation, and structure. Multi-agent LLM frameworks address this by assigning specialized roles to different agents, mirroring how human composers and arrangers collaborate. CoComposer¹⁾ uses five role-specialized agents for iterative symbolic music creation in ABC notation, while WeaveMuse²⁾ provides an open framework for multimodal music tasks spanning text, notation, audio, and visual modalities.

CoComposer deploys five specialized agents using AutoGen group chats:

• Leader Agent: Analyzes user prompts and decomposes them into musical specifications (title, genre, key, chord progression, instruments, tempo, rhythm)
• Melody Agent: Generates the main melody in ABC notation with MIDI instrument info, tempo, rhythm, key, and genre parameters
• Accompaniment Agent: Creates harmony and supporting parts synchronized with the melody, handling chord progressions and rhythmic alignment
• Revision Agent: Receives feedback and applies targeted modifications to improve composition quality
• Review Agent: Evaluates the overall composition against quality criteria and provides structured feedback

The compositional workflow can be modeled as an iterative function:

<latex>f: P \to (M, A), \quad R(M, A) \to (M', A')</latex>

where $P$ is the prompt, $M$ is melody, $A$ is accompaniment, and $R$ is the review feedback function that drives iterative refinement.

Streamlined Design: CoComposer uses 5 agents (vs. ComposerX's 6), eliminating the separate Instrument agent to reduce communication rounds while maintaining quality.

WeaveMuse supports multimodal music tasks through:

• Specialist Agents: Interpret requirements, validate outputs across formats (ABC, MIDI, audio)
• Manager Agent: Selects tools, sequences actions, maintains state, handles user turns
• Intermodal Loops: Analysis-synthesis-render cycles across text, symbolic notation, audio, and visual modalities

WeaveMuse emphasizes reproducibility with interchangeable open-source models and supports cross-format constraint validation for rhythmic and harmonic coherence.

CoComposer is evaluated using AudioBox-Aesthetics on four criteria:

<latex>Q_{total} = w_{CE} \cdot Q_{CE} + w_{CU} \cdot Q_{CU} + w_{PC} \cdot Q_{PC} + w_{PQ} \cdot Q_{PQ}</latex>

where CE = Content Enjoyment, CU = Content Usefulness, PC = Production Complexity, PQ = Production Quality.

from dataclasses import dataclass, field
from enum import Enum
 
class AgentRole(Enum):
    LEADER = "leader"
    MELODY = "melody"
    ACCOMPANIMENT = "accompaniment"
    REVISION = "revision"
    REVIEW = "review"
 
@dataclass
class MusicSpec:
    title: str
    genre: str
    key: str
    tempo: int
    time_signature: str
    chord_progression: list[str] = field(default_factory=list)
    instruments: list[str] = field(default_factory=list)
 
class CoComposerSystem:
    def __init__(self, llm_model: str = "gpt-4o"):
        self.agents = {
            role: MusicAgent(role, llm_model)
            for role in AgentRole
        }
 
    def compose(self, user_prompt: str,
                max_iterations: int = 3) -> str:
        spec = self.agents[AgentRole.LEADER].decompose(
            user_prompt
        )
        melody_abc = self.agents[AgentRole.MELODY].generate(
            spec
        )
        accomp_abc = self.agents[AgentRole.ACCOMPANIMENT].generate(
            spec, melody_abc
        )
        for iteration in range(max_iterations):
            review = self.agents[AgentRole.REVIEW].evaluate(
                melody_abc, accomp_abc, spec
            )
            if review.score >= 0.85:
                break
            melody_abc, accomp_abc = (
                self.agents[AgentRole.REVISION].revise(
                    melody_abc, accomp_abc, review.feedback
                )
            )
        return self.merge_abc(melody_abc, accomp_abc)
 
    def merge_abc(self, melody: str, accomp: str) -> str:
        return f"X:1\n%%score 1 2\n" \
               f"V:1 name=\"Melody\"\n{melody}\n" \
               f"V:2 name=\"Accompaniment\"\n{accomp}"

• "CoComposer: Multi-Agent Collaborative Music Composition with LLMs" (2025)
• "WeaveMuse: Open Multi-Agent Framework for Multimodal Music" (2025)

• Image Editing Agents
• Video Editing Agents
• Game Playing Agents