Skip to main content
Glama
emmron
by emmron

mcp__gemini__team_orchestrator

Coordinate multi-developer workflows with shared AI contexts, enabling seamless team collaboration across roles like frontend, backend, and devops for Agile projects on the Gemini MCP server.

Instructions

Multi-developer collaboration with shared AI contexts and workflow coordination

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
coordination_levelNoCoordination levelhigh
projectYesProject name or description
team_membersNoTeam member roles
workflow_typeNoWorkflow typeagile

Implementation Reference

  • The handler function for the mcp__gemini__team_orchestrator tool. It orchestrates team collaboration by generating an AI-powered orchestration plan, role-specific guidelines, stores the configuration, and returns a formatted response.
        handler: async (args) => {
          const { project, team_members = ['frontend', 'backend', 'devops'], workflow_type = 'agile', coordination_level = 'high' } = args;
          validateString(project, 'project');
          
          const timer = performanceMonitor.startTimer('team_orchestrator');
          
          const orchestrationPrompt = `Design team orchestration strategy for multi-developer collaboration:
    
    **Project**: ${project}
    **Team Roles**: ${team_members.join(', ')}
    **Workflow**: ${workflow_type}
    **Coordination Level**: ${coordination_level}
    
    Create comprehensive collaboration framework:
    
    1. **Team Structure & Responsibilities**
       ${team_members.map(role => `- **${role}**: Specific responsibilities and deliverables`).join('\n   ')}
    
    2. **Workflow Coordination**
       - Task distribution strategy
       - Dependency management
       - Communication protocols
       - Progress tracking methods
    
    3. **Shared Context Management**
       - Context sharing between team members
       - Knowledge transfer protocols
       - Decision documentation
       - Conflict resolution procedures
    
    4. **AI-Assisted Coordination**
       - AI context sharing between developers
       - Automated workflow suggestions
       - Cross-team knowledge synthesis
       - Intelligent task routing
    
    5. **Quality Assurance Integration**
       - Code review coordination
       - Testing responsibilities
       - Quality gates and standards
       - Performance monitoring
    
    6. **Delivery Pipeline**
       - Sprint planning and execution
       - Release coordination
       - Risk management
       - Success metrics
    
    Provide specific protocols and tools for each aspect.`;
    
          const orchestrationPlan = await aiClient.call(orchestrationPrompt, 'main', { 
            complexity: 'complex',
            maxTokens: 4000 
          });
          
          // Generate team-specific guidelines
          const guidelines = {};
          for (const role of team_members) {
            const rolePrompt = `Create specific guidelines for ${role} developer in this team setup:
    
    Project: ${project}
    Team Structure: ${team_members.join(', ')}
    
    Provide for ${role}:
    1. **Daily Responsibilities**
    2. **Collaboration Touchpoints**
    3. **AI Context Usage Guidelines**
    4. **Quality Standards**
    5. **Communication Protocols**
    
    Be specific and actionable.`;
    
            guidelines[role] = await aiClient.call(rolePrompt, 'main');
          }
          
          // Save team configuration
          const teamData = {
            id: Date.now().toString(),
            project,
            team_members,
            workflow_type,
            coordination_level,
            timestamp: new Date().toISOString(),
            orchestration_plan: orchestrationPlan,
            role_guidelines: guidelines
          };
          
          const storageData = await storage.read('team_orchestrations');
          if (!storageData.teams) storageData.teams = [];
          storageData.teams.push(teamData);
          
          await storage.write('team_orchestrations', storageData);
          
          timer.end();
          
          return `๐Ÿ‘ฅ **Team Orchestration Plan** (${workflow_type})
    
    **Project**: ${project}
    **Team**: ${team_members.join(', ')}
    **Coordination**: ${coordination_level}
    
    ---
    
    ๐ŸŽฏ **Orchestration Strategy**
    
    ${orchestrationPlan}
    
    ---
    
    ๐Ÿ“‹ **Role-Specific Guidelines**
    
    ${Object.entries(guidelines).map(([role, guide]) => `### ${role.toUpperCase()} DEVELOPER\n${guide}`).join('\n\n---\n\n')}
    
    **Team Configuration ID**: ${teamData.id} (saved for project tracking)`;
        }
  • Input schema defining parameters for the team_orchestrator tool including project, team members, workflow type, and coordination level.
    parameters: {
      project: { type: 'string', description: 'Project name or description', required: true },
      team_members: { type: 'array', description: 'Team member roles', default: ['frontend', 'backend', 'devops'] },
      workflow_type: { type: 'string', description: 'Workflow type', default: 'agile' },
      coordination_level: { type: 'string', description: 'Coordination level', default: 'high' }
    },
  • Registration of the mcp__gemini__team_orchestrator tool within the businessTools object export.
      'mcp__gemini__team_orchestrator': {
        description: 'Multi-developer collaboration with shared AI contexts and workflow coordination',
        parameters: {
          project: { type: 'string', description: 'Project name or description', required: true },
          team_members: { type: 'array', description: 'Team member roles', default: ['frontend', 'backend', 'devops'] },
          workflow_type: { type: 'string', description: 'Workflow type', default: 'agile' },
          coordination_level: { type: 'string', description: 'Coordination level', default: 'high' }
        },
        handler: async (args) => {
          const { project, team_members = ['frontend', 'backend', 'devops'], workflow_type = 'agile', coordination_level = 'high' } = args;
          validateString(project, 'project');
          
          const timer = performanceMonitor.startTimer('team_orchestrator');
          
          const orchestrationPrompt = `Design team orchestration strategy for multi-developer collaboration:
    
    **Project**: ${project}
    **Team Roles**: ${team_members.join(', ')}
    **Workflow**: ${workflow_type}
    **Coordination Level**: ${coordination_level}
    
    Create comprehensive collaboration framework:
    
    1. **Team Structure & Responsibilities**
       ${team_members.map(role => `- **${role}**: Specific responsibilities and deliverables`).join('\n   ')}
    
    2. **Workflow Coordination**
       - Task distribution strategy
       - Dependency management
       - Communication protocols
       - Progress tracking methods
    
    3. **Shared Context Management**
       - Context sharing between team members
       - Knowledge transfer protocols
       - Decision documentation
       - Conflict resolution procedures
    
    4. **AI-Assisted Coordination**
       - AI context sharing between developers
       - Automated workflow suggestions
       - Cross-team knowledge synthesis
       - Intelligent task routing
    
    5. **Quality Assurance Integration**
       - Code review coordination
       - Testing responsibilities
       - Quality gates and standards
       - Performance monitoring
    
    6. **Delivery Pipeline**
       - Sprint planning and execution
       - Release coordination
       - Risk management
       - Success metrics
    
    Provide specific protocols and tools for each aspect.`;
    
          const orchestrationPlan = await aiClient.call(orchestrationPrompt, 'main', { 
            complexity: 'complex',
            maxTokens: 4000 
          });
          
          // Generate team-specific guidelines
          const guidelines = {};
          for (const role of team_members) {
            const rolePrompt = `Create specific guidelines for ${role} developer in this team setup:
    
    Project: ${project}
    Team Structure: ${team_members.join(', ')}
    
    Provide for ${role}:
    1. **Daily Responsibilities**
    2. **Collaboration Touchpoints**
    3. **AI Context Usage Guidelines**
    4. **Quality Standards**
    5. **Communication Protocols**
    
    Be specific and actionable.`;
    
            guidelines[role] = await aiClient.call(rolePrompt, 'main');
          }
          
          // Save team configuration
          const teamData = {
            id: Date.now().toString(),
            project,
            team_members,
            workflow_type,
            coordination_level,
            timestamp: new Date().toISOString(),
            orchestration_plan: orchestrationPlan,
            role_guidelines: guidelines
          };
          
          const storageData = await storage.read('team_orchestrations');
          if (!storageData.teams) storageData.teams = [];
          storageData.teams.push(teamData);
          
          await storage.write('team_orchestrations', storageData);
          
          timer.end();
          
          return `๐Ÿ‘ฅ **Team Orchestration Plan** (${workflow_type})
    
    **Project**: ${project}
    **Team**: ${team_members.join(', ')}
    **Coordination**: ${coordination_level}
    
    ---
    
    ๐ŸŽฏ **Orchestration Strategy**
    
    ${orchestrationPlan}
    
    ---
    
    ๐Ÿ“‹ **Role-Specific Guidelines**
    
    ${Object.entries(guidelines).map(([role, guide]) => `### ${role.toUpperCase()} DEVELOPER\n${guide}`).join('\n\n---\n\n')}
    
    **Team Configuration ID**: ${teamData.id} (saved for project tracking)`;
        }
      },
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'collaboration' and 'coordination' but doesn't explain what the tool actually doesโ€”whether it creates a session, manages tasks, or facilitates communication. Critical details like permissions, side effects, or output format are missing, leaving significant gaps for a tool with team coordination implications.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core idea without unnecessary words. It's appropriately sized for the tool's complexity, with no wasted phrases or redundancy, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of team coordination and the lack of annotations and output schema, the description is incomplete. It doesn't clarify the tool's behavior, expected outcomes, or how it integrates with sibling tools. For a multi-parameter tool with no structured output, more context on what the tool returns or how it operates is needed to be adequately helpful.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all parameters (coordination_level, project, team_members, workflow_type). The description adds no additional meaning beyond the schema, such as explaining how parameters interact or their impact on collaboration. With high schema coverage, the baseline is 3, as the description doesn't compensate but doesn't detract either.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Multi-developer collaboration with shared AI contexts and workflow coordination' states a general purpose but lacks specificity. It mentions collaboration and coordination but doesn't specify what action the tool performs (e.g., 'orchestrate,' 'initiate,' 'manage'). It distinguishes from siblings like 'ai_chat' or 'analyze_codebase' by focusing on team coordination rather than individual tasks, but the verb is vague.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives is provided. The description implies usage for team-based projects, but it doesn't specify scenarios, prerequisites, or exclusions. Without context on when to choose this over siblings like 'create_project_tasks' or 'planner_pro', the agent must infer based on general terms.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Related Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/emmron/gemini-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server