Articles/Agents & Manager

◈ Agents & Manager/2026-03-21Advanced

Antigravity Multi-Agent Production Patterns — Delegation, Parallel Execution, and Cost, from a Solo Developer View

Antigravity production multi-agent orchestration from a solo developer view. Beyond five orchestration patterns: deciding what to delegate, choosing your degree of parallelism, and the signals to monitor so cost stays in the black.

agents¹²³ multi-agent⁴⁹ orchestration²¹ production⁷¹ Mission Control advanced²⁰ enterprise⁴

✦ Premium Article

For a stretch of years I ran six mobile apps in parallel by myself, and release-heavy weeks were always a tightrope walk. I would be adjusting a banner placement in one app when a review rejection landed on another. You only have two hands.

The first time I handed a batch of tasks to multiple agents, that tightrope came back to me. The core question—how do you hold together things that run in parallel—hadn't changed. What breaks a system is almost always coordination and monitoring left for later.

This article organizes Antigravity's production multi-agent orchestration through the lens of solo development rather than enterprise theory. Alongside five orchestration patterns, it covers how to decide what to delegate versus keep in your own hands, and how to design parallelism so cost doesn't break you.

Understanding Multi-Agent Orchestration

Single agents excel at focused tasks, but enterprise workflows require sophisticated coordination:

Code Review Agent identifies style violations and design issues
Test Generation Agent creates comprehensive test suites
Documentation Agent maintains accurate API documentation
Security Scanner Agent flags vulnerabilities and compliance issues
Performance Analyzer Agent optimizes bottlenecks

These agents working independently produce fragmented results. With proper orchestration, they become a unified intelligence augmenting every development decision.

The Mission Control Architecture

Antigravity's Mission Control is the orchestration backbone—a coordination layer that:

Routes tasks to appropriate agents based on context
Manages dependencies between agent executions
Handles failures with fallback strategies
Coordinates outputs for downstream processing
Tracks progress across multi-step workflows
Maintains context across agent invocations

// AGENTS.md configuration for Mission Control
{
  "mission": "code-quality-improvement",
  "version": "1.0",
  "agents": {
    "review": {
      "role": "code-quality-guardian",
      "model": "claude-opus-4",
      "context": "full-project"
    },
    "testing": {
      "role": "test-coverage-specialist",
      "model": "claude-opus-4",
      "context": "file-aware"
    },
    "documentation": {
      "role": "api-documentation-expert",
      "model": "claude-haiku-4",
      "context": "exports-only"
    }
  },
  "orchestration": {
    "type": "sequential-with-fallback",
    "timeout": 3600,
    "retryPolicy": "exponential-backoff"
  }
}

✦

Thank you for reading this far.

Continue Reading

What follows includes implementation code, benchmarks, and practical content we hope you'll find useful. This site runs without ads — server and development costs are supported entirely by members like you. If it's been helpful, we'd be truly grateful for your support.

WHAT YOU'LL LEARN

✦A concrete line for what to delegate, judged by verification cost, reversibility, and repetition

✦Choosing parallelism by the number of outputs you can verify, so cost never breaks you

✦Production monitoring via three signals: tokens per task, retry rate, and approval backlog

Secure payment via Stripe · Cancel anytime

✦

Unlock This Article

Get full access to the rest of this article. Buy once, read anytime. This site is ad-free — your support goes directly toward keeping it running.

Unlock all articles with Membership →

Pattern 1: Sequential Orchestration with Handoff

Use case: Linear workflows where each agent's output becomes the next agent's input.

This pattern works for:

Code generation followed by testing followed by documentation
Requirements gathering followed by design followed by implementation
Security scanning followed by remediation followed by verification

// Sequential execution flow in Mission Control
export class SequentialOrchestrator {
  async executeWorkflow(task: WorkflowTask): Promise<WorkflowResult> {
    const results: AgentResult[] = [];
    let input = task.initialData;
 
    for (const agentName of task.agentSequence) {
      try {
        const agent = this.agents[agentName];
 
        // Plan mode: preview agent action before execution
        const plan = await agent.generatePlan(input);
        await this.notifyPlanGenerated(plan);
 
        // Execute with context from previous steps
        const output = await agent.execute({
          input,
          context: results,
          planApproval: true
        });
 
        results.push({
          agent: agentName,
          output,
          timestamp: Date.now(),
          success: true
        });
 
        // Use output as next agent's input
        input = output.transformedData;
 
      } catch (error) {
        // Failure handling strategy
        if (task.critical) {
          throw error;
        }
        // Non-critical failures: log and continue
        results.push({
          agent: agentName,
          error: error.message,
          success: false
        });
      }
    }
 
    return {
      completed: true,
      results,
      finalOutput: input,
      totalDuration: this.calculateDuration(results)
    };
  }
}

Plan Mode in Action:

User: "Refactor UserService to use dependency injection"

Mission Control Plan:
1. [code-analyzer-agent] Analyze current UserService structure
   - Identify 7 dependencies
   - Map injection points

2. [refactoring-agent] Generate refactored implementation
   - Apply constructor injection
   - Update 12 call sites

3. [testing-agent] Create tests for refactored code
   - Generate unit tests
   - Generate integration tests

4. [verification-agent] Ensure compatibility
   - Type checking
   - Circular dependency detection

[User approves plan]

Executing... (3 of 4 steps complete)

Pattern 2: Parallel Agent Execution

Use case: Independent analysis tasks where results are merged or combined.

// Parallel execution for independent agents
export class ParallelOrchestrator {
  async executeParallelAgents(
    codeFile: string,
    agents: Agent[]
  ): Promise<CombinedAnalysis> {
 
    // All agents analyze simultaneously
    const analyses = await Promise.all(
      agents.map(agent =>
        agent.analyze(codeFile, {
          timeout: 30000,
          priority: 'high'
        })
      )
    );
 
    // Aggregate results
    return {
      security: analyses[0],      // SecurityAgent output
      performance: analyses[1],   // PerformanceAgent output
      accessibility: analyses[2], // A11yAgent output
      style: analyses[3],         // StyleAgent output
 
      // Combined insights
      criticalIssues: this.mergeCritical(analyses),
      recommendations: this.rankByImpact(analyses),
      estimatedFixTime: this.calculateRemediationTime(analyses)
    };
  }
}

Enterprise Use Case: Code Review Pipeline

// Parallel agents in production code review
const parallelReviewAgents = [
  {
    agent: 'security-agent',
    analysis: 'vulnerability-scanning',
    timeout: 45000,
    context: 'dependencies + code'
  },
  {
    agent: 'performance-agent',
    analysis: 'algorithmic-complexity',
    timeout: 30000,
    context: 'code only'
  },
  {
    agent: 'accessibility-agent',
    analysis: 'a11y-compliance',
    timeout: 25000,
    context: 'ui-code only'
  },
  {
    agent: 'style-agent',
    analysis: 'code-style',
    timeout: 15000,
    context: 'code only'
  }
];
 
// All four agents run simultaneously on pull request
// Results aggregated in <2 minutes for production feedback

Pattern 3: Router Pattern with Dynamic Agent Selection

Use case: Different request types require different agents. Route to the most appropriate handler.

// Smart routing based on task classification
export class RouterAgent {
  private routes = new Map<string, Agent>();
 
  async classifyTask(input: string): Promise<string> {
    // Use lightweight model for classification
    const classification = await claude.classify(input, {
      categories: [
        'bug-fix',
        'feature-implementation',
        'refactoring',
        'documentation',
        'infrastructure',
        'performance-optimization'
      ]
    });
 
    return classification.category;
  }
 
  async routeAndExecute(input: string): Promise<AgentResult> {
    const category = await this.classifyTask(input);
    const targetAgent = this.routes.get(category);
 
    if (!targetAgent) {
      return {
        success: false,
        error: `No agent configured for ${category}`
      };
    }
 
    return targetAgent.execute(input, {
      classified: true,
      category,
      confidence: this.getConfidence(category)
    });
  }
}

Router Configuration in AGENTS.md:

router:
  classification:
    model: "claude-haiku-4"  # Fast classification
    retryOnLowConfidence: true
    fallbackCategory: "general-assistant"
 
  routes:
    bug-fix:
      agent: "debugging-specialist"
      priority: "high"
      estimatedTime: "15-30 minutes"
 
    feature-implementation:
      agent: "feature-engineer"
      priority: "normal"
      estimatedTime: "2-4 hours"
 
    refactoring:
      agent: "code-architect"
      priority: "normal"
      estimatedTime: "1-3 hours"
 
    performance-optimization:
      agent: "performance-specialist"
      priority: "normal"
      estimatedTime: "30-60 minutes"

Pattern 4: Consensus-Based Validation

Use case: Critical decisions requiring validation from multiple perspectives.

When code changes affect critical systems, multiple agents independently validate the proposal before approval.

// Consensus pattern for critical changes
export class ConsensusValidator {
  async validateCriticalChange(
    change: CodeChange,
    validators: Agent[]
  ): Promise<ValidationResult> {
 
    // Get independent assessments
    const assessments = await Promise.all(
      validators.map(agent =>
        agent.validate(change, { independentAnalysis: true })
      )
    );
 
    // Calculate consensus
    const consensus = this.calculateConsensus(assessments);
 
    return {
      unanimous: consensus.agreementLevel === 1.0,
      agreementLevel: consensus.agreementLevel,
      approvalVotes: assessments.filter(a => a.approved).length,
      concerns: this.extractConcerns(assessments),
      recommendation: this.determineRecommendation(consensus),
      canProceed: consensus.agreementLevel >= 0.8
    };
  }
 
  private extractConcerns(assessments: Assessment[]): Concern[] {
    return assessments
      .filter(a => a.concerns && a.concerns.length > 0)
      .flatMap(a => a.concerns)
      .sort((a, b) => b.severity - a.severity);
  }
}

Production Example: Database Migration Validation

// Before executing database migrations, validate with multiple agents
 
const migrationValidators = [
  {
    name: 'schema-safety-agent',
    role: 'Validates schema compatibility'
  },
  {
    name: 'performance-impact-agent',
    role: 'Analyzes query performance implications'
  },
  {
    name: 'data-integrity-agent',
    role: 'Ensures data preservation'
  },
  {
    name: 'rollback-safety-agent',
    role: 'Verifies rollback procedures'
  }
];
 
// All four agents validate independently
// Migration only executes if >= 3/4 approve

Pattern 5: Adaptive Learning and Feedback Loops

Use case: Agents improve their outputs based on feedback, creating learning feedback loops.

// Adaptive agent with learning feedback
export class AdaptiveAgent extends Agent {
  private feedbackHistory: Feedback[] = [];
  private performanceMetrics: PerformanceMetric[] = [];
 
  async execute(input: string): Promise<AgentResult> {
    // Get similar past tasks
    const similarPastTasks = await this.findSimilarTasks(input);
    const successfulApproaches = similarPastTasks
      .filter(t => t.feedback.successful)
      .map(t => t.approach);
 
    // Execute with learned context
    const result = await this.agent.execute(input, {
      learnedContext: successfulApproaches,
      previousAttempts: this.feedbackHistory
    });
 
    // Track performance for future improvement
    this.performanceMetrics.push({
      taskId: result.id,
      executionTime: result.duration,
      qualityScore: await this.evaluateQuality(result),
      timestamp: Date.now()
    });
 
    return result;
  }
 
  async acceptFeedback(feedback: Feedback): void {
    this.feedbackHistory.push({
      ...feedback,
      timestamp: Date.now()
    });
 
    // Retrain or adjust prompts based on feedback
    if (feedback.type === 'quality-issue') {
      await this.updateSystemPrompt(feedback.details);
    }
  }
}

Production Configuration Best Practices

AGENTS.md Structure for Enterprise

version: "1.0"
metadata:
  project: "backend-infrastructure"
  team: "core-platform"
  slackChannel: "#agent-alerts"
 
agents:
  code-quality-guardian:
    model: "claude-opus-4"
    contextWindow: "unlimited"
    timeout: 300
    retryPolicy: "aggressive"
    alertThreshold: "error"
 
  test-coverage-specialist:
    model: "claude-opus-4"
    contextWindow: "100k"
    timeout: 600
    retryPolicy: "gentle"
    alertThreshold: "warning"
 
  performance-analyst:
    model: "claude-opus-4"
    contextWindow: "100k"
    timeout: 180
    retryPolicy: "moderate"
    alertThreshold: "critical"
 
orchestration:
  defaultPattern: "sequential-with-parallel-fallback"
  maxConcurrentAgents: 4
  globalTimeout: 3600
  failureStrategy: "escalate-to-human"
 
  patterns:
    - name: "pull-request-review"
      agents: ["code-quality-guardian", "test-coverage-specialist"]
      type: "parallel"
 
    - name: "release-validation"
      agents: ["performance-analyst", "security-validator", "compatibility-checker"]
      type: "consensus"
      requiredAgreement: 0.8
 
monitoring:
  metricsCollection: true
  agentPerformanceTracking: true
  slackAlerts: true
  customMetrics:
    - "execution-time-by-agent"
    - "failure-rate-trends"
    - "human-override-frequency"

Performance Optimization Strategies

Context Management for Large Codebases

// Selective context loading for performance
export class ContextOptimizer {
  async prepareContext(
    targetFile: string,
    agent: Agent
  ): Promise<ProjectContext> {
 
    const context = {
      // Always include: target file + immediate dependencies
      primary: await this.loadFileAndDependencies(targetFile),
 
      // Include only if agent requests: broader context
      secondary: agent.needsBroaderContext
        ? await this.loadRelatedFiles(targetFile)
        : null,
 
      // Load on-demand: full project context
      full: null, // Loaded only if needed
 
      // Pre-compute expensive analyses
      precomputedMetrics: await this.calculateMetrics(targetFile)
    };
 
    return context;
  }
}

Caching and State Management

// Cache agent outputs to avoid redundant analysis
export class AgentCache {
  private cache = new Map<string, CachedResult>();
  private readonly TTL = 3600000; // 1 hour
 
  async execute(agent: Agent, input: string): Promise<AgentResult> {
    const cacheKey = this.generateKey(agent.name, input);
 
    // Check cache validity
    if (this.cache.has(cacheKey)) {
      const cached = this.cache.get(cacheKey)!;
      if (Date.now() - cached.timestamp < this.TTL) {
        return cached.result;
      }
    }
 
    // Execute and cache
    const result = await agent.execute(input);
    this.cache.set(cacheKey, {
      result,
      timestamp: Date.now()
    });
 
    return result;
  }
}

Error Handling and Resilience

Graceful Degradation Strategy

// Fallback chain when primary agent fails
export class ResilientOrchestrator {
  private fallbackChain = [
    { agent: 'claude-opus-4', context: 'full' },
    { agent: 'claude-sonnet-3', context: 'focused' },
    { agent: 'claude-haiku-4', context: 'minimal' }
  ];
 
  async executeWithFallback(task: Task): Promise<Result> {
    for (const option of this.fallbackChain) {
      try {
        return await this.executeAgent(option.agent, task, option.context);
      } catch (error) {
        console.log(`Agent ${option.agent} failed, trying fallback...`);
        continue;
      }
    }
 
    throw new Error('All agent options exhausted');
  }
}

Real-World Enterprise Scenarios

Scenario 1: Continuous Integration Pipeline

Multi-agent system validates every pull request:

Static Analysis Agent — Type checking, linting
Security Agent — Vulnerability scanning, dependency audit
Test Agent — Runs tests, measures coverage
Performance Agent — Benchmarks critical paths
Documentation Agent — Updates relevant docs

Results aggregated in a unified PR comment with severity-stratified issues.

Scenario 2: Feature Implementation Workflow

Multi-agent system collaborates on feature development:

Requirements Agent — Clarifies specifications
Architecture Agent — Designs system approach
Implementation Agent — Generates code
Testing Agent — Creates comprehensive tests
Documentation Agent — Writes API docs and guides

Output: Complete, tested, documented feature ready for review.

Scenario 3: Infrastructure Management

Multi-agent system manages cloud infrastructure:

Infrastructure Agent — Defines IaC
Security Agent — Validates compliance
Cost Agent — Analyzes budget impact
Scaling Agent — Ensures capacity planning
Monitoring Agent — Configures observability

Result: Secure, cost-optimized, observable infrastructure deployment.

Monitoring and Observability

// Comprehensive multi-agent observability
export class AgentMonitoring {
  async trackExecution(orchestration: Orchestration) {
    const metrics = {
      totalAgents: orchestration.agents.length,
      parallelAgents: orchestration.parallelCount,
      totalDuration: orchestration.duration,
      agentDurations: orchestration.agents.map(a => ({
        agent: a.name,
        duration: a.executionTime,
        success: a.succeeded
      })),
      failures: orchestration.agents.filter(a => !a.succeeded),
      criticalPath: this.identifyCriticalPath(orchestration),
      efficiency: (orchestration.optimalTime / orchestration.actualTime) * 100
    };
 
    // Send to monitoring backend
    await this.sendMetrics(metrics);
 
    // Alert on anomalies
    if (metrics.failures.length > 0) {
      await this.alertOnFailure(metrics);
    }
 
    return metrics;
  }
}

Deciding What to Delegate — and What to Keep

Even when you know the orchestration patterns, the first thing you hesitate over is whether a task should go to an agent at all. Leave that vague and only turn up parallelism, and review cost overtakes generation cost.

The line I use in practice comes down to three axes.

Axis	Good to delegate	Keep in hand
Verification cost	Correctness is machine-checkable (tests, types, schema)	Judging correctness needs context or taste
Reversibility of failure	Redo is cheap and impact is contained	Involves irreversible actions such as billing, deletion, or publish settings
Repetition	The same shape of work recurs	One-off, with premises that shift each time

In app operations, first-pass triage of user reviews or scaffolding test code is something I delegate without hesitation. Price changes or the final wording of a store listing, I keep. The former is cheap to walk back if wrong; the latter ties directly to revenue and trust, and the cost of undoing it spikes.

For tasks you are unsure about, the safe default is "agent proposes, human confirms." Antigravity's plan mode fits this middle ground well: a human approves the plan before execution, putting a gate in front of low-reversibility operations.

// Put an approval gate in front of irreversible operations
{
  "agents": {
    "billing": {
      "role": "subscription-manager",
      "requiresApproval": true,      // billing always needs human sign-off
      "context": "billing-scope-only"
    }
  }
}

The line is not drawn once and left alone. As agents grow more accurate, shift work toward delegation; when something goes wrong, pull it back. Keeping that range of motion was the surest way I found to avoid a blowup.

Designing Cost and Choosing a Degree of Parallelism

Parallel agents grow cost in parallel the moment they start. Run them without designing this, and the end-of-month bill stops you in your tracks.

Given today's pricing, the starting point is your ceiling. Compared with AI Pro, AI Ultra ($100/month) sets Antigravity usage limits about five times higher. That ceiling starts to bite when you continuously run token-heavy agents in parallel — visual regression tests, multimodal evaluation. If your work is mostly short classification or formatting, Pro's allowance is plenty.

When choosing parallelism, I cap on "outputs I can actually verify," not "agents running at once." Run five in parallel but verify only two per hour, and the other three outputs pile up while cost arrives first. Practically, throttle generation parallelism to your verification throughput.

At minimum, watch these three signals.

Signal	Why watch it	Sign of trouble
Tokens per task	Pinpoints the main cost driver	One agent's figures jump an order of magnitude
Retry rate	Early detection of failure loops	Does not converge even with exponential backoff
Pending-approval backlog	Tells you if parallelism is excessive	The queue grows monotonically

It is not far from watching AdMob eCPM by country and time of day back in my app days. Look only at the overall average and local anomalies dissolve into it. In agent operations too, decomposing which agent is spiking rather than the average token count gets you to the cost driver fastest.

Cost drops more by speeding up verification than generation. The more you widen the area where tests and types decide correctness automatically, the less human approval waits, and the more safely you can raise parallelism. That was the quiet but effective move for running multi-agent work in the black as a solo developer.

Wrapping up

What trips up production multi-agent work is usually not the orchestration pattern itself but everything around it — where you draw the delegation line, and how you design cost. Patterns are only a starting point.

Start by picking one reversible, easy-to-verify task and delegating it as "agent proposes, human confirms." Measure verification throughput and the token breakdown there, and you will see which pattern to expand into next, and at what degree of parallelism.

I am still searching for the right line myself. I would be glad to keep refining it together, comparing notes from real operation. Thank you for reading.

Thank You for Reading

Antigravity Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.