Coordination Strategies

import { Cogitator, Agent, tool } from '@cogitator-ai/core';
import { swarm } from '@cogitator-ai/swarms';

const team = swarm('dev-team')
  .strategy('hierarchical')
  .supervisor(
    new Agent({
      name: 'tech-lead',
      model: 'openai/gpt-4o',
      instructions: 'Break down tasks and delegate to your team members.',
    })
  )
  .workers([
    new Agent({ name: 'frontend-dev', instructions: 'Build UI components.' }),
    new Agent({ name: 'backend-dev', instructions: 'Build API endpoints.' }),
  ])
  .hierarchical({
    maxDelegationDepth: 3,
    workerCommunication: false,
    routeThrough: 'supervisor',
    visibility: 'full',
  })
  .build(cogitator);

const pool = swarm('support-pool')
  .strategy('round-robin')
  .agents([
    new Agent({ name: 'support-1', instructions: 'Handle customer tickets.' }),
    new Agent({ name: 'support-2', instructions: 'Handle customer tickets.' }),
    new Agent({ name: 'support-3', instructions: 'Handle customer tickets.' }),
  ])
  .roundRobin({
    sticky: true,
    stickyKey: (input) => extractTicketId(input),
    rotation: 'sequential',
  })
  .build(cogitator);

const reviewBoard = swarm('review-board')
  .strategy('consensus')
  .agents([
    new Agent({ name: 'security-reviewer', instructions: 'Focus on security issues.' }),
    new Agent({ name: 'perf-reviewer', instructions: 'Focus on performance.' }),
    new Agent({ name: 'quality-reviewer', instructions: 'Focus on code quality.' }),
  ])
  .consensus({
    threshold: 0.66,
    maxRounds: 3,
    resolution: 'majority',
    onNoConsensus: 'supervisor-decides',
  })
  .build(cogitator);

const result = await reviewBoard.run({ input: 'Should we merge this PR?' });

const expertPool = swarm('expert-pool')
  .strategy('auction')
  .agents([
    new Agent({
      name: 'python-expert',
      instructions: 'Python and data science specialist.',
      metadata: { expertise: ['python', 'pandas', 'ml'] },
    }),
    new Agent({
      name: 'typescript-expert',
      instructions: 'TypeScript and Node.js specialist.',
      metadata: { expertise: ['typescript', 'node', 'react'] },
    }),
  ])
  .auction({
    bidding: 'capability-match',
    selection: 'highest-bid',
    minBid: 0.3,
  })
  .build(cogitator);

const contentPipeline = swarm('content-pipeline')
  .strategy('pipeline')
  .pipeline({
    stages: [
      { name: 'research', agent: researcherAgent },
      { name: 'draft', agent: writerAgent },
      { name: 'review', agent: reviewerAgent, gate: true },
      { name: 'polish', agent: editorAgent },
    ],
    gates: {
      review: {
        condition: (output) => !output.includes('NEEDS_REVISION'),
        onFail: 'retry-previous',
        maxRetries: 3,
      },
    },
    stageInput: (prevOutput, stage, ctx) => {
      return `Previous output:\n${prevOutput}\n\nOriginal request: ${ctx.input}`;
    },
  })
  .build(cogitator);

const debateTeam = swarm('risk-assessment')
  .strategy('debate')
  .agents([
    new Agent({
      name: 'advocate',
      instructions: 'Argue IN FAVOR.',
      metadata: { role: 'advocate' },
    }),
    new Agent({ name: 'critic', instructions: 'Argue AGAINST.', metadata: { role: 'critic' } }),
  ])
  .moderator(
    new Agent({
      name: 'moderator',
      model: 'openai/gpt-4o',
      instructions: 'Synthesize both sides into a balanced recommendation.',
    })
  )
  .debate({ rounds: 3, format: 'structured' })
  .build(cogitator);

const dealTeam = swarm('contract-negotiation')
  .strategy('negotiation')
  .agents([
    new Agent({ name: 'buyer', instructions: 'Negotiate the best deal for the buyer.' }),
    new Agent({ name: 'seller', instructions: 'Negotiate the best deal for the seller.' }),
  ])
  .build(cogitator);