Enzu: Framework Multi-Agent em Go
teilomillet/enzu-go
Framework Go para sistemas multi-agent com hierarquia, paralelismo e tools extensíveis
Ver no GitHubFramework declarativo em Go para construir sistemas sofisticados com múltiplos agentes de IA. Permite colaboração entre LLMs através de organização hierárquica, execução paralela de tarefas e ferramentas extensíveis com gerenciamento de estado e comunicação estruturada.
Instalação
npx convez-ai teilomillet/enzu-go1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Sistemas de pesquisa distribuída com múltiplos agentes especializados
- Pipelines de análise de dados com processamento paralelo
- Automação complexa com coordenação entre agentes e fallback inteligente
Veredito

Enzu é uma escolha sólida para engenheiros que precisam orquestrar múltiplos agentes em Go com padrões claros de hierarquia e paralelismo. Maduro em arquitetura, exige expertise para extrair valor máximo das capacidades avançadas.
README
A tradução para o português deste README ainda está na fila.
Enzu: Multi-Agent Framework for AI Systems
Enzu is a declarative Go framework designed for building sophisticated multi-agent AI systems. It enables LLMs and AI agents to collaborate, execute parallel tasks, and leverage extensible tools while maintaining clear hierarchies and communication patterns.
🎯 Framework Capabilities
Agent System Architecture
- Hierarchical Agent Organization: Define agent roles, responsibilities, and relationships
- Dynamic Task Distribution: Automatically route tasks to specialized agents
- Parallel Processing: Execute multiple agent tasks concurrently
- State Management: Track and maintain agent states across interactions
Tool Integration System
- Declarative Tool Registry: Register and manage tools with clear interfaces
- Inheritance Patterns: Tools can be inherited and shared across agent hierarchies
- Thread-Safe Operations: Concurrent tool access with built-in safety mechanisms
- Custom Tool Creation: Extend functionality through a standardized tool interface
Execution Patterns
- Synergy-Based Collaboration: Group agents into task-focused collaborative units
- Context Propagation: Share context and state across agent boundaries
- Parallel Task Execution: Optimize performance through concurrent processing
- Error Recovery: Built-in retry mechanisms and error handling patterns
Communication Infrastructure
- HTTP Server Integration: Built-in REST API capabilities
- Structured Message Passing: Type-safe communication between agents
- Event System: Publish-subscribe patterns for agent coordination
- Logging System: Comprehensive tracing and debugging capabilities
🔧 Core Integration Patterns
1. Research and Analysis Pattern
// Pattern: Distributed Research System
type ResearchRequest struct {
Topic string `json:"topic"`
Subtopics []string `json:"subtopics,omitempty"`
MaxResults int `json:"max_results,omitempty"`
TimeoutSecs int `json:"timeout_secs,omitempty"`
}
// Create specialized research agents
researcher := enzu.NewAgent("Primary Researcher",
"Deep research and fact verification",
llm,
enzu.WithToolLists("ResearchTool"),
enzu.WithParallelExecution(true),
)
analyst := enzu.NewAgent("Data Analyst",
"Process and analyze research results",
llm,
enzu.WithToolLists("AnalysisTool"),
enzu.WithParallelExecution(true),
)
2. Self-Aware System Pattern
// Pattern: Self-Aware Interactive System
manager := enzu.NewSynergyManager("Self-Aware System", llm, logger)
// Define capability domains
researchSynergy := createDomainSynergy("Research", llm, logger)
analysisSynergy := createDomainSynergy("Analysis", llm, logger)
creativeSynergy := createDomainSynergy("Creative", llm, logger)
// Register domains
manager.AddSynergy(researchSynergy)
manager.AddSynergy(analysisSynergy)
manager.AddSynergy(creativeSynergy)
3. Tool Integration Pattern
// Pattern: Extensible Tool System
exaSearchOptions := tools.ExaSearchOptions{
NumResults: 5,
Type: "neural",
Contents: tools.Contents{
Text: true,
},
UseAutoprompt: true,
StartPublishedDate: "2023-01-01T00:00:00.000Z",
}
tools.RegisterTool("ResearchTool", exaSearchOptions)
4. API Integration Pattern
// Pattern: Multi-Agent API Server
type Server struct {
synergy *enzu.Synergy
logger *enzu.Logger
}
// Initialize server with parallel processing capabilities
func NewServer() (*Server, error) {
// Create research agents with specific roles
researchAgent1 := enzu.NewAgent("Research Agent 1",
"Agent specialized in AI research",
llm,
enzu.WithToolLists("ResearchTool"),
enzu.WithParallelExecution(true),
)
researchAgent2 := enzu.NewAgent("Research Agent 2",
"Agent specialized in startup research",
llm,
enzu.WithToolLists("ResearchTool"),
enzu.WithParallelExecution(true),
)
// Create parallel processing synergy
synergy := enzu.NewSynergy(
"Parallel AI Research",
llm,
enzu.WithAgents(researchAgent1, researchAgent2),
enzu.WithLogger(logger),
)
return &Server{synergy: synergy, logger: logger}, nil
}
// Handle parallel task execution
func (s *Server) handleExecute(w http.ResponseWriter, r *http.Request) {
var request struct {
Tasks []string `json:"tasks"`
}
// Distribute tasks among agents
agents := s.synergy.GetAgents()
for i, taskDescription := range request.Tasks {
agent := agents[i%len(agents)] // Round-robin distribution
tasks = append(tasks, enzu.NewTask(taskDescription, agent))
}
}
🚀 Capability Domains
1. Research & Information Retrieval
- Neural search integration (
ExaSearchtool) - Multi-agent research coordination
- Parallel information gathering
- Research result synthesis
2. Task Management & Execution
- Multi-agent task distribution
- Parallel task execution
- Progress tracking
- Result aggregation
3. Web Content Processing
- URL content fetching (
FetchURLtool) - HTML parsing and extraction
- CSS selector-based targeting
- Structured data collection
4. Synergy Management
- Multi-synergy orchestration
- Result synthesis across synergies
- Team-based agent organization
- Cross-team coordination
- Hierarchical task execution
5. Team Organization
- Role-specialized agents
- Team-based synergies
- Domain-specific agent groups
- Task-team alignment
6. API Integration & Scaling
-
Parallel Task Distribution
- Round-robin task assignment
- Load-balanced processing
- Concurrent execution
- Real-time response handling
-
HTTP Service Integration
- RESTful endpoints
- JSON request/response
- Error handling patterns
- Status monitoring
-
Multi-Agent Coordination
- Role-based agent assignment
- Task synchronization
- Result aggregation
- State management
📦 Installation
go get github.com/teilomillet/enzu
📚 Integration Resources
Core Documentation
/docs: Architecture and integration guides/docs/tutorials: Step-by-step implementation patterns/examples: Reference implementations and use cases
Example Implementations
- Research Assistant System (
examples/8_research_assistant_example.go) - Self-Aware System (
examples/7_manager_mode_example.go) - Parallel Processing System (
examples/4_parallel_example.go) - Tool Integration System (
examples/3_tools_example.go) - API Integration System (
examples/6_api_example.go)
Integration Patterns
-
HTTP API Integration
- REST endpoint creation
- Request/Response handling
- Timeout management
- Error recovery
- Round-robin task distribution
- Load balancing strategies
-
Tool Registry Integration
- Tool registration
- Capability inheritance
- Access control
- Resource management
-
Agent Collaboration
- Task distribution
- Result synthesis
- Context sharing
- Error handling