Creating tools for agents in LangChain - Mechanics & Internals

Overview - Creating tools for agents

What is it?

Creating tools for agents means building small, reusable pieces of code that an AI agent can use to perform specific tasks. These tools act like helpers that the agent can call when it needs to do something, such as searching the internet, doing math, or accessing a database. Instead of hardcoding everything inside the agent, tools let the agent stay flexible and smart by using the right helper at the right time. This makes the agent more powerful and easier to improve.

Why it matters

Without tools, agents would have to know how to do every task themselves, which is very hard and limits what they can do. Tools let agents handle many different jobs by calling specialized helpers, just like how you use different apps on your phone for different things. This means agents can solve more problems, adapt faster, and be more reliable. It also makes building and updating agents easier because you can improve or add tools without changing the whole agent.

Where it fits

Before learning about creating tools for agents, you should understand what AI agents are and how they use language models to make decisions. After this, you can learn about how agents plan and choose which tools to use, and then how to build complex workflows by combining multiple tools and agents.

Mental Model

Core Idea

Tools are like specialized helpers that an AI agent calls on to perform tasks it cannot do alone, making the agent smarter and more flexible.

Think of it like...

Imagine an agent as a chef who knows many recipes but sometimes needs special kitchen gadgets like a blender or a thermometer. Instead of doing everything by hand, the chef uses these gadgets (tools) to cook better and faster.

Agent
  │
  ├─ Tool 1: Search Engine
  ├─ Tool 2: Calculator
  ├─ Tool 3: Database Query
  └─ Tool 4: API Caller

Agent calls the right tool based on the task.

Build-Up - 7 Steps

1

Foundation

What is an agent tool in LangChain

Concept: Introducing the idea of a tool as a callable function or class that performs a specific task for an agent.

In LangChain, a tool is a piece of code that an agent can use to do something useful. For example, a tool might search the web, do math, or fetch data. Tools have a name and a description so the agent knows when to use them. You create a tool by defining a function or class and then wrapping it so the agent can call it.

Result

You get a reusable tool that the agent can call by name to perform its task.

Understanding that tools are separate from the agent itself helps you see how agents can stay simple while still doing many different things.

2

Foundation

Basic tool creation with functions

Concept: How to create a simple tool using a Python function and register it for the agent.

You write a Python function that does one job, like adding two numbers. Then you create a Tool object in LangChain by giving it the function, a name, and a description. This tool can then be passed to an agent so it knows how to use it.

Result

A working tool that the agent can call to perform the function's task.

Knowing how to wrap simple functions as tools is the first step to making agents that can do many tasks.

3

Intermediate

Using external APIs as tools

🤔Before reading on: do you think an agent can directly call any API without a tool? Commit to yes or no.

Concept: How to create tools that connect to external services or APIs, enabling agents to access live data or perform complex operations.

Many useful tasks require calling external APIs, like weather services or databases. You create a tool by writing code that sends requests to these APIs and processes the response. Then you wrap this code as a LangChain tool with a clear name and description. The agent can then call this tool to get real-time information or perform actions outside its own code.

Result

Agents can use live data and external services by calling these API tools.

Understanding that tools act as bridges between the agent and the outside world unlocks powerful agent capabilities.

4

Intermediate

Tool input and output handling

🤔Before reading on: do you think tools must always return text, or can they return other data types? Commit to your answer.

Concept: How tools receive inputs from agents and return outputs, including handling different data types and formats.

Tools take input from the agent, usually as text or structured data, and return results. You can design tools to accept multiple parameters or complex inputs. The output can be text, numbers, or even JSON objects. Proper input and output handling ensures the agent understands the tool's results and can use them in its reasoning.

Result

Tools communicate clearly with agents, enabling smooth task execution.

Knowing how to design tool interfaces prevents confusion and errors when agents use them.

5

Intermediate

Registering multiple tools with an agent

Concept: How to provide an agent with a list of tools so it can choose which one to use based on the task.

You can create many tools and give them all to an agent when you create it. The agent uses the tool descriptions to decide which tool fits the current question or task. This lets the agent handle a wide range of problems by picking the right tool each time.

Result

An agent that can solve diverse tasks by selecting from multiple tools.

Understanding that agents use tool descriptions to pick tools helps you design better tool sets.

6

Advanced

Custom tool classes with state and logic

🤔Before reading on: do you think tools can maintain memory or state between calls? Commit to yes or no.

Concept: Creating tools as classes that can keep state or have complex logic, not just simple functions.

Sometimes tools need to remember information or manage complex workflows. You can create a tool as a class with methods and internal variables. This lets the tool keep track of previous calls or manage multi-step processes. You then expose a call method that the agent uses. This approach makes tools more powerful and flexible.

Result

Tools that can handle complex tasks and remember context across calls.

Knowing that tools can be stateful expands what agents can do beyond simple queries.

7

Expert

Tool chaining and orchestration inside agents

🤔Before reading on: do you think agents can automatically combine multiple tools in sequence? Commit to yes or no.

Concept: How agents can use multiple tools in a planned sequence to solve complex problems, and how to design tools for this orchestration.

Advanced agents can plan to use several tools one after another, passing results from one tool to the next. This is called tool chaining or orchestration. You design tools with clear inputs and outputs so the agent can combine them. LangChain supports this by letting agents reason about which tools to call and when, enabling multi-step problem solving.

Result

Agents that solve complex tasks by combining multiple tools automatically.

Understanding tool orchestration reveals how agents can handle real-world problems that need many steps.

Under the Hood

Underneath, tools are Python objects or functions that the agent calls dynamically during its reasoning process. The agent uses the tool's name and description to decide when to call it. When called, the tool executes its code, which may include API calls, computations, or database queries, and returns a result. The agent then uses this result to continue its reasoning or produce a final answer. This dynamic calling is managed by LangChain's agent framework, which integrates language model outputs with tool invocation.

Why designed this way?

Tools were designed to separate concerns: the agent focuses on reasoning and decision-making, while tools handle specific tasks. This modularity makes agents easier to build, maintain, and extend. Early AI systems tried to hardcode all logic inside the agent, which was inflexible and complex. By creating tools as independent units, developers can add new capabilities without changing the agent's core logic, enabling faster innovation and better reliability.

┌─────────────┐       calls       ┌─────────────┐
│   Agent     │──────────────────▶│    Tool     │
│ (reasoning) │                   │ (task code) │
└─────────────┘                   └─────────────┘
       ▲                               │
       │ uses output                   │ returns result
       └──────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think an agent can use any function as a tool without adaptation? Commit to yes or no.

Common Belief: Any Python function can be used directly as a tool without changes.

Reality: Tools must have clear names and descriptions so the agent knows when and how to use them; not all functions fit this pattern directly.

Why it matters: Without proper naming and description, the agent cannot decide when to call the tool, leading to poor or failed task execution.

Quick: Do you think tools always return text outputs? Commit to yes or no.

Common Belief: Tools only return text strings to the agent.

Reality: Tools can return various data types like numbers, JSON, or objects, as long as the agent can interpret them.

Why it matters: Limiting tools to text reduces their usefulness and prevents agents from handling structured data effectively.

Quick: Do you think agents can automatically combine tools without explicit design? Commit to yes or no.

Common Belief: Agents automatically know how to chain multiple tools without extra setup.

Reality: Tool chaining requires careful design of tool inputs/outputs and agent planning; it is not automatic.

Why it matters: Assuming automatic chaining leads to unexpected failures or incorrect results in complex tasks.

Quick: Do you think tools can maintain memory between calls by default? Commit to yes or no.

Common Belief: Tools always remember previous calls and context automatically.

Reality: Tools are stateless by default; stateful behavior requires explicit design using classes or external storage.

Why it matters: Expecting automatic memory causes bugs when tools behave unexpectedly or lose context.

Expert Zone

1

Tools' descriptions must be carefully crafted to guide the agent's natural language understanding for correct tool selection.

2

Stateful tools can introduce complexity in concurrency and scaling, requiring careful management in production.

3

Tool chaining often needs intermediate result formatting to ensure compatibility between tools, which is a subtle but critical detail.

When NOT to use

Creating tools is not ideal when tasks are simple and can be handled directly by the language model or when latency from external calls is unacceptable. In such cases, embedding logic inside the agent prompt or using prompt engineering might be better.

Production Patterns

In production, tools are often wrapped around robust APIs with error handling and rate limiting. Agents use tool registries to dynamically load tools. Tool orchestration is combined with caching and logging to improve performance and traceability.

Connections

Microservices Architecture

Tools act like microservices that provide specific functionalities to a central agent.

Understanding tools as microservices helps grasp modularity and scalability principles in software design.

Human Delegation

Agents delegate tasks to tools just like people delegate chores to specialists.

Seeing agents as delegators clarifies why tools improve efficiency and focus.

Operating System System Calls

Tools are like system calls that provide controlled access to system resources for programs.

Knowing this analogy helps understand how agents rely on tools to safely extend their capabilities.

Common Pitfalls

#1 Creating tools without clear names or descriptions.

Wrong approach:

Tool(func=some_function)

Correct approach:

Tool(name='AddNumbers', func=some_function, description='Adds two numbers')

Root cause:

The agent needs names and descriptions to decide when to use a tool; missing these makes the tool unusable.

#2 Returning raw data types that the agent cannot interpret.

Wrong approach:

def tool_func(x): return {'result': x*2}

Correct approach:

def tool_func(x): return f'The result is {x*2}'

Root cause:

Agents expect text outputs to incorporate into their reasoning; returning raw objects confuses them.

#3 Assuming tools remember previous calls without design.

Wrong approach:

class Tool:
def __call__(self, input):
self.count += 1
return self.count

# but count is never initialized

Correct approach:

class Tool:
def __init__(self):
self.count = 0
def __call__(self, input):
self.count += 1
return self.count

Root cause:

Forgetting to initialize state causes runtime errors and unexpected behavior.

Key Takeaways

Tools are modular helpers that agents call to perform specific tasks, making agents more capable and flexible.

Creating tools requires clear naming and descriptions so agents can choose the right tool for each task.

Tools can be simple functions or complex classes with state, depending on the task complexity.

Advanced agents can chain multiple tools to solve multi-step problems, but this requires careful design.

Understanding tools as bridges between agents and external systems unlocks powerful real-world applications.