"Research AI trends and give me something useful"

Task: Research the top 5 enterprise AI agent deployment trends in 2026
Context: This is for a technical report targeting CTOs at Fortune 500 companies
Scope: Focus on production deployments, not research/experimental
Output format: 5 bullet points, each with: trend name, evidence (1-2 examples), and business impact
Constraints: 400 words maximum, cite sources where possible

from anthropic import Anthropic

client = Anthropic()

def create_specialist_agent(role: str, expertise: str, tools: list = None):
    """Factory function creating specialized agent callables."""
    def agent(task: str, context: str = "") -> str:
        system = f"""You are a specialist {role}.
Expertise: {expertise}
Complete the delegated task precisely within its scope."""

        messages = []
        if context:
            messages.append({
                "role": "user",
                "content": f"Context from prior work:\n{context}"
            })
            messages.append({
                "role": "assistant",
                "content": "Understood, I'll use this context."
            })
        messages.append({"role": "user", "content": task})

        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=1500,
            system=system,
            messages=messages
        )
        return response.content[0].text
    return agent

# Create specialist agents
research_agent = create_specialist_agent(
    role="research analyst",
    expertise="web research, source evaluation, information synthesis"
)
writing_agent = create_specialist_agent(
    role="technical writer",
    expertise="clear writing, structure, audience adaptation"
)
review_agent = create_specialist_agent(
    role="quality reviewer",
    expertise="accuracy checking, completeness assessment, critique"
)

# Orchestrator delegates to specialists
def orchestrate_content_creation(topic: str) -> str:
    """Orchestrator delegates research → writing → review."""

    # Step 1: Delegate research
    research_result = research_agent(
        task=f"Research: {topic}\nOutput: 5 key facts with sources, 300 words max"
    )

    # Step 2: Delegate writing with research context
    draft = writing_agent(
        task=f"Write a 600-word article about: {topic}\nStructure: intro, 3 sections, conclusion",
        context=research_result
    )

    # Step 3: Delegate review with both
    review = review_agent(
        task="Review this draft for accuracy, completeness, and clarity. Provide 3 specific improvements.",
        context=f"Research:\n{research_result}\n\nDraft:\n{draft}"
    )

    return f"Draft:\n{draft}\n\nReview:\n{review}"

from agents import Agent, Runner, handoff

# Define specialized agents
research_agent = Agent(
    name="ResearchAgent",
    instructions="""You research topics thoroughly.
When research is complete, hand off to the writing agent.""",
    tools=[web_search]
)

writing_agent = Agent(
    name="WritingAgent",
    instructions="""You write clear, structured content.
Use the research provided to create accurate content.""",
    tools=[]
)

review_agent = Agent(
    name="ReviewAgent",
    instructions="""You review content for quality.
Provide specific, actionable feedback."""
)

# Configure handoffs
research_agent_with_handoff = Agent(
    name="ResearchAgent",
    instructions=research_agent.instructions,
    tools=[web_search],
    handoffs=[handoff(writing_agent)]  # Can hand off to writer
)

# Run the agent — control will flow through handoffs
result = Runner.run_sync(research_agent_with_handoff,
                          "Research and write about AI agent trends 2026")

import json

def create_agent_tool(agent_callable, tool_name: str, description: str) -> dict:
    """Wrap an agent as a tool for another agent to call."""
    return {
        "name": tool_name,
        "description": description,
        "input_schema": {
            "type": "object",
            "properties": {
                "task": {"type": "string", "description": "The specific task to delegate"},
                "context": {"type": "string", "description": "Relevant context for the task"}
            },
            "required": ["task"]
        },
        "function": lambda task, context="": agent_callable(task, context)
    }

# Supervisor with agents as tools
research_tool = create_agent_tool(
    research_agent,
    "delegate_to_research_agent",
    "Delegate research tasks to the specialized research agent"
)

writing_tool = create_agent_tool(
    writing_agent,
    "delegate_to_writing_agent",
    "Delegate writing and drafting tasks to the specialized writing agent"
)

def run_supervisor(user_request: str) -> str:
    """Supervisor that delegates using agent tools."""
    messages = [{"role": "user", "content": user_request}]
    tool_map = {
        "delegate_to_research_agent": research_tool["function"],
        "delegate_to_writing_agent": writing_tool["function"]
    }
    tools_schema = [
        {"name": t["name"], "description": t["description"],
         "input_schema": t["input_schema"]}
        for t in [research_tool, writing_tool]
    ]

    for _ in range(10):
        response = client.messages.create(
            model="claude-opus-4-6",
            max_tokens=2048,
            system="You are a supervisor. Break down complex tasks and delegate to specialists.",
            messages=messages,
            tools=tools_schema
        )

        if response.stop_reason == "end_turn":
            return next(b.text for b in response.content if hasattr(b, "text"))

        messages.append({"role": "assistant", "content": response.content})
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                result = tool_map[block.name](**block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result
                })
        messages.append({"role": "user", "content": tool_results})

    return "Delegation loop incomplete"