Agent Architectures.

The foundational loop. The model reasons about the task, picks a tool, observes the result, and reasons again until complete.

while not done:
  thought = llm.think(history)
  if thought.action:
    result = tools[thought.action](thought.input)
    history.append(observation=result)
  else:
    return thought.final_answer

Orchestrator breaks task into subtasks, dispatches to specialist agents, aggregates results.

User → Orchestrator → [Agent A | Agent B | Agent C]
              → Aggregator → Response

Agent decides when to retrieve context. Retrieval is a tool call, not a preprocessing step.

Query → Embedding → Vector Search → Context Injection → Generation
Key params: chunk_size=512, overlap=64, top_k=5, reranker=cross-encoder

Short-term = conversation context window. Long-term = vector store of past interactions. On each turn: retrieve relevant memories → inject into context → generate → store new memory.

Generator produces output → Critic evaluates against criteria → Refiner incorporates feedback → repeat until pass.

output = generator.generate(task)
for i in range(max_iterations):
  feedback = critic.evaluate(output, criteria)
  if feedback.passes: break
  output = refiner.improve(output, feedback)
return output

Model identifies all independent tool calls and executes them in parallel. Use tool_choice: "auto" with multiple tools defined. Model emits multiple tool_use blocks in one response.

# Simultaneously fetch GitHub stats + Stripe revenue + PostHog analytics
# → compose dashboard
# Result: 3–5× speedup vs sequential; fewer total LLM turns

Supervisor classifies intent → routes to specialized subagent → returns to supervisor for output handling.

Input → Supervisor (classify)
      → [CodeAgent | ResearchAgent | DataAgent]
      → Supervisor (format) → Output

Agent wakes on external event (webhook, schedule, file change). Performs task. Goes back to sleep. No persistent conversation — each invocation is stateless (state lives in external store).

Agent catches its own errors and attempts automated recovery. On tool failure: retry with modified input, try alternative tool, or escalate to human.

try:
  result = agent.execute(task)
except ToolError as e:
  strategy = error_classifier.classify(e)
  if strategy == 'retry':
    result = agent.execute(task, hint=e.message)
  elif strategy == 'fallback':
    result = fallback_tool.execute(task)
  else:
    return escalate_to_human(task, e)

Planner LLM generates a full task plan upfront. Executor LLM carries out each step. Planner can revise the plan based on execution results.

plan = planner_llm.create_plan(task)
results = []
for step in plan.steps:
  result = executor_llm.run(step, context=results)
  results.append(result)
  if result.needs_replan:
    plan = planner_llm.revise(plan, result)
return synthesizer.combine(results)

Agent pauses at defined checkpoints to request human approval before proceeding. Supports async approval via Slack, email, or UI.

for step in plan:
  agent.execute(step)
  if step.requires_approval:
    approval = await human_gateway.request(
      action=step.description,
      timeout=3600
    )
    if not approval.granted:
      return abort_with_explanation(approval.reason)

Specialized agent for transforming unstructured data (documents, emails, web pages) into typed, validated schemas using forced JSON output.

const schema = z.object({
  title: z.string(),
  date: z.string().datetime(),
  items: z.array(z.object({
    name: z.string(),
    amount: z.number(),
  })),
})

const result = await anthropic.messages.create({
  tools: [{ name: 'extract', input_schema: zodToJsonSchema(schema) }],
  tool_choice: { type: 'tool', name: 'extract' },
  messages: [{ role: 'user', content: rawDocument }],
})

Agent writes code, executes it in a sandbox, reads the output, and iterates until the result matches the goal. Combines code generation with tool-based execution.

goal = "Analyze sales_data.csv and find the top 5 products by revenue"
while not satisfied:
  code = llm.write_code(goal, context=previous_outputs)
  stdout, stderr = sandbox.execute(code)
  if stderr:
    context.add(error=stderr)
  elif not satisfies_goal(stdout, goal):
    context.add(output=stdout, feedback="Not quite — refine")
  else:
    return format_result(stdout)