ai claude_opus multi_agent_systems agentic_workflows sub_agents llm_orchestration prompt_engineering rag automation

Architecting Multi-Agent Debate Frameworks: Sub-Agent Orchestration and Automated Persona Synthesis via Claude Opus

4 min read

Architecting Multi-Agent Debate Frameworks: Sub-Agent Orchestration and Automated Persona Synthesis

In the evolving landscape of LLM orchestration, moving beyond simple single-prompt reasoning toward multi-agent debate systems represents a significant leap in cognitive depth. While many developers focus on "agent teams"—complex, autonomous groups of agents—there is a more cost-effective and computationally efficient pattern: Sub-Agent Orchestration.

This post explores the technical implementation of the "Roast Room," a framework designed to simulate high-level executive councils through hierarchical sub-agents, utilizing Claude Opus as the primary reasoning engine.

The Architecture: Sub-Agents vs. Agent Teams

A common pitfall in multi-agent design is the deployment of full agent teams for every task. While powerful, this approach often results in excessive token consumption and high latency with diminishing marginal returns on decision quality.

The "Roast Room" architecture shifts this paradigm by utilizing sub-agents. In this model, each council member (e.g., Jeff Bezos, Naval Ravikant) is not a fully autonomous agent running its own independent loop, but rather a specialized sub-agent instance triggered within a controlled orchestration layer. This allows for:

  1. Reduced Overhead: Minimizing the cost of recursive agent loops.
  2. Structured Interaction: Forcing agents into specific roles (e.g., "The Critic," "The Financier") to prevent conversational drift.
  3. Deterministic Debate Rounds: Controlling the flow from opening positions to rebuttals and final verdicts.

The Anatomy of an Agent: Markdown-Based Configuration

Each sub-agent in this system is instantiated via a lightweight configuration layer. At its simplest level, an agent's identity is defined by a Markdown file. This file acts as the system prompt, defining the "lens" through which the model processes information, its debating style, and its decision-making heuristics.

However, the true intelligence of the system lies in the "Brain" directory. To move beyond generic LLM personas, each agent is backed by a structured data repository containing:

  • Frameworks & Principles: Hardcoded logic (e.g., Dan Martell’s "Buyback Principle").
  • Positions & Rules: Specific stances on variables like pricing, debt, or scaling.
  • Sources & Stories: High-density semantic context derived from external datasets.
  • Voice/Persona MD: Instructions for linguistic style and tone.

Data Density and RAG Integration

The depth of these "brains" is significant. For instance, the Alex Hormozi agent is constructed from a corpus of approximately 500,000 words spanning 2021–2026, including 48 distinct sources, 14 primary interviews, and 34 instructional videos. By feeding this high-density context into the sub-agent's prompt window (or via RAG), we achieve a level of domain-specific reasoning that far exceeds standard zero-shot prompting.

Automated Persona Synthesis: The "New Roaster" Skill

One of the most advanced features of this implementation is the "New Roaster" skill—an automated pipeline for agent generation. This process automates the creation of both the technical configuration and the visual assets required for a new council member.

When a user requests a new persona (e.g., Elon Musk), the system executes a multi-step workflow:

  1. Agent File Generation: Creating the .md configuration with specific decision loops.
  2. Brain Construction: Aggregating relevant frameworks, principles, and sources into a structured folder hierarchy.
  3. Visual Asset Synthesis: Generating a character avatar/portrait to represent the agent in the UI.

This allows for the rapid scaling of the council, enabling users to dynamically inject subject matter expertise into any debate session without manual prompt engineering.

The Debate Workflow: Multi-Round Iteration

The orchestration engine follows a structured execution loop to ensure a rigorous "roast" of the user's input:

  1. Context Gathering: The system analyzes the initial prompt (e.g., an event planning decision) and identifies necessary context gaps, prompting the user for variables like budget, size, or location constraints.
  2. Agent Selection: Based on the topic, the orchestrator selects the most relevant sub-agents from the available pool (e.g., bringing in Naval Ravikant specifically to discuss "leverage" and "equity").
  3. Round 1: Opening Positions: Each agent generates an initial stance based on their specific lens (e.g., Warren Buffett focusing on cash flow and long-term risk).
  4. Round 2: The Rebuttal/Debate Phase: Agents are instructed to read the opening positions of their peers and actively "poke holes" in opposing arguments. This is where the system can utilize a "doubles advocate" logic, where the facilitator (Claude Code) forces an agent to argue against its initial position to ensure all perspectives are explored.
  5. Round 3: Final Verdict: The agents provide a final vote and score (e.g., 8/10), culminating in a synthesized PDF report that summarizes the debate, key points of contention, and the ultimate recommendation.

Conclusion: Scaling Human Expertise via Agentic Orchestration

The goal of this architecture is not to replace human judgment but to leverage the documented expertise of world-class thinkers through an agentic lens. By extracting frameworks from proven leaders and encoding them into sub-agent "brains," we create a scalable, programmable council that can provide multi-perspective scrutiny on any business decision.