Advanced Agentic AI Design Patterns

Session Notes

This session introduced the evolution from generative AI assistants to autonomous agentic AI systems. It covered four core design patterns: reflection, tool use, planning, and multi-agent collaboration, and showed how the open-source Strands Agents SDK supports agent development.

The Evolution Toward Agentic AI

Generative AI Assistants:

• Follow a defined set of rules.
• Automate repetitive tasks.
• Mimic aspects of human logic and reasoning.

Generative AI Agents:

• Reason and act to achieve a specific goal.
• Address a broader range of tasks than rule-based assistants.
• Can interact with tools and their environment.

Agentic AI Systems:

• Operate with a higher degree of autonomy.
• Coordinate reasoning, planning, tools, memory, and actions.
• Can automate complete workflows rather than individual tasks.

What Are AI Agents?

• AI agents are autonomous software systems that use artificial intelligence, particularly large language models, to reason, plan, and complete tasks on behalf of people or other systems.
• An agent observes its environment, works toward a goal, selects actions, and uses tools where needed.
• Memory provides context from previous observations and interactions.
• Tools connect the agent to external capabilities.
• Actions allow the agent to affect or query its environment.

Core Agentic AI Design Patterns

Reflection:

• Enables an AI system to evaluate its own output, decisions, and reasoning.
• Helps identify errors and inconsistencies.
• Generates suggestions for improvement.
• Supports iterative refinement across multiple cycles.

Tool Use:

• Extends an agent beyond language generation.
• Connects the agent to APIs, databases, calculators, search systems, and image-processing services.
• Enables dynamic interaction with external systems.
• Supports tasks such as data retrieval, calculations, and system operations.

Planning:

• Breaks a complex objective into manageable subtasks.
• Organizes steps into a structured strategy.
• Executes tasks in sequence while monitoring progress.
• Revises the plan when new information or failures require adjustment.

Multi-Agent Collaboration:

• Decomposes complex problems among multiple agents.
• Assigns specialized roles or capabilities to each agent.
• Allows agents to exchange information and share intermediate results.
• Integrates individual outputs into a final result.

Pattern 1: Reflection

Self-Evaluation:

• The model reviews its own response or proposed action.

Error Identification:

• The model searches for factual errors, omissions, contradictions, and weaknesses.

Improvement Suggestions:

• The model proposes specific changes to improve the result.

Iterative Improvement:

• The system repeats evaluation and revision until it reaches an acceptable result or a configured limit.

Reflection can improve quality, but each iteration adds latency and model cost. Applications should define stopping criteria and avoid unbounded loops.

Pattern 2: Tool Use

External Resource Utilization:

• Agents can call APIs, query databases, retrieve documents, or invoke other software.

Capability Extension:

• Tools enable precise calculations and operations that a language model cannot reliably perform on its own.

Dynamic Interaction:

• The agent chooses a tool based on the current task and uses the result to determine its next step.

Typical Applications:

• Retrieving current or private data.
• Performing calculations.
• Processing images or files.
• Creating tickets or updating business systems.
• Running controlled infrastructure operations.

Tool access must be constrained by validation, authorization, and least-privilege permissions because agent-generated tool inputs are untrusted.

Pattern 3: Planning

Task Decomposition:

• Divide a complex goal into smaller, independently executable tasks.

Strategic Structuring:

• Determine dependencies and arrange tasks in an effective order.

Efficient Execution:

• Follow the plan and monitor completion and failures.

Flexible Adjustment:

• Re-plan when a tool fails, assumptions change, or new information becomes available.

Planning is particularly useful for tasks that require several tools, have dependencies, or cannot be completed reliably in a single model response.

Pattern 4: Multi-Agent Collaboration

Task Division:

• Break the problem into work that can be delegated.

Specialization:

• Give each agent a defined role, such as researcher, analyst, developer, or reviewer.

Collaboration:

• Allow agents to exchange context and intermediate findings.

Result Integration:

• Combine and reconcile outputs before producing the final answer.

Multi-agent systems can improve specialization and parallelism, but they also introduce coordination cost, duplicated work, and additional failure modes. They should be used when role separation provides clear value.

Strands Agents

• Strands Agents is an open-source Python SDK for building AI agents with a small amount of code.
• It uses a model-driven approach to building and running agents.
• It can scale from conversational assistants to autonomous, multi-step workflows.
• It supports local development and production deployment.

Lightweight and Flexible:

• Provides a simple, customizable agent loop.

Model Agnostic:

• Supports Amazon Bedrock, Anthropic, Ollama, and custom model providers.

Advanced Capabilities:

• Supports multi-agent systems, autonomous agents, and streaming.

Built-In Model Context Protocol Support:

• Provides native integration with MCP servers.
• Allows agents to discover and use external tools exposed through MCP.

The Agentic Loop

1. Invoke the model with the goal, context, available tools, and observations.
2. Receive the model response, reasoning outcome, and tool selection.
3. Let the agent decide whether another action is required.
4. Execute the selected tool with validated inputs.
5. Return the tool result to the model as a new observation.
6. Repeat until the task is complete or a stopping condition is reached.
7. Produce the final response.

The loop enables complex, multi-step reasoning and action. Production implementations should also enforce limits for iterations, execution time, permissions, and spending.

Design Considerations

• Use reflection when output quality benefits from critique and revision.
• Use tools when the task requires current data, deterministic computation, or external actions.
• Use planning when a goal contains multiple dependent steps.
• Use multiple agents when specialization or parallel work outweighs coordination overhead.
• Validate all tool inputs and outputs at system boundaries.
• Apply least-privilege access to every tool and agent role.
• Log tool calls and state transitions for observability and auditing.
• Add timeouts, retry limits, and explicit termination conditions.
• Keep a human approval step for sensitive or irreversible actions.

Key Takeaways

• Agentic AI combines models, memory, goals, tools, actions, and environmental feedback.
• Reflection, tool use, planning, and multi-agent collaboration are reusable patterns for building capable agents.
• Each pattern solves a different problem and introduces its own cost and operational complexity.
• Strands Agents provides a lightweight, model-agnostic SDK with support for multi-agent workflows and MCP tools.
• Reliable agent systems require guardrails, bounded execution, observability, and controlled tool permissions in addition to model reasoning.