// Multi-stage pipeline with model selection
const developmentPipeline = async (featureRequest: string) => {
  // Stage 1: Fast ideation with Flash (200ms)
  const initialConcept = await antigravity.ask({
    model: 'gemini-3-flash',
    prompt: `Generate React component skeleton for: ${featureRequest}`,
    temperature: 0.7,
  });
 
  // Stage 2: Deep optimization with Pro (1-2s)
  const optimized = await antigravity.ask({
    model: 'gemini-3-pro',
    prompt: `Optimize this component for:
      - Type safety (TypeScript)
      - Performance (React.memo, useMemo, lazy loading)
      - Accessibility (WCAG 2.1 AAA)
      - Testability
 
      Current implementation:
      ${initialConcept.text}`,
    temperature: 0.3,
    extendedThinking: true,
  });
 
  // Stage 3: Quality review with Claude (1s)
  const review = await antigravity.ask({
    model: 'claude-sonnet-4.5',
    prompt: `Comprehensive code review covering:
      - Maintainability and code clarity
      - Security vulnerabilities
      - Performance implications
      - Best practice compliance
 
      ${optimized.text}`,
    temperature: 0.2,
  });
 
  return { initialConcept, optimized, review };
};
 
// Usage
const result = await developmentPipeline('User authentication form');

// Algorithm optimization with reasoning transparency
const algorithmOptimization = async () => {
  const response = await antigravity.ask({
    model: 'gemini-3-pro',
    prompt: `
    Compare three approaches for finding two numbers in a sorted array that sum to target:
    1. Brute force O(n²)
    2. Hash map O(n)
    3. Two-pointer O(n)
 
    For a dataset of 1M integers, analyze:
    - Time complexity
    - Space complexity
    - Memory access patterns
    - Cache efficiency
    - Parallelization potential
    `,
    extendedThinking: true,
    thinkingBudget: 15000, // Token budget for internal reasoning
  });
 
  // Response includes detailed step-by-step analysis
  // with explicit reasoning and tradeoff analysis
};

// Autonomous agent with tool access
const codeQualityAgent = new AntigravityAgent({
  model: 'gemini-3-pro',
  systemPrompt: `
    You are a code quality expert. Analyze code for security,
    performance, maintainability, and best practices.
    Use available tools to gather evidence and make recommendations.
  `,
  tools: [
    {
      name: 'scan_codebase',
      description: 'Analyze entire codebase for patterns and issues',
      parameters: { path: 'string', language: 'string' }
    },
    {
      name: 'check_dependencies',
      description: 'Check npm/pip packages for known vulnerabilities',
      parameters: { manifestFile: 'string' }
    },
    {
      name: 'profile_performance',
      description: 'Run performance profiling on specified function',
      parameters: { functionPath: 'string' }
    },
    {
      name: 'run_security_scan',
      description: 'SAST and dependency security check',
      parameters: { fullScan: 'boolean' }
    }
  ]
});
 
// Execute with natural language
const analysis = await codeQualityAgent.execute(
  'Perform comprehensive quality audit on our React application'
);
 
// Agent automatically:
// 1. Scans codebase for antipatterns
// 2. Checks dependencies for CVEs
// 3. Profiles performance bottlenecks
// 4. Runs SAST security scanning
// 5. Synthesizes findings into prioritized report

// Analyze UI screenshots for accessibility issues
const accessibilityAudit = async (screenshotUrl: string) => {
  const response = await antigravity.ask({
    model: 'gemini-3-pro',
    prompt: `
    Audit this UI screenshot for accessibility compliance:
    - WCAG 2.1 Level AAA conformance
    - Color contrast ratios
    - Focus indicators
    - Keyboard navigation
    - Screen reader compatibility
    - Font sizing and readability
    `,
    images: [screenshotUrl],
  });
 
  return response; // Detailed accessibility report with citations
};

const testSuiteGenerator = new AntigravityAgent({
  model: 'gemini-3-pro',
  systemPrompt: `
    You are a TDD expert. Generate comprehensive test suites covering:
    - Happy path (normal operation)
    - Edge cases and boundary conditions
    - Error scenarios and exception handling
    - Performance and load testing
    - Integration points
 
    Use established patterns and best practices.
    Aim for >90% code coverage.
  `,
  tools: [
    {
      name: 'read_source',
      description: 'Load source code for analysis'
    },
    {
      name: 'identify_branches',
      description: 'Analyze control flow to identify all test paths'
    },
    {
      name: 'generate_cases',
      description: 'Create test case specifications'
    },
    {
      name: 'write_tests',
      description: 'Generate test code in target framework'
    },
    {
      name: 'execute_tests',
      description: 'Run tests and report coverage'
    }
  ]
});
 
// Execute end-to-end
const testGeneration = await testSuiteGenerator.execute(
  'Generate comprehensive test suite for src/utils/dateFormatter.ts'
);
 
// Agent handles entire workflow automatically:
// 1. Parse function signature and logic
// 2. Identify all decision branches
// 3. Generate 25+ test cases
// 4. Create test file with setUp/tearDown
// 5. Execute tests and report coverage
// 6. Suggest additional edge cases if coverage <90%

const auditAgent = new AntigravityAgent({
  model: 'gemini-3-pro',
  systemPrompt: `
    Conduct enterprise-grade code audits covering:
    - Security vulnerabilities (OWASP Top 10)
    - Performance bottlenecks and optimization opportunities
    - Maintainability metrics and technical debt
    - Best practice violations
    - Design pattern opportunities
 
    Prioritize issues by severity and impact.
    Provide actionable remediation steps.
  `,
  tools: [
    { name: 'ast_analysis', description: 'Parse and analyze code structure' },
    { name: 'dependency_scan', description: 'Vulnerability check on packages' },
    { name: 'performance_profile', description: 'CPU/memory profiling' },
    { name: 'security_check', description: 'SAST and pattern matching' },
    { name: 'generate_report', description: 'Create prioritized audit report' }
  ]
});
 
// Execute comprehensive audit
const audit = await auditAgent.execute(
  'Full code quality audit on entire backend service'
);
 
// Output structure:
{
  summary: {
    riskLevel: 'HIGH',
    criticalIssues: 4,
    majorIssues: 18,
    minorIssues: 31
  },
  issues: [
    {
      id: 'SEC-001',
      severity: 'CRITICAL',
      category: 'SQL Injection',
      file: 'src/db/queries.js',
      line: 142,
      description: 'Dynamic query construction vulnerable to injection',
      recommendation: 'Use parameterized queries with prepared statements',
      estimatedFix: '30 minutes'
    }
  ],
  metrics: {
    maintainabilityIndex: 72,
    cyclomaticComplexity: 14,
    linesOfCode: 12450,
    testCoverage: 68
  }
}

const deploymentOrchestrator = new AntigravityAgent({
  model: 'gemini-3-pro',
  systemPrompt: `
    Orchestrate safe, validated deployments following:
    - Pre-deployment validation (tests, security, performance)
    - Staged rollout (staging → canary → production)
    - Health checks and monitoring
    - Rollback procedures on failure
 
    Maximize safety and minimize downtime.
  `,
  tools: [
    { name: 'git_check', description: 'Verify git status and commits' },
    { name: 'run_tests', description: 'Execute full test suite' },
    { name: 'security_scan', description: 'Run SAST and dependency checks' },
    { name: 'build', description: 'Build application artifacts' },
    { name: 'deploy_staging', description: 'Deploy to staging environment' },
    { name: 'smoke_tests', description: 'Run critical path tests' },
    { name: 'deploy_canary', description: 'Deploy to 5% of production traffic' },
    { name: 'monitor_metrics', description: 'Watch error rate, latency, etc' },
    { name: 'deploy_full', description: 'Deploy to 100% of production' },
    { name: 'notify_team', description: 'Send Slack/email notifications' },
    { name: 'rollback', description: 'Revert to previous stable version' }
  ]
});
 
// Autonomous deployment with safety checks
const deployment = await deploymentOrchestrator.execute(
  'Deploy v3.2.1 to production with full validation and canary rollout'
);
 
// Agent performs complex orchestration:
// 1. Verify no uncommitted changes
// 2. Run 400+ unit + integration tests
// 3. Security scanning (SAST + SCA)
// 4. Build optimized artifacts
// 5. Deploy to staging, run smoke tests
// 6. Canary deploy to 5% production traffic
// 7. Monitor for 10 minutes (error rate, latency, exceptions)
// 8. Auto-rollback if anomalies detected
// 9. Full production deploy if metrics green
// 10. Notify team with deployment summary

const emailTriageAgent = new AntigravityAgent({
  model: 'gemini-3-pro',
  tools: [
    { name: 'list_unread', description: 'Get unread emails' },
    { name: 'classify', description: 'Categorize by topic/priority' },
    { name: 'summarize', description: 'Create email thread summaries' },
    { name: 'draft_reply', description: 'Generate response suggestions' },
    { name: 'create_task', description: 'Create action items in Tasks' },
    { name: 'send_email', description: 'Send outgoing emails' }
  ]
});
 
// Daily email triage
const triage = await emailTriageAgent.execute(
  'Process unread emails: categorize, summarize long threads, draft replies, create action items'
);

const dataAnalysisAgent = new AntigravityAgent({
  model: 'gemini-3-pro',
  tools: [
    { name: 'read_sheet', description: 'Load Google Sheet data' },
    { name: 'query_data', description: 'SQL-like querying' },
    { name: 'statistical_analysis', description: 'Calculate metrics' },
    { name: 'create_charts', description: 'Generate visualizations' },
    { name: 'forecast', description: 'Time series prediction' },
    { name: 'write_doc', description: 'Output analysis to Google Doc' }
  ]
});
 
// Automated business intelligence
const bi = await dataAnalysisAgent.execute(
  'Analyze 2025 sales data: trends by region/product, anomaly detection, forecast Q2, write report'
);

const calendarOptimizer = new AntigravityAgent({
  model: 'gemini-3-pro',
  tools: [
    { name: 'read_calendar', description: 'Get schedule and events' },
    { name: 'analyze_patterns', description: 'Identify time allocation' },
    { name: 'find_slots', description: 'Find available time windows' },
    { name: 'suggest_consolidation', description: 'Recommend meeting mergers' },
    { name: 'create_focus_blocks', description: 'Schedule deep work time' },
    { name: 'optimize_schedule', description: 'Rebalance calendar' }
  ]
});
 
// Optimize team schedule
const optimization = await calendarOptimizer.execute(
  'Analyze team calendar: identify bottlenecks, suggest meeting consolidation, create daily focus blocks'
);

class ProjectManagementSystem {
  async executeFullCycle(projectName: string, scope: string) {
    // Phase 1: Planning (Pro - thorough design)
    const plan = await this.planProject(projectName, scope);
 
    // Phase 2: Daily tracking (Flash - fast updates)
    const tracking = await this.setupTracking(plan);
 
    // Phase 3: Risk management (Pro - complex analysis)
    const riskModel = await this.analyzeRisks(plan);
 
    // Phase 4: Documentation (Claude - high-quality writing)
    const documentation = await this.generateDocs(plan, riskModel);
 
    // Phase 5: Team collaboration (Google Workspace)
    const collaboration = await this.setupWorkspace(plan, documentation);
 
    return { plan, tracking, riskModel, documentation, collaboration };
  }
 
  async planProject(name: string, scope: string) {
    return await antigravity.ask({
      model: 'gemini-3-pro',
      prompt: `Detailed project plan for "${name}":
        ${scope}
 
        Deliverables:
        - Scope breakdown with WBS
        - 8-week milestones
        - Resource requirements
        - Risk matrix
        - Success metrics
        - Dependency map`,
      extendedThinking: true,
    });
  }
 
  async setupTracking(plan: any) {
    return await antigravity.ask({
      model: 'gemini-3-flash',
      prompt: `Daily tracking templates for this plan:\n${plan}`,
      temperature: 0.6,
    });
  }
 
  async analyzeRisks(plan: any) {
    const analysis = await antigravity.ask({
      model: 'gemini-3-pro',
      prompt: `Comprehensive risk analysis for:\n${plan}`,
    });
 
    const mitigations = await antigravity.ask({
      model: 'gemini-3-pro',
      prompt: `Mitigation strategies for identified risks:\n${analysis}`,
    });
 
    return { analysis, mitigations };
  }
 
  async generateDocs(plan: any, risks: any) {
    return await antigravity.ask({
      model: 'claude-sonnet-4.5',
      prompt: `Write executive summary and project charter:
        Plan: ${plan}
        Risks & Mitigations: ${risks}`,
    });
  }
 
  async setupWorkspace(plan: any, docs: any) {
    // Create shared Google Drive folder structure
    // Create Google Docs for documentation
    // Set up Google Sheets for tracking
    // Create Calendar events for milestones
    // Set up Gmail labels and filters
  }
}

// Smart model routing based on request complexity
const intelligentRouter = {
  estimate: (prompt: string): 'flash' | 'pro' | 'sonnet' => {
    // Flash: <100 words, simple requests
    if (prompt.length < 100 && !prompt.includes('analyze'))
      return 'flash';
 
    // Pro: Complex reasoning, 500+ words
    if (prompt.length > 500 || prompt.includes('architect'))
      return 'pro';
 
    // Sonnet: Writing-focused
    if (prompt.includes('document') || prompt.includes('report'))
      return 'sonnet';
 
    return 'flash'; // Default to cheapest
  },
 
  execute: async (prompt: string) => {
    const model = this.estimate(prompt);
    return await antigravity.ask({ model, prompt });
  },
};
 
// Typical monthly costs with hybrid strategy:
// - Flash: 70% of requests → ~$20
// - Pro: 20% of requests → ~$40
// - Sonnet: 10% of requests → ~$15
// Total: ~$75/month (vs $200+ single-model)