单智能体为何会遇到瓶颈

# Context exhaustion example
max_tokens = 128000  # GPT-4o context limit

conversation_history = []
total_tokens = 0

for step in agent_steps:
    step_tokens = count_tokens(step)
    if total_tokens + step_tokens > max_tokens:
        # Agent cannot proceed - context is full
        raise ContextExhaustedError('Agent context window full at step ' + str(len(conversation_history)))
    conversation_history.append(step)
    total_tokens += step_tokens

# 20 tools is too many for one agent
tools = [
    search_web, query_database, send_email, create_document,
    read_file, write_file, run_python, call_api,
    analyze_image, transcribe_audio, translate_text, summarize_doc,
    fetch_weather, book_calendar, send_slack, query_crm,
    generate_chart, resize_image, compress_file, validate_json
]

# Agent spends 40% of its tokens just picking which tool to use
agent = create_agent(llm=gpt4o, tools=tools)  # This will be slow and unreliable

# Error propagation example
def single_agent_pipeline(task):
    result_1 = agent.think('Research competitors')     # Step 3: hallucinates a fake company
    result_2 = agent.think('Analyze ' + result_1)     # Step 4: analyzes the fake company
    result_3 = agent.think('Compare prices for ' + result_2)  # Step 5: prices for a fake company
    # Final report is built on fiction - error propagated silently
    return agent.think('Write report using ' + result_3)

import asyncio

# Single agent: sequential (slow)
def single_agent_research(topics):
    results = []
    for topic in topics:  # topics = ['AI', 'ML', 'NLP'] - runs one at a time
        result = agent.research(topic)
        results.append(result)
    return results  # Takes 3x longer than necessary

# Multi-agent: parallel (fast)
async def multi_agent_research(topics):
    tasks = [agent_pool.research(topic) for topic in topics]
    return await asyncio.gather(*tasks)  # All three run simultaneously

# Diagnostic checklist
def should_use_multi_agent(task_spec):
    signals = {
        'too_many_steps': task_spec.estimated_steps > 20,
        'too_many_tools': len(task_spec.required_tools) > 10,
        'multiple_domains': len(task_spec.required_expertise) > 2,
        'parallelizable': task_spec.has_independent_subtasks,
        'context_heavy': task_spec.estimated_tokens > 50000
    }
    score = sum(signals.values())
    print('Multi-agent signals:', signals)
    return score >= 2  # Upgrade if 2+ signals are present

# Multi-agent system sketch
orchestrator = Agent(
    llm='gpt-4o',
    system='You are a task planner. Break work into subtasks and delegate.',
    tools=[delegate_to_researcher, delegate_to_writer, delegate_to_coder]
)

researcher = Agent(
    llm='gpt-4o',
    system='You are a research specialist. Find and verify information.',
    tools=[search_web, query_arxiv, fetch_url]  # Only 3 focused tools
)

writer = Agent(
    llm='gpt-4o',
    system='You are a technical writer. Transform research into clear prose.',
    tools=[format_markdown, check_grammar]  # Only 2 focused tools
)