smolagents: The Simplest Way to Build Powerful AI Agents

Ever wonder how language models can search the web but struggle to run a simple calculation accurately? Or how they can analyze PDFs but can't make an API call? Welcome to the gap between traditional language models and AI agents. Traditional LLMs are impressive but passive - they generate text based on patterns learned during training. AI agents, on the other hand, can take action in the world. They can search the web, call APIs, execute code, and interact with databases - all to achieve specific goals. Enter smolagents: a lightweight library that strips AI agent development down to its essentials. The Brain and Body Architecture As shown in the diagram above, an AI agent consists of two fundamental components: The Brain: An LLM that handles reasoning and planning, making decisions about which actions to take (hence often called the "Router") The Body: The agent's means of interacting with its environment - defined by the tools and actions available to it smolagents brilliantly implements this architecture with minimal overhead. The entire library is around 1,000 lines of code, embodying the "keep it simple" philosophy that building powerful AI agents shouldn't require complex architecture. From Workflows to True Agents Where does smolagents fit in the broader landscape of AI development patterns? As this diagram illustrates, there's a spectrum: On the left, we have workflows where the developer pre-defines the paths In the middle, the LLM has some control but within limited options On the right, true agents that direct their own actions based on environmental feedback smolagents leans toward the right of this spectrum, enabling you to build agents that can truly adapt to circumstances and take appropriate actions. Creating Your First Agent in Three Steps Here's how simple it is to create a basic agent with smolagents: from smolagents.agent import CodeAgent from smolagents.model import HfApiModel # 1. Initialize a model model = HfApiModel(model_id="llama3/llama-3-8b-instruct") # 2. Create an agent agent = CodeAgent(model=model, tools=[]) # 3. Run the agent response = agent.run("Calculate the 50th Fibonacci number") That's it! This agent can already solve mathematical problems by generating and executing Python code. But the real power comes when you add custom tools. The Magic of Custom Tools smolagents makes creating custom tools refreshingly straightforward: from smolagents.tool import tool @tool("Get weather data for a city") def get_weather_data(city: str): """ Returns weather data for a given city. Args: city: The name of the city (e.g., New York, London, Tokyo) Returns: A dictionary containing weather data """ # Implementation here... pass Just add the @tool decorator to any Python function, provide good documentation, and your agent can now use this capability. Code-First: LLMs Doing What They Do Best smolagents uses a code-first approach instead of requiring JSON formats for actions. When your agent needs to analyze weather patterns across multiple cities, it might generate code like: # Get weather for multiple cities cities = ["Tokyo", "New York", "London"] data = {} for city in cities: data[city] = get_weather_data(city) # Calculate average temperatures avg_temps = {city: sum(info["temperatures"])/len(info["temperatures"]) for city, info in data.items()} # Find the warmest city warmest_city = max(avg_temps, key=avg_temps.get) print(f"The warmest city is {warmest_city} with an average of {avg_temps[warmest_city]:.1f}°C") This is more natural for LLMs (which are trained extensively on code) and more powerful for solving complex problems. When to Use smolagents smolagents is perfect for: Rapid prototyping of AI agents Projects requiring custom domain-specific tools When you need to switch between different LLM providers Building systems that need to interact with their environment When simplicity and readability matter more than complex architecture However, for highly regulated environments or production systems requiring extensive monitoring, you might need additional infrastructure around your smolagents implementation. Getting Started Today Ready to build your first AI agent? Installation is straightforward: pip install smolagents Then you can quickly set up a model, define your tools, build your agent, and start interacting with it. Whether you're building a personal assistant, a data analysis tool, or exploring complex multi-agent systems, smolagents offers a clean, intuitive library to bring your ideas to life. Take Your Agent Development Skills to the Next Level If you're ready to dive deeper into the world of AI agents, check out the comprehensive smolagents course at ai-in-a-shell.com. The free course covers everything from basic agent development to advanced multi-agent

from smolagents.agent import CodeAgent
from smolagents.model import HfApiModel

# 1. Initialize a model
model = HfApiModel(model_id="llama3/llama-3-8b-instruct")

# 2. Create an agent
agent = CodeAgent(model=model, tools=[])

# 3. Run the agent
response = agent.run("Calculate the 50th Fibonacci number")

from smolagents.tool import tool

@tool("Get weather data for a city")
def get_weather_data(city: str):
    """
    Returns weather data for a given city.

    Args:
        city: The name of the city (e.g., New York, London, Tokyo)

    Returns:
        A dictionary containing weather data
    """
    # Implementation here...
    pass

# Get weather for multiple cities
cities = ["Tokyo", "New York", "London"]
data = {}

for city in cities:
    data[city] = get_weather_data(city)

# Calculate average temperatures
avg_temps = {city: sum(info["temperatures"])/len(info["temperatures"]) 
             for city, info in data.items()}

# Find the warmest city
warmest_city = max(avg_temps, key=avg_temps.get)
print(f"The warmest city is {warmest_city} with an average of {avg_temps[warmest_city]:.1f}°C")

pip install smolagents