Overview
Strategy Mode orchestrates three AI models working together in sophisticated multi-agent workflows. Unlike Parallel Mode where models work independently, Strategy Mode creates sequential pipelines where each model's output influences the next.
This guide covers four proven multi-agent patterns:
- Ensemble Synthesis: Models draft independently, a synthesizer combines best elements
- Model Arbitration: Models compete, a judge selects the winner
- Mixture of Agents: Sequential refinement with a composer finalizing output
- Multi-Agent Debate: Models critique each other, a critic arbitrates
Prerequisites
- Completed Guide 01 (The Editable Story) and Guide 04 (Parallel Mode)
- Active subscription with sufficient credits for 3-model execution
- Understanding of different model strengths (creative vs analytical vs balanced)
- Familiarity with prompt engineering and model temperature settings
Understanding Strategy Types
1. Ensemble Synthesis
Pattern: Parallel drafting → Unified synthesis
Roles:
- Drafter A: Generates first independent draft
- Drafter B: Generates second independent draft (without seeing A's output)
- Synthesizer: Receives both drafts, creates unified output combining best elements
Best For: Creative content (marketing copy, storytelling, brainstorming) where diversity of ideas is valuable and you want the best of multiple approaches.
Example: Product launch announcement where Drafter A focuses on technical features, Drafter B emphasizes emotional benefits, and Synthesizer creates a balanced message that appeals to both technical and emotional buyers.
2. Model Arbitration
Pattern: Competitive generation → Judged selection
Roles:
- Candidate A: Generates first solution
- Candidate B: Generates competing solution (without seeing A's output)
- Judge: Evaluates both solutions against criteria, selects winner or creates hybrid
Best For: Decision-making scenarios (proposal selection, design choices, strategic planning) where you need objective evaluation of competing approaches.
Example: Architecture decision document where Candidate A proposes microservices, Candidate B proposes monolithic architecture, and Judge evaluates based on team size, scalability needs, and maintenance considerations.
3. Mixture of Agents
Pattern: Sequential refinement → Final composition
Roles:
- Drafter: Creates initial rough draft
- Critic: Receives draft, identifies weaknesses and suggests improvements
- Composer: Receives both draft and critique, creates polished final version
Best For: Quality-critical content (legal documents, technical specifications, research papers) where iterative refinement produces superior results.
Example: API documentation where Drafter creates initial docs, Critic identifies missing error cases and unclear examples, and Composer produces comprehensive documentation with all gaps filled.
4. Multi-Agent Debate
Pattern: Adversarial critique → Arbitrated resolution
Roles:
- Advocate: Presents initial position with strong arguments
- Challenger: Receives position, presents counter-arguments and alternative view
- Arbitrator: Receives both positions, synthesizes balanced conclusion
Best For: Complex analysis (strategy documents, research synthesis, risk assessment) where exploring multiple perspectives leads to more robust conclusions.
Example: Investment thesis where Advocate presents bullish case, Challenger presents bearish case, and Arbitrator provides balanced risk-reward analysis considering both perspectives.
Step 1: Select Strategy Mode
- Navigate to the Authoring page
- Click the Execution Mode dropdown (defaults to "Single")
- Select "Strategy" from the dropdown
- The interface will display a validation message: "Strategy mode requires exactly 3 models"
Tip: Unlike Parallel Mode (2 models), Strategy Mode requires exactly 3 models. The generate button will remain disabled until you select 3 models.
Step 2: Choose Strategy Type
- After selecting Strategy mode, a new "Execution Strategy" dropdown appears
- Select your desired strategy:
- Ensemble Synthesis: For creative content needing diverse ideas
- Model Arbitration: For competitive evaluation and selection
- Mixture of Agents: For sequential refinement and quality improvement
- Multi-Agent Debate: For balanced analysis of complex topics
- The role labels will update based on your selected strategy
Warning: Strategy type cannot be changed after generation starts. Choose carefully based on your content goals.
Step 3: Select Three Models with Role Assignment
- Click "Available Models" to open the model selector
- The interface now shows role-specific dropdowns (roles vary by strategy type)
- For Ensemble Synthesis:
- Drafter A: Choose a creative model (e.g., Claude Sonnet)
- Drafter B: Choose a different creative model (e.g., GPT-4)
- Synthesizer: Choose a balanced, analytical model (e.g., Gemini Pro)
- For Model Arbitration:
- Candidate A: Choose model with one perspective
- Candidate B: Choose model with different strengths
- Judge: Choose most analytical, objective model
- For Mixture of Agents:
- Drafter: Choose fast, creative model for initial draft
- Critic: Choose analytical model good at finding weaknesses
- Composer: Choose high-quality model for final polish
- For Multi-Agent Debate:
- Advocate: Choose persuasive, creative model
- Challenger: Choose critical, analytical model
- Arbitrator: Choose balanced model for synthesis
Model Selection Tips:
- Use different model families to get diverse perspectives
- Consider cost vs quality: premium models for final roles, efficient models for drafting
- Temperature matters: Higher for creative roles, lower for analytical roles
- Check the model's SKU Level to ensure you have credits
Step 4: Configure Template and Tone
- Select an Artifact Template appropriate for your strategy:
- Ensemble Synthesis: Marketing, Blog, Creative Writing
- Model Arbitration: Decision Document, Technical Specification
- Mixture of Agents: Documentation, Research, Technical Writing
- Multi-Agent Debate: Analysis, Strategy, Research Synthesis
- Choose Template Tone:
- Creative (temp: 0.9): For ensemble synthesis and debate
- Balanced (temp: 0.7): For mixture of agents
- Precise (temp: 0.5): For model arbitration
- Adjust Max Output Tokens if needed (higher for synthesis/composition roles)
Cost Consideration: Strategy mode uses 3x the tokens of single mode. With sequential processing, later models receive longer input context (including previous outputs). Monitor your credit usage carefully.
Step 5: Write Your Prompt
Strategy mode prompts should provide clear context for the entire workflow:
Ensemble Synthesis Example:
Create a product launch announcement for our new AI-powered analytics platform. Target Audience: B2B SaaS buyers (both technical and business stakeholders) Key Points to Cover: - Real-time data visualization - Predictive analytics with 95% accuracy - Integration with 50+ data sources - Enterprise-grade security Please generate diverse drafts that will be synthesized into a unified message.
Model Arbitration Example:
We need to choose between two architecture approaches for our mobile app: Option A: Native iOS/Android (Swift/Kotlin) Option B: Cross-platform (React Native) Context: - Team: 5 developers (3 web, 2 mobile) - Timeline: 6 months to launch - Budget: $200K - Requirement: High performance, offline-first Generate competing analyses that will be judged for final recommendation.
Mixture of Agents Example:
Create API documentation for our User Authentication endpoint: POST /api/auth/login Parameters: - email (string, required) - password (string, required) - remember_me (boolean, optional) Returns: JWT token on success, error on failure This will go through draft → critique → final composition for maximum quality.
Multi-Agent Debate Example:
Analyze the investment thesis for Company X: Bullish Arguments (Advocate): - 300% revenue growth YoY - Strong moat with proprietary technology - Expanding to 10 new markets Bearish Arguments (Challenger): - Not yet profitable ($50M loss last quarter) - High customer acquisition cost ($500) - Intense competition from larger players Generate advocate position, challenger rebuttal, and arbitrated balanced assessment.
Prompt Engineering Tips:
- Be explicit about the strategy pattern you're using
- Provide evaluation criteria for arbitration strategies
- Include constraints (word count, tone, audience)
- For debate mode, outline both sides of the argument
Step 6: Execute Strategy
- Verify all three models are selected (one for each role)
- Confirm the Generate button is enabled
- Click Generate to start the multi-agent workflow
- Watch the progress indicator show sequential execution:
- Stage 1: First model generates (Drafter A / Candidate A / Drafter / Advocate)
- Stage 2: Second model receives Stage 1 output (Drafter B / Candidate B / Critic / Challenger)
- Stage 3: Third model receives both previous outputs (Synthesizer / Judge / Composer / Arbitrator)
- Total execution time: 2-5 minutes depending on model speed and output length
What's Happening Behind the Scenes:
- Each model receives the original prompt plus role-specific instructions
- Sequential models receive previous outputs as additional context
- Final model synthesizes, judges, composes, or arbitrates based on all prior work
- All intermediate outputs are preserved for your review
Step 7: Review Multi-Stage Output
Strategy mode preserves all intermediate outputs for full transparency:
- The AI Generation Pane displays a tabbed or collapsible interface
- Each role's output is shown separately with clear labels
- For Ensemble Synthesis:
- Drafter A: First independent draft
- Drafter B: Second independent draft
- Synthesizer: Final unified output (typically the best result)
- For Model Arbitration:
- Candidate A: First proposal
- Candidate B: Competing proposal
- Judge: Evaluation, recommendation, or hybrid solution
- For Mixture of Agents:
- Drafter: Initial rough draft
- Critic: Critique with improvement suggestions
- Composer: Polished final version (usually highest quality)
- For Multi-Agent Debate:
- Advocate: Initial position with arguments
- Challenger: Counter-arguments and rebuttals
- Arbitrator: Balanced synthesis considering both sides
- You can copy content from ANY stage, not just the final output
Pro Tip: Sometimes intermediate outputs contain valuable insights. The Drafter's creative ideas or the Critic's analysis might be worth preserving separately, even if the final Composer output is your primary deliverable.
Step 8: Edit and Refine
Strategy mode outputs are fully editable like any other generation:
- Click on any section to activate the Tiptap editor
- Use the floating toolbar for text formatting (Bold, Italic, Headings, Colors)
- Edit, delete, or reorganize sections as needed
- You can mix content from different stages:
- Copy introduction from Drafter A
- Copy body paragraphs from Synthesizer
- Copy conclusion from Drafter B
- For Model Arbitration, you might keep both proposals and the Judge's analysis
- For Multi-Agent Debate, you might structure final doc as: Position → Counter-Position → Synthesis
Hybrid Authoring Workflows:
- Run Ensemble Synthesis to get diverse ideas, then manually curate best elements
- Use Model Arbitration to generate options, then add your own expert commentary
- Apply Mixture of Agents for base quality, then add domain-specific refinements
- Leverage Multi-Agent Debate for balanced analysis, then add your own conclusions
Step 9: Regenerate Specific Sections
If one section isn't meeting your needs, regenerate it without re-running the entire workflow:
- Hover over the section header to reveal the Regenerate icon (circular arrow)
- Click the icon to regenerate just that section
- The regeneration uses the same model and role as the original
- If you want a different approach:
- Manually edit the section with your own instructions
- Or change the execution mode to Single, select a different model, and regenerate
Note: Section regeneration is independent. If you regenerate the Synthesizer output, it won't automatically re-read updated Drafter outputs. For full re-synthesis, you need to run the complete Strategy workflow again.
Step 10: Save Version with Strategy Metadata
- Click Save Version in the toolbar
- Enter a descriptive version name that includes the strategy type (e.g., "Product Launch - Ensemble v1")
- The system automatically saves:
- All three model outputs (one for each role)
- Strategy type and configuration
- Model assignments for each role
- Temperature, tone, and other parameters
- You can load this version later to see the complete multi-agent workflow
- Versions are saved to Google Cloud Storage with immediate availability (no delay)
Version Control Best Practice: Save a version after each complete Strategy execution before making manual edits. This lets you compare the "pure" multi-agent output to your refined version.
Step 11: Export Strategy Results
Export your final document with optional model attribution:
- Click Export in the toolbar
- Choose format: PDF, DOCX, or HTML
- Toggle "Include Model Attribution" if you want footnotes showing which model generated each section
- For Strategy mode, attribution will show role names (e.g., "Generated by Drafter: Claude Sonnet")
- Download the file and verify formatting
Export Options for Strategy Mode:
- Full Workflow: Export all three outputs as separate sections (good for transparency)
- Final Only: Export only the Synthesizer/Judge/Composer/Arbitrator output
- Comparison View: Export as side-by-side (useful for Model Arbitration)
Advanced: Choosing the Right Strategy
Decision Matrix
| Strategy | Best For | Avoid When | Expected Quality |
|---|---|---|---|
| Ensemble Synthesis | Creative content, brainstorming, marketing | Highly technical, regulated content | High creativity, moderate consistency |
| Model Arbitration | Decision-making, architecture choices | Single clear solution exists | High objectivity, structured analysis |
| Mixture of Agents | Technical docs, research, quality-critical | Simple content, tight deadlines | Highest quality, most polished |
| Multi-Agent Debate | Complex analysis, strategy, risk assessment | One-sided topics, simple yes/no questions | Most balanced, comprehensive perspectives |
Real-World Comparisons
Scenario: Product Marketing Copy
- Single Mode: Fast, consistent tone, but may miss creative angles
- Parallel Mode: Two independent approaches, you manually combine
- Ensemble Synthesis: ✅ Best choice - automated synthesis of diverse creative ideas
Scenario: API Documentation
- Single Mode: Adequate, but may miss edge cases
- Ensemble Synthesis: Too creative, inconsistent structure
- Mixture of Agents: ✅ Best choice - draft → critique → polished final
Scenario: Technology Decision (Build vs Buy)
- Single Mode: May be biased toward one option
- Parallel Mode: Good, but you have to judge yourself
- Model Arbitration: ✅ Best choice - structured competitive analysis with judgment
Scenario: Investment Risk Analysis
- Single Mode: May lack depth in considering both sides
- Ensemble Synthesis: Too consensus-oriented, may miss contrarian views
- Multi-Agent Debate: ✅ Best choice - explicit advocate/challenger/arbitrator structure
Troubleshooting
Generate button stays disabled
Verify you have selected exactly 3 models (one for each role). Check the validation message below the model selector.
Final output doesn't reference earlier stages
This is expected for Ensemble Synthesis (Drafters work independently). For other strategies, check that your prompt explicitly asks for synthesis/judgment/composition based on previous inputs.
Synthesizer output is too short or generic
Increase Max Output Tokens for the final role. Also ensure your prompt asks for comprehensive synthesis, not just a summary.
Models agree too much (not enough diversity)
Use models from different families (Claude, GPT, Gemini) rather than multiple versions of the same model. Increase temperature for creative roles.
Execution is too slow
Strategy mode is inherently slower (sequential processing). Use faster models for drafting roles (Drafter, Candidate, Advocate) and reserve premium models for final roles (Synthesizer, Judge, Composer, Arbitrator).
Running out of credits quickly
Strategy mode uses 3x tokens minimum (often more due to sequential context). Consider:
- Using lower SKU Level models for non-final roles
- Reducing Max Output Tokens
- Using Strategy mode only for critical content
- Upgrading to a higher subscription tier
Best Practices
Match Strategy to Content Goals
Don't use Strategy mode just because it's advanced. Single or Parallel mode may be more cost-effective for straightforward content. Use Strategy when you specifically need synthesis, judgment, refinement, or balanced analysis.
Optimize Model Selection for Roles
The final role (Synthesizer/Judge/Composer/Arbitrator) should use your highest-quality model since that output is usually what you'll deliver. Earlier roles can use faster, cheaper models to control costs.
Save Intermediate Outputs
Don't discard Drafter or Critic outputs after synthesis/composition. They often contain insights worth preserving separately or referencing later.
Iterate on Strategy Type
Try different strategies on the same prompt to see which produces the best results for your specific content type. What works for marketing may not work for technical docs.
Monitor Token Usage
Check your subscription dashboard after Strategy executions. Sequential processing means later models receive long input contexts (original prompt + all previous outputs), which can consume tokens quickly.
Use Version Control Extensively
Save versions after each Strategy run with descriptive names ("Ensemble v1", "Arbitration v2") so you can compare different multi-agent approaches to the same prompt.
Summary
Congratulations! You've mastered Strategy Mode and multi-agent workflows. You now understand:
- The four core strategy types and when to use each
- How to assign models to specialized roles (Drafter, Critic, Judge, etc.)
- Sequential execution patterns and how context flows between models
- How to review and leverage intermediate outputs
- Cost optimization strategies for multi-agent workflows
- How to export strategy results with model attribution
Strategy Mode represents the cutting edge of AI-assisted content creation, enabling sophisticated multi-agent collaboration patterns that weren't possible with single-model systems.
What's Next? Explore advanced features like RAG (Retrieval-Augmented Generation), custom templates, and API integration in our Enterprise guides.