gemini-flow

Coordinates 96+ specialized agents across 23 functional categories using Byzantine consensus mechanisms and adaptive coordination patterns. The system implements hierarchical consensus for core development agents, mesh-based coordination for GitHub integration, and gossip protocols for distributed state synchronization. Agents communicate through dual-protocol support (A2A + MCP) with sub-millisecond coordination latency, enabling fault-tolerant multi-agent workflows where individual agent failures don't cascade.

Provides a single unified API gateway that routes requests across 8 Google AI services (Veo3, Imagen4, Lyria, Gemini variants, and others) through an intelligent ModelRouter that selects models based on latency, cost, and quality metrics. The UnifiedAPI component implements latency-based routing, cost-optimized selection, and quality-aware model picking using real-time service health monitoring and adaptive request dispatching. Abstracts away service-specific API differences through standardized adapter interfaces.

Provides command-line interface for defining, configuring, and executing agent workflows without code. The CLI accepts task specifications in natural language or structured format, maps them to appropriate agent swarms, and executes workflows with real-time progress reporting. Supports interactive mode for iterative task refinement, batch mode for scripted workflows, and configuration files for reproducible executions. CLI integrates with the Gemini CLI ecosystem, enabling seamless integration with Google Cloud tooling. Outputs execution logs, performance metrics, and results in structured formats (JSON, YAML).

Enables code-generation agents (coder, reviewer agents) to understand and generate code with awareness of existing codebase structure, dependencies, and patterns. The system indexes the codebase (file structure, imports, function signatures, type definitions) to provide agents with semantic context. Agents can query the index to understand existing code patterns, avoid duplicating functionality, and generate code consistent with project conventions. Supports multiple languages through tree-sitter AST parsing (40+ languages). Generated code is validated against existing patterns and type signatures before integration.

Implements code review workflows using Byzantine consensus among multiple reviewer agents (code-review-swarm) to reach agreement on code quality, security, and style compliance. Reviewer agents analyze code changes, identify issues, and vote on approval. Byzantine consensus ensures that malicious or faulty reviewers cannot block legitimate changes or approve problematic code. Consensus results include detailed review comments, issue categorization (critical, warning, info), and approval rationale. Integrates with GitHub to post review comments and manage PR approval status.

Monitors agent performance metrics (latency, throughput, error rates, resource usage) and adaptively allocates computational resources based on observed performance. The system tracks per-agent metrics, identifies bottlenecks, and reallocates resources (CPU, memory, API quota) to optimize overall system performance. Implements adaptive throttling to prevent resource exhaustion and graceful degradation when resources are constrained. Metrics are exposed through monitoring APIs and integrated with external monitoring systems (Prometheus, Datadog). Enables cost optimization by identifying underutilized agents and reallocating their resources.

Implements bidirectional communication between agents using both Agent-to-Agent (A2A) protocol for direct peer coordination and Model Context Protocol (MCP) for standardized tool/resource access. The Protocol Layer bridges these protocols, translating between A2A message formats and MCP server interfaces, enabling agents to communicate directly with each other while also accessing external tools and resources through MCP. Supports streaming responses and real-time message delivery with sub-millisecond latency.

Provides 96+ pre-configured specialized agents organized across 23 functional categories including core-development (coder, planner, researcher, reviewer, tester), consensus-systems (Byzantine fault-tolerant, Raft, gossip protocol agents), GitHub integration (PR manager, code-review swarm, release manager), security (zero-trust architect, encryption specialist, compliance auditor), and others. Each agent has predefined capabilities, coordination patterns, and role-specific prompts. Agents are defined in agent-definitions.ts with hierarchical consensus patterns for core agents and adaptive swarm patterns for specialized domains.

Provides 13 specialized agents for GitHub integration (PR manager, code-review swarm, release manager) that coordinate through adaptive swarm patterns to automate pull request management, code review, and release workflows. Agents can read repository state, create/update PRs, manage issues, trigger CI/CD pipelines, and coordinate releases through GitHub API integration. The system maintains awareness of repository structure, branch state, and CI/CD status, enabling agents to make context-aware decisions about code changes and releases.

Implements streaming response infrastructure that delivers model outputs in real-time chunks rather than waiting for complete responses. The streaming system handles token-by-token delivery from Google AI services, manages backpressure when clients consume slower than tokens arrive, and supports cancellation of in-flight streams. Streaming types are defined in src/types/streaming.ts with support for text, image, and multi-modal streaming. Enables responsive user experiences and reduces perceived latency for long-running model operations.

Implements zero-trust security model through specialized security agents (zero-trust-architect, encryption-specialist-advanced, compliance-auditor) that enforce authentication/authorization on every request, encrypt sensitive data in transit and at rest, and audit all operations. The security framework validates agent identities, enforces least-privilege access, and maintains compliance audit logs. Agents coordinate through zero-trust coordination patterns to ensure no implicit trust between components. Supports encryption of API keys, agent state, and inter-agent messages.

Dynamically selects optimal coordination patterns (hierarchical consensus for core agents, mesh-based for GitHub integration, gossip protocols for distributed state) based on task characteristics, agent count, and network conditions. The adaptive-coordinator agent monitors coordination performance and switches patterns if latency or consensus time degrades. Implements three primary coordination patterns: hierarchical-coordinator (for sequential decision-making), mesh-coordinator (for peer-to-peer collaboration), and adaptive-coordinator (for dynamic pattern switching). Coordination pattern selection is transparent to agents; they communicate through unified interfaces regardless of underlying pattern.

Orchestrates complex workflows spanning multiple modalities through unified service routing. Integrates Google's multi-modal services: Gemini for text/vision, Veo3 for video generation, Imagen4 for image generation, and Lyria for music/audio. The system maintains modality-aware context, enabling agents to reason about multi-modal data and coordinate transformations between modalities (e.g., text description → image → video). Streaming support enables real-time delivery of generated images, videos, and audio. Agents can compose workflows that mix text analysis, image generation, video creation, and audio synthesis.

Implements adapter pattern to abstract differences between heterogeneous Google AI services through unified interfaces. Each service (Gemini, Veo3, Imagen4, Lyria, etc.) has a dedicated adapter (src/adapters/deepmind-adapter.ts, etc.) that translates between unified API contracts and service-specific APIs. AdapterManager handles adapter lifecycle (initialization, health monitoring, graceful degradation). Adapters expose consistent request/response formats, error handling, and streaming interfaces regardless of underlying service differences. Enables adding new services by implementing new adapters without modifying orchestration logic.