Agentic Workflows

What it is

An agentic workflow is a pattern where one or more AI agents execute complex tasks autonomously, making decisions at each step about what action to take, which tool to use, and when to request human intervention. Unlike a fixed pipeline, the agent adapts its behavior based on intermediate results.

Fundamental patterns

Reflection

The agent evaluates its own output and improves it iteratively:

Generate → Evaluate → Refine → Evaluate → Deliver

Useful for: writing, code generation, analysis.

Planning (Plan-and-Execute)

The agent decomposes the task into subtasks before executing:

Analyze task → Create plan → Execute step 1 → ... → Step N → Synthesize

Useful for: research, complex tasks with multiple dependencies.

Tool use (ReAct)

The agent alternates between reasoning and action:

Think → Act → Observe → Think → Act → Observe → Respond

This is the most common pattern in frameworks like Strands Agents.

Multi-agent

Multiple specialized agents collaborate:

Orchestrator → Research agent → Writer agent → Reviewer agent → Result

Autonomy levels

The choice of autonomy level depends on task risk and system maturity:

1. Assisted: agent suggests, human approves each step. Ideal for high-risk tasks like modifying infrastructure or sending communications
2. Supervised: agent executes, human reviews key points. Good for code generation or data analysis
3. Autonomous: agent executes end-to-end, reports results. Appropriate for well-defined repetitive tasks
4. Collaborative: multiple agents coordinate with minimal human intervention. The most advanced pattern, requires robust guardrails

ReAct flow in detail

Example with Strands Agents

from strands import Agent
from strands.tools import tool
 
@tool
def search_docs(query: str) -> str:
    """Search relevant documents in the knowledge base."""
    # Search implementation
    return results
 
agent = Agent(
    model="us.anthropic.claude-sonnet-4-20250514-v1:0",
    tools=[search_docs],
    system_prompt="You are a research assistant. Use search_docs to find information before answering."
)
 
response = agent("What are the best practices for RAG?")

The agent autonomously decides when to invoke search_docs and how many times to iterate before responding.

Anti-patterns

• Agent for everything: using an agent when a fixed pipeline would suffice — adds unnecessary latency and cost
• No iteration limit: an agent without max_turns can enter infinite loops
• Ambiguous tools: if two tools do similar things, the agent will choose inconsistently
• No fallback: when the agent fails, there should be a clear recovery path

Design considerations

• Guardrails: define clear boundaries of what the agent can and cannot do
• Observability: log every decision and action for debugging
• Error recovery: the agent should handle failures gracefully
• Cost: each iteration consumes tokens — establish limits
• Evaluation: measure result quality, not just completion

Connection with MCP

The Model Context Protocol provides the tool layer that agentic workflows need. Without a standard protocol for discovering and using tools, each workflow requires ad-hoc integrations.

Why it matters

Agentic workflows allow LLMs to move from answering questions to executing complex multi-step tasks. Understanding their patterns — ReAct, planning, reflection — is the difference between building chatbots and building assistants that actually complete work.

References

• The Landscape of Emerging AI Agent Architectures — Masterman et al., 2024. Overview of agent architectures.
• Building Effective Agents — Anthropic, 2024. Practical guide to agentic patterns.
• Design Patterns for AI Agents — Zhuge et al., 2024. Taxonomy of design patterns for agents.
• ReAct: Synergizing Reasoning and Acting in Language Models — Yao et al., 2022. The paper that formalized the ReAct pattern.
• Strands Agents — Documentation — AWS. SDK for building agents with tools.