orchestration

type BaseOrchestrator ¶

type BaseOrchestrator struct {
	// contains filtered or unexported fields
}

BaseOrchestrator provides common functionality for orchestrators

func NewBaseOrchestrator(name, pattern string, runtime agent.Runtime) *BaseOrchestrator

func (b *BaseOrchestrator) Execute(ctx context.Context, input *agent.Message) (*agent.Message, error)

func (b *BaseOrchestrator) Name() string

func (b *BaseOrchestrator) Pattern() string

func (b *BaseOrchestrator) Ready() bool

func (b *BaseOrchestrator) Runtime() agent.Runtime

func (b *BaseOrchestrator) SetReady(ready bool)

func (b *BaseOrchestrator) Start(ctx context.Context) error

func (b *BaseOrchestrator) Stop(ctx context.Context) error

type ConversationTurn ¶ added in v0.4.0

type ConversationTurn struct {
	Query    string
	Response string
	Context  string
}

ConversationTurn represents a single turn in conversation history

type Ensemble ¶

type Ensemble struct {
	*BaseOrchestrator
	// contains filtered or unexported fields
}

Ensemble implements multi-model voting for improved accuracy. Multiple models generate outputs and vote on the best result. Provides 25-50% error reduction in high-stakes decisions.

Use cases: - Medical diagnosis - Financial forecasting - Content moderation - Critical decision-making

func NewContentModerationEnsemble(name string, runtime agent.Runtime, models []string) *Ensemble

func NewEnsemble(name string, runtime agent.Runtime, models []string, opts ...EnsembleOption) *Ensemble

func NewFinancialForecastEnsemble(name string, runtime agent.Runtime, models []string) *Ensemble

func NewMedicalDiagnosisEnsemble(name string, runtime agent.Runtime, models []string) *Ensemble

func (e *Ensemble) Execute(ctx context.Context, input *agent.Message) (*agent.Message, error)

type EnsembleOption ¶

type EnsembleOption func(*Ensemble)

EnsembleOption configures an Ensemble orchestrator

func WithAgreementThreshold(threshold float64) EnsembleOption

func WithVotingStrategy(strategy VotingStrategy) EnsembleOption

type HandoffInstruction ¶

type HandoffInstruction struct {
	TargetAgent string
	Context     string
	Reason      string
}

HandoffInstruction represents a handoff instruction from an agent

type Hierarchical ¶

type Hierarchical struct {
	*BaseOrchestrator
	// contains filtered or unexported fields
}

Hierarchical implements multi-level delegation pattern. Managers delegate to sub-managers who delegate to workers. Perfect for complex task decomposition and organizational hierarchies.

Use cases: - Enterprise workflows - Project management - Complex multi-step processes - Organizational hierarchies

func NewEnterpriseWorkflow(name string, runtime agent.Runtime, departments map[string][]string) *Hierarchical

func NewHierarchical(name string, runtime agent.Runtime, manager string, teams map[string][]string, opts ...HierarchicalOption) *Hierarchical

func NewProjectManager(name string, runtime agent.Runtime) *Hierarchical

func (h *Hierarchical) Execute(ctx context.Context, input *agent.Message) (*agent.Message, error)

type HierarchicalOption ¶

type HierarchicalOption func(*Hierarchical)

HierarchicalOption configures a Hierarchical orchestrator

func WithMaxDepth(depth int) HierarchicalOption

type Orchestrator ¶

type Orchestrator interface {
	// Name returns the orchestrator identifier
	Name() string

	// Pattern returns the pattern type (e.g., "parallel", "router", "rag")
	Pattern() string

	// Execute runs the orchestration pattern synchronously
	Execute(ctx context.Context, input *agent.Message) (*agent.Message, error)

	// Start runs the orchestration pattern asynchronously
	Start(ctx context.Context) error

	// Stop gracefully shuts down the orchestrator
	Stop(ctx context.Context) error

	// Ready returns true if the orchestrator is ready
	Ready() bool
}

Orchestrator defines the interface for agent orchestration patterns. All orchestration patterns implement this interface.

type Parallel ¶

type Parallel struct {
	*BaseOrchestrator
	// contains filtered or unexported fields
}

Parallel executes multiple agents concurrently and aggregates results. Provides 3-4× speedup for independent tasks compared to sequential execution.

Use cases: - Multi-source research - Batch processing - A/B testing - Independent data gathering

func NewParallel(name string, runtime agent.Runtime, agents []string, opts ...ParallelOption) *Parallel

func (p *Parallel) Execute(ctx context.Context, input *agent.Message) (*agent.Message, error)

type ParallelOption ¶

type ParallelOption func(*Parallel)

ParallelOption configures a Parallel orchestrator

func WithAggregateFunc(fn func(results map[string]*agent.Message) (*agent.Message, error)) ParallelOption

func WithFailFast(enabled bool) ParallelOption

type RAG ¶

type RAG struct {
	*BaseOrchestrator
	// contains filtered or unexported fields
}

RAG implements Retrieval-Augmented Generation pattern. Retrieves relevant documents from a vector store, then generates grounded answers. Most common enterprise pattern for chatbots and Q&A systems.

Use cases: - Enterprise chatbots - Documentation Q&A - Knowledge retrieval - Context-aware generation

func NewConversationalRAG(name string, runtime agent.Runtime, retriever, generator string, historyAgent string) *RAG

func NewHybridRAG(name string, runtime agent.Runtime, semanticRetriever, keywordRetriever, generator string) *RAG

func NewMultiQueryRAG(name string, runtime agent.Runtime, queryExpander, retriever, generator string) *RAG

func NewRAG(name string, runtime agent.Runtime, retriever, generator string, opts ...RAGOption) *RAG

func (r *RAG) Execute(ctx context.Context, input *agent.Message) (*agent.Message, error)

type RAGOption ¶

type RAGOption func(*RAG)

RAGOption configures a RAG orchestrator

func WithReranker(reranker string) RAGOption

func WithTopK(k int) RAGOption

type Reflection ¶

type Reflection struct {
	*BaseOrchestrator
	// contains filtered or unexported fields
}

Reflection implements iterative refinement with self-critique. Generator creates output, critic reviews it, generator refines. Provides 20-50% quality improvement through iterative refinement.

Use cases: - Code generation with review - Content creation with editing - Complex reasoning tasks - Quality assurance

func NewMultiCriticReflection(name string, runtime agent.Runtime, generator string, critics []string, maxIterations int) *Reflection

func NewReflection(name string, runtime agent.Runtime, generator, critic string, opts ...ReflectionOption) *Reflection

func NewSelfReflection(name string, runtime agent.Runtime, agent string, maxIterations int) *Reflection

func (r *Reflection) Execute(ctx context.Context, input *agent.Message) (*agent.Message, error)

type ReflectionOption ¶

type ReflectionOption func(*Reflection)

ReflectionOption configures a Reflection orchestrator

func WithImprovementThreshold(threshold float64) ReflectionOption

func WithMaxIterations(max int) ReflectionOption

type Router ¶

type Router struct {
	*BaseOrchestrator
	// contains filtered or unexported fields
}

Router routes requests to different agents based on classification. Provides 25-50% cost reduction by routing simple queries to cheaper models.

Use cases: - Cost optimization (simple → cheap, complex → expensive models) - Intent-based routing - Skill-based agent selection - Load balancing

func NewCostOptimizingRouter(name string, runtime agent.Runtime, classifier string) *Router

func NewIntentRouter(name string, runtime agent.Runtime, classifier string, intentMap map[string]string) *Router

func NewRouter(name string, runtime agent.Runtime, classifier string, routes map[string]string, opts ...RouterOption) *Router

func NewSkillRouter(name string, runtime agent.Runtime, classifier string, skillMap map[string]string) *Router

func (r *Router) Execute(ctx context.Context, input *agent.Message) (*agent.Message, error)

type RouterOption ¶

type RouterOption func(*Router)

RouterOption configures a Router orchestrator

func WithDefaultRoute(agent string) RouterOption

type Swarm ¶

type Swarm struct {
	*BaseOrchestrator
	// contains filtered or unexported fields
}

Swarm implements decentralized agent handoffs based on conversational context. Agents decide when to hand off to other agents dynamically. Popularized by OpenAI Swarm.

Use cases: - Customer service handoffs (general → billing → technical) - Adaptive routing based on conversation flow - Collaborative problem-solving

func NewSwarm(name string, runtime agent.Runtime, entryAgent string, agents []string, opts ...SwarmOption) *Swarm

func (s *Swarm) Execute(ctx context.Context, input *agent.Message) (*agent.Message, error)

type SwarmOption ¶

type SwarmOption func(*Swarm)

SwarmOption configures a Swarm orchestrator

func WithMaxHandoffs(max int) SwarmOption

type VotingStrategy ¶

type VotingStrategy string

VotingStrategy defines how ensemble votes are aggregated

const (
	VotingMajority   VotingStrategy = "majority"   // Simple majority vote
	VotingUnanimous  VotingStrategy = "unanimous"  // All must agree
	VotingWeighted   VotingStrategy = "weighted"   // Weighted by model confidence
	VotingConfidence VotingStrategy = "confidence" // Highest confidence wins
)