AI Agents & Agentic Workflows

Tool Use & Function Calling

Tool use is the foundation of agentic behavior. Without tools, an LLM can only reason over information in its context window — it cannot browse the web, run code, query a database, or call an API. Tools are what connect the LLM's reasoning to the real world.

How Tool Calling Works

Modern LLMs (GPT-4o, Claude 3.5, Gemini 1.5) natively support structured tool calling:

1. You describe available tools as JSON schemas (name, description, parameters).
2. The LLM decides whether to call a tool, and if so, which one and with what arguments.
3. Your code executes the tool and returns results.
4. The LLM reads the result and decides whether to call another tool or produce a final answer.

LangChain Tool-Using Agent (Code Example 1)

LangChain's create_tool_calling_agent makes it straightforward to build agents that pick from a toolkit based on the task at hand. The example below builds a financial research agent that can search the web, do arithmetic, and look up stock prices.

from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain.tools import tool
from langchain_core.prompts import ChatPromptTemplate
import requests, json

# Define tools the agent can use
@tool
def search_web(query: str) -> str:
    """Search the web for current information about a topic."""
    # In production: integrate Tavily, Serper, or Brave Search API
    return f"Web search results for '{query}': [simulated results]"

@tool
def calculate(expression: str) -> str:
    """Safely evaluate a mathematical expression."""
    try:
        # Use eval with restricted globals for safety
        result = eval(expression, {"__builtins__": {}}, {})
        return str(result)
    except Exception as e:
        return f"Error: {str(e)}"

@tool
def get_stock_price(ticker: str) -> str:
    """Get the current stock price for a given ticker symbol."""
    # In production: integrate Alpha Vantage, Yahoo Finance, etc.
    prices = {"AAPL": 189.50, "MSFT": 415.20, "GOOGL": 175.30, "NVDA": 875.00}
    price = prices.get(ticker.upper(), "ticker not found")
    return f"{ticker.upper()}: ${price}"

# Create the agent
llm = ChatOpenAI(model="gpt-4o", temperature=0)
tools = [search_web, calculate, get_stock_price]
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful financial research assistant. Use tools to gather data before answering."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}")  # tool call/result history
])

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True, max_iterations=5)

result = executor.invoke({"input": "Compare the stock prices of Apple and NVIDIA. Which has a higher P/E ratio if Apple's EPS is $6.25 and NVIDIA's is $1.95?"})
print(result["output"])
# Agent plan: get_stock_price(AAPL) -> get_stock_price(NVDA) -> calculate P/E ratios -> compare

Anatomy of a Tool Call Trace

With verbose=True, you can see the agent's reasoning. A typical trace looks like:

> Entering new AgentExecutor chain...
Thought: I need to get the stock prices first.
Action: get_stock_price
Action Input: {"ticker": "AAPL"}
Observation: AAPL: $189.50

Action: get_stock_price
Action Input: {"ticker": "NVDA"}
Observation: NVDA: $875.00

Thought: Now I can calculate P/E ratios.
Action: calculate
Action Input: {"expression": "189.50 / 6.25"}
Observation: 30.32

Action: calculate
Action Input: {"expression": "875.00 / 1.95"}
Observation: 448.72

Final Answer: Apple's P/E is 30.32x vs NVIDIA's 448.72x. NVIDIA trades at a dramatically higher multiple, reflecting expectations of explosive AI-driven earnings growth.

Planning & Reasoning Patterns

Raw tool calling is reactive. For complex tasks, agents need to plan — to decompose goals into steps before executing them. Several reasoning patterns have emerged as reliable approaches.

ReAct: Reason + Act

The ReAct pattern (Yao et al., 2022) interleaves reasoning traces with action calls. Before each tool call, the agent explicitly writes its reasoning in natural language. This improves performance on complex tasks and makes agent behavior auditable.

Plan-and-Execute

For tasks requiring many steps, Plan-and-Execute separates the planning phase from execution. A "planner" LLM creates a task list upfront; an "executor" works through each step, potentially replanning if a step fails.

from langchain_experimental.plan_and_execute import PlanAndExecute, load_agent_executor, load_chat_planner

planner = load_chat_planner(llm)
executor = load_agent_executor(llm, tools, verbose=True)
agent = PlanAndExecute(planner=planner, executor=executor, verbose=True)

# The agent will:
# 1. Create a numbered plan: ["Step 1: Search for...", "Step 2: Calculate...", ...]
# 2. Execute each step, passing outputs to subsequent steps
# 3. Synthesize a final answer from all step outputs
agent.run("Research the top 3 AI chip manufacturers, compare their 2025 revenue, and predict market share in 2027")

Reflection & Self-Critique

Reflection agents evaluate their own outputs and iteratively improve them. This pattern is especially powerful for creative tasks, code generation, and research summaries.

REFLECTION_PROMPT = """
You wrote the following response:
<response>{response}</response>

Critique this response. What is missing? What could be more accurate or clearer?
Then rewrite an improved version addressing your critique.
"""
# Typical improvement: 2-3 reflection cycles yield significantly better outputs

Agentic Design Patterns Comparison

Different patterns suit different task types. The table below maps patterns to their optimal use cases and associated risks:

Agent Memory Systems

Memory is what transforms a stateless LLM into an agent that learns and adapts. Without memory, every conversation starts from zero — the agent cannot recall user preferences, past decisions, or previously gathered facts.

Types of Agent Memory

Vector-Based Episodic Memory (Code Example 3)

The following class implements a FAISS-backed episodic memory store that lets agents remember past conversations and retrieve relevant context using semantic similarity.

from openai import OpenAI
from sentence_transformers import SentenceTransformer
import faiss, numpy as np, json
from datetime import datetime

class AgentMemory:
    """Vector-based episodic memory for AI agents."""
    def __init__(self, dim: int = 384):
        self.embedder = SentenceTransformer('all-MiniLM-L6-v2')
        self.index = faiss.IndexFlatIP(dim)
        self.memories = []

    def store(self, content: str, metadata: dict = {}):
        embedding = self.embedder.encode([content], normalize_embeddings=True)
        self.index.add(embedding.astype('float32'))
        self.memories.append({"content": content, "timestamp": datetime.now().isoformat(), **metadata})

    def retrieve(self, query: str, k: int = 3) -> list[dict]:
        if self.index.ntotal == 0: return []
        q_emb = self.embedder.encode([query], normalize_embeddings=True).astype('float32')
        scores, indices = self.index.search(q_emb, min(k, self.index.ntotal))
        return [{"memory": self.memories[i], "relevance": float(scores[0][j])}
                for j, i in enumerate(indices[0]) if i != -1]

# Usage: agent remembers past conversations
memory = AgentMemory()
memory.store("User prefers Python over JavaScript for data science tasks", {"type": "preference"})
memory.store("Previous analysis showed NVIDIA stock outperforming AMD by 40% in 2024", {"type": "fact"})

relevant = memory.retrieve("What programming language does the user prefer?")
print(relevant[0]["memory"]["content"])  # -> "User prefers Python..."

Memory Management Strategies

As agents accumulate memory, several challenges emerge:

• Recency Bias: Always injecting the most recent context may miss important older facts. Use hybrid scoring: relevance + recency.
• Memory Summarization: Periodically compress older memories. GPT-4 can summarize 20 past conversations into a 500-word profile.
• Memory Isolation: In multi-user systems, each user's memories must be namespaced — use metadata filtering on the vector index.
• Forgetting: Not all memories are worth keeping. Implement TTL-based expiry for time-sensitive facts.

Multi-Agent Systems

Single agents have limits. They can lose context on very long tasks, lack specialization, and may hallucinate without a second opinion. Multi-agent systems address these limitations by having several specialized agents collaborate — each doing what it does best.

Why Multi-Agent?

AutoGen Multi-Agent System (Code Example 2)

Microsoft's AutoGen framework makes it straightforward to build group chats where agents with distinct personas collaborate on complex tasks.

import autogen

# Multi-agent research team: planner + researcher + critic + executor
config_list = [{"model": "gpt-4o", "api_key": "..."}]
llm_config = {"config_list": config_list, "temperature": 0.1}

planner = autogen.AssistantAgent(
    name="Planner",
    system_message="""Break complex tasks into steps. Assign each step to the right specialist.
    Always create a plan before work begins. Format: PLAN: step1, step2, step3""",
    llm_config=llm_config
)

researcher = autogen.AssistantAgent(
    name="Researcher",
    system_message="Gather information and data. Cite sources. Focus on facts, not opinions.",
    llm_config=llm_config
)

critic = autogen.AssistantAgent(
    name="Critic",
    system_message="Review outputs for accuracy, completeness, and logical consistency. Point out flaws.",
    llm_config=llm_config
)

executor = autogen.UserProxyAgent(
    name="Executor",
    human_input_mode="NEVER",  # fully automated
    code_execution_config={"work_dir": "workspace", "use_docker": False},
    max_consecutive_auto_reply=5
)

# Group chat: agents collaborate to solve the task
groupchat = autogen.GroupChat(
    agents=[planner, researcher, critic, executor],
    messages=[], max_round=12
)
manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=llm_config)
executor.initiate_chat(manager, message="Analyze the competitive landscape of LLM providers in 2025. Include market share estimates and key differentiators.")

Multi-Agent Orchestration Patterns

Agent Frameworks Compared

The agent framework ecosystem has grown rapidly since 2023. Choosing the right framework depends on your use case, team's Python expertise, and whether you need multi-agent support out of the box.

Production Considerations

Deploying agents in production is fundamentally different from running demos. Agents that work perfectly in testing can fail in unpredictable ways in production — looping indefinitely, calling expensive tools unnecessarily, or executing harmful actions when given malicious inputs.

Safety & Guardrails

Observability

Agents are harder to debug than standard software because their behavior is non-deterministic. Investing in observability infrastructure is essential:

• Trace every run: Log the full reasoning trace — every thought, tool call, and observation. LangSmith, Weights & Biases Weave, and Langfuse are purpose-built for this.
• Token usage: Track token consumption per run and per tool to identify cost hotspots.
• Latency breakdown: Separate LLM inference time from tool execution time. Tool latency is usually the bigger issue.
• Success/failure rates: Define task success criteria and track them. A 90% task completion rate might be acceptable; 60% is not.

Cost Management

Agents can be expensive. A single complex research task might make 10–20 LLM calls and dozens of tool calls. Strategies to control costs:

• Use smaller models for simpler steps: Route tool selection and formatting steps to GPT-4o Mini; reserve GPT-4o for complex reasoning.
• Cache tool results: Web search results, API responses, and database queries can be cached. Many tasks re-use the same data.
• Prompt compression: Use LLMLingua or similar tools to compress conversation history before injecting into context.
• Budget limits: Implement per-user and per-task token budgets with hard stops.

Exercises & Practice

Building agents is a hands-on skill. Work through these exercises in order — each one reinforces a different layer of the agentic stack.