MacNet: Scale Multi-Agent LLM Collaboration Beyond Linear Workflows with Custom Topologies

Traditional multi-agent systems powered by large language models (LLMs) often follow rigid, sequential workflows—like a single assembly line where each agent hands off a task to the next. While useful for simple pipelines, this linear approach severely limits exploration: only one development path is pursued, potentially missing better solutions or requiring costly trial-and-error iterations.

Enter MacNet—a framework built on ChatDev that reimagines multi-agent collaboration through customizable network topologies. By modeling agent interactions as directed acyclic graphs (DAGs), MacNet enables parallel, branching collaboration paths that mimic real-world team dynamics. This isn’t just about adding more agents; it’s about enabling structured, scalable exploration of the solution space without hitting context-length barriers or sacrificing coherence.

For project leads, researchers, and technical decision-makers seeking to automate complex tasks—especially in software development or structured creative domains—MacNet offers a principled way to move beyond single-chain limitations and generate higher-quality, diverse outputs through orchestrated agent networks.

Why MacNet Matters: Solving the “One Path, One Outcome” Problem

Most LLM-based agent frameworks operate in linear phases: planning → coding → testing → deployment. Each phase produces a single output, which flows downstream. This works for straightforward tasks, but real-world problems rarely have a single optimal path.

MacNet directly addresses this by allowing multiple collaborative development trajectories to coexist and interact. Its foundation is the Multi-Agent Collaboration Network (MacNet) framework, which represents agents as nodes in a DAG. Edges define information flow, enabling code, ideas, or partial solutions to evolve along multiple branches simultaneously. Crucially, MacNet handles context management intelligently, so scaling to dozens of agents doesn’t break due to token limits.

This architecture unlocks two key capabilities:

• Diverse solution exploration: Instead of one Gomoku implementation, you get several variants shaped by different agent sub-teams.
• Cross-team orchestration (Croto): Borrowing from the Croto methodology, MacNet supports strategic interactions between independent agent teams at critical decision points—like having multiple engineering squads propose UI designs, then converge on the best one through peer review.

The result? Higher software quality, reduced redundancy, and fewer dead ends—all without manual intervention.

Key Features That Address Real Collaboration Challenges

1. Topology-Aware Agent Deployment

MacNet lets you define how agents collaborate—not just that they collaborate. Using generate_graph.py, you can create tree, chain, star, or fully custom DAG structures. For example:

python generate_graph.py --node_num 10 --topology tree  

This flexibility mirrors real organizational structures: hierarchical review chains, parallel feature teams, or hybrid workflows.

2. Scalable Collaboration Without Context Overflow

By design, MacNet ensures that no single LLM call exceeds context limits. Agent communications are localized to graph edges, and intermediate artifacts (like code diffs) are persisted between nodes. This makes scaling to 10, 20, or more agents feasible—even with standard LLM backends.

3. Realistic Agent Roles via SRDD_Profile

Generic “coder” or “tester” personas limit realism. MacNet integrates the SRDD_Profile dataset—a large-scale collection of domain-specific agent role prompts (e.g., “frontend React developer for e-commerce apps”). When launching a task, you can specify a software category:

python run.py --task "Build a to-do app" --name "TodoApp" --type web  

Agents then adopt contextually appropriate personas, improving the relevance and depth of their contributions.

4. Built-In Cross-Team Intelligence (Croto)

The Croto integration enables multi-team problem solving. At aggregation nodes, solutions from predecessor teams are merged using strategies like greedy selection or hierarchical pruning. The aggregate() function in graph.py orchestrates this, allowing diverse inputs to be synthesized into a superior unified output—much like a tech lead reconciling proposals from multiple squads.

Where MacNet Delivers Maximum Value

MacNet excels in scenarios that demand structured exploration with phased decision points, such as:

• Automated software prototyping: Generate multiple architectural variants of a feature (e.g., user auth via OAuth vs. JWT) and let agent teams refine each path before convergence.
• Creative content generation: In story writing, different agent sub-teams can explore plot branches (hero’s journey vs. redemption arc), with MacNet merging the strongest elements.
• Technical design space exploration: When building a data pipeline, parallel teams can evaluate Spark vs. Flink vs. Dask approaches, with cross-team feedback improving the final selection.

Crucially, MacNet is not designed for real-time control systems, unstructured brainstorming, or tasks that can’t be decomposed into discrete phases. Its strength lies in orchestrated, topology-guided collaboration.

Getting Started in Under Five Minutes

You don’t need deep AI expertise—just a clear task description and Python:

1. Generate your collaboration graph:

   python generate_graph.py --node_num 8 --topology tree  
   

   This creates a config in config.yaml defining agent topology.

2. Launch the collaboration:

   python run.py --task "Develop a basic Gomoku game." --name "Gomoku"  
   

   Optionally add --type game to pull role prompts from SRDD_Profile.

3. Monitor and retrieve results:

   • Real-time logs (including code diffs and agent suggestions) appear in MacNetLog/.
   • Final software outputs are saved in timestamped folders under WareHouse/.

The entire process is observable, reproducible, and requires no manual agent prompting.

Limitations and Practical Considerations

While powerful, MacNet isn’t a universal solution:

• Domain focus: Optimized for software development and structured creative tasks (e.g., stories). Less effective for open-ended or sensory-driven tasks (e.g., image generation).
• LLM dependency: Requires access to a capable LLM backend (e.g., GPT-4, Claude, or open-weight models). Cost and latency scale with graph size.
• Task decomposability: Works best when your problem can be broken into sequential or branching phases with clear interfaces between them.

That said, for its target use cases, MacNet represents a significant leap over linear agent workflows—turning multi-agent systems from assembly lines into dynamic, exploratory collaboration networks.

Summary

MacNet redefines what’s possible with LLM-based agent teams by replacing rigid pipelines with flexible, topology-driven collaboration. By enabling parallel solution exploration, realistic agent roles, and cross-team synthesis—all while managing context limits—it directly tackles the “one path, one outcome” bottleneck of traditional approaches. For technical leaders automating complex, phased tasks, MacNet offers a scalable, observable, and higher-quality alternative to linear agent frameworks.