Multi-Agent Systems

from aakit import Agent

# Create specialized agents
researcher = Agent(
    name="researcher",
    instruction="You excel at finding and analyzing information",
    model="gpt-4",
    tools=[web_search, extract_data, analyze_trends]
)

writer = Agent(
    name="writer", 
    instruction="You create clear, engaging content",
    model="claude-3-opus",
    tools=[format_markdown, check_grammar]
)

editor = Agent(
    name="editor",
    instruction="You coordinate research and writing tasks",
    model="gpt-4",
    tools=[researcher, writer]  # Agents as tools!
)

# The editor delegates to specialists
result = await editor.chat(
    "Create a comprehensive report on AI trends in healthcare"
)
# Editor automatically:
# 1. Asks researcher to gather data
# 2. Passes findings to writer
# 3. Reviews and finalizes the report

from aakit import Agent, parallel_chat

# Create multiple agents for different tasks
agents = {
    "market_analyst": Agent(
        name="market_analyst",
        instruction="You analyze market data",
        model="gpt-4"
    ),
    "tech_reviewer": Agent(
        name="tech_reviewer", 
        instruction="You evaluate technical feasibility",
        model="gpt-4"
    ),
    "risk_assessor": Agent(
        name="risk_assessor",
        instruction="You identify potential risks",
        model="gpt-3.5-turbo"
    )
}

# Execute all agents in parallel
results = await parallel_chat(
    agents=agents,
    message="Evaluate launching a new AI product",
    timeout=30
)

# Aggregate results
for agent_name, response in results.items():
    print(f"{agent_name}: {response}")

from aakit import Agent, Pipeline

# Create a processing pipeline
pipeline = Pipeline([
    Agent(
        name="translator",
        instruction="You translate text to English",
        model="gpt-3.5-turbo"
    ),
    Agent(
        name="summarizer",
        instruction="You create concise summaries",
        model="gpt-4"
    ),
    Agent(
        name="categorizer",
        instruction="You categorize content by topic",
        model="gpt-3.5-turbo"
    )
])

# Process through the pipeline
result = await pipeline.process(
    "Un article français sur l'intelligence artificielle..."
)
# Output: Categorized English summary

from aakit import Agent, Team

# Create a hierarchical team structure
manager = Agent(
    name="project_manager",
    instruction="You manage AI development projects",
    model="gpt-4"
)

team = Team(
    manager=manager,
    members=[
        Agent("frontend_dev", "You build user interfaces", "gpt-4"),
        Agent("backend_dev", "You build APIs and services", "gpt-4"), 
        Agent("ml_engineer", "You develop ML models", "gpt-4"),
        Agent("qa_tester", "You ensure quality", "gpt-3.5-turbo")
    ],
    coordination_strategy="manager_led"  # or "consensus", "round_robin"
)

# Manager coordinates the team
result = await team.execute_project(
    "Build a chatbot application with sentiment analysis"
)

from aakit import Agent, Negotiation

# Create agents with different objectives
buyer = Agent(
    name="buyer",
    instruction="You negotiate to minimize cost",
    model="gpt-4",
    context={"budget": 10000, "requirements": ["fast", "reliable"]}
)

seller = Agent(
    name="seller",
    instruction="You negotiate to maximize profit",
    model="gpt-4",
    context={"min_price": 8000, "features": ["fast", "reliable", "support"]}
)

# Set up negotiation
negotiation = Negotiation(
    agents=[buyer, seller],
    max_rounds=5,
    success_criteria="agreement_reached"
)

# Agents negotiate automatically
result = await negotiation.start()
print(f"Final agreement: {result.agreement}")
print(f"Rounds taken: {result.rounds}")

from aakit import Agent, AgentPool

# Create an agent pool for scaling
pool = AgentPool(
    template=Agent(
        name="worker",
        instruction="You process data tasks",
        model="gpt-3.5-turbo"
    ),
    min_agents=2,
    max_agents=10,
    scale_factor="queue_length"  # Auto-scale based on workload
)

# Submit tasks - agents are spawned as needed
tasks = ["task1", "task2", "task3", ...]
results = await pool.process_batch(tasks)

# Pool automatically:
# - Spawns new agents when load increases
# - Terminates idle agents
# - Balances work across agents