Coding Implementation to Build Multi-Agent AI Systems with SmolAgents Using Coding, Tool Calling, and Dynamic Orchestration

import subprocess, sys


def pip(*args):
   subprocess.check_call([sys.executable, "-m", "pip", "install", "-q", *args])


pip("smolagents[all]", "duckduckgo-search", "wikipedia", "rich")


import os, math, textwrap
from rich.console import Console
from rich.panel   import Panel
from rich.table   import Table
from rich         import print as rprint


console = Console()


def section(title: str, color: str = "bold cyan"):
   console.rule(f"[{color}]{title}[/{color}]")


def show(label: str, value):
   console.print(Panel(str(value), title=f"[bold yellow]{label}[/bold yellow]", expand=False))


import getpass


OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
if not OPENAI_API_KEY:
   OPENAI_API_KEY = getpass.getpass("🔑 Enter your OpenAI API key: ")
   os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY


console.print("[green]✓ OpenAI API key loaded.[/green]")


section("SECTION 1 · SmolAgents Architecture")


console.print(Panel("""
SmolAgents (HuggingFace) is a minimalist agent framework.
Current stable release: 1.24.0   |   Using: OpenAI gpt-4o-mini


CORE ABSTRACTIONS
 Tool
 agent.tools (dict)
 ToolCollection
 LiteLLMModel
 CodeAgent
 ToolCallingAgent


MULTI-AGENT  (v1.8+ API)
 Pass sub-agents directly via  managed_agents=[sub_agent]
 Sub-agents need  name=  and  description=  set at init.
 ManagedAgent wrapper class was removed in v1.8.0.


EXECUTION LOOP (CodeAgent)
 Task ──► LLM writes Python ──► sandbox executes it
      ◄── observation (tool output / exception) ◄──
 Repeats up to max_steps, then calls final_answer(...)
""", title="[bold green]Architecture[/bold green]"))

section("SECTION 2 · Building Custom Tools")


from smolagents import Tool, tool


@tool
def celsius_to_fahrenheit(celsius: float) -> str:
   return f"{celsius}°C = {celsius * 9/5 + 32:.2f}°F"


class PrimeTool(Tool):


   name        = "prime_checker"
   description = (
       "If composite, returns the smallest prime factor."
   )
   inputs = {
       "n": {"type": "integer", "description": "Positive integer to test."}
   }
   output_type = "string"


   def forward(self, n: int) -> str:
       if n < 2:
           return f"{n} is not prime (must be >= 2)."
       for i in range(2, int(math.isqrt(n)) + 1):
           if n % i == 0:
               return f"{n} is NOT prime. Smallest factor: {i}."
       return f"{n} IS prime!"


class MemoTool(Tool):


   name        = "memory_store"
   description = (
       "Stores or retrieves key-value pairs. "
       "action='set' stores key+value; "
       "action='get' retrieves by key; "
       "action='list' shows all keys."
   )
   inputs = {
       "action": {"type": "string", "description": "set | get | list"},
       "key":    {"type": "string", "description": "Memory key (skip for list)", "nullable": True},
       "value":  {"type": "string", "description": "Value to store (set only)",  "nullable": True},
   }
   output_type = "string"


   def __init__(self, *args, **kwargs):
       super().__init__(*args, **kwargs)
       self._store: dict[str, str] = {}


   def forward(self, action: str, key: str = None, value: str = None) -> str:
       if action == "set":
           self._store[key] = value
           return f"Stored '{key}' = '{value}'"
       elif action == "get":
           return self._store.get(key, f"Key '{key}' not found.")
       elif action == "list":
           return "Keys: " + ", ".join(self._store.keys()) if self._store else "Memory empty."
       return "Unknown action. Use: set | get | list"

class DuckDuckGoTool(Tool):


   name        = "web_search"
   description = "Performs a web search and returns top results as plain text."
   inputs = {
       "query":       {"type": "string",  "description": "The search query."},
       "max_results": {"type": "integer", "description": "Results to return (1-10).", "nullable": True},
   }
   output_type = "string"


   def forward(self, query: str, max_results: int = 3) -> str:
       try:
           from duckduckgo_search import DDGS
           with DDGS() as ddgs:
               results = [
                   f"* {r['title']}n  {r['href']}n  {r['body'][:200]}"
                   for r in ddgs.text(query, max_results=max_results)
               ]
           return "nn".join(results) if results else "No results found."
       except Exception as e:
           return f"Search failed: {e}"


@tool
def factorial(n: int) -> str:
   return f"{n}! = {math.factorial(n)}"


show("celsius_to_fahrenheit(100)", celsius_to_fahrenheit(100))
show("PrimeTool — 97",             PrimeTool().forward(97))
show("PrimeTool — 100",            PrimeTool().forward(100))
m = MemoTool()
m.forward("set", "author", "Ada Lovelace")
show("MemoTool get 'author'",      m.forward("get", "author"))


section("SECTION 3 · Managing Tools  (agent.tools dict)")


console.print(Panel("""
The Toolbox class was removed in v1.x.
Tools live in  agent.tools, a plain Python dict keyed by tool name.
""", title="[bold green]Tools Dict[/bold green]"))


section("SECTION 4 · LLM Engines")


console.print(Panel("""
SmolAgents supports multiple LLM backends via  LiteLLMModel.
We use  gpt-4o-mini.
""", title="[bold green]Engine Options[/bold green]"))


from smolagents import LiteLLMModel


MODEL_ID = "openai/gpt-4o-mini"
engine   = LiteLLMModel(model_id=MODEL_ID, api_key=OPENAI_API_KEY)
console.print(f"[green]Engine ready:[/green] {MODEL_ID}")

section("SECTION 5 · CodeAgent")


from smolagents import CodeAgent


code_agent = CodeAgent(
   tools           = [celsius_to_fahrenheit, PrimeTool(), MemoTool(), DuckDuckGoTool()],
   model           = engine,
   max_steps       = 6,
   verbosity_level = 1,
)


console.print("n[bold]Initial agent.tools keys:[/bold]", list(code_agent.tools.keys()))
code_agent.tools["factorial"] = factorial
console.print("[dim]After adding factorial:[/dim]", list(code_agent.tools.keys()))


console.print("n[bold yellow]Task 1:[/bold yellow]")
result1 = code_agent.run(
   "Convert boiling point (100C) and body temperature (37C) to Fahrenheit. "
   "Which is higher and by how much?"
)
show("CodeAgent — Task 1", result1)


console.print("n[bold yellow]Task 2:[/bold yellow]")
result2 = code_agent.run("What is 17 times 19? Is that result prime? Also check 7919.")
show("CodeAgent — Task 2", result2)


console.print("n[bold yellow]Task 3:[/bold yellow]")
result3 = code_agent.run("Compute 10! using the factorial tool.")
show("CodeAgent — Task 3", result3)

section("SECTION 6 · ToolCallingAgent (ReAct)")


from smolagents import ToolCallingAgent


react_agent = ToolCallingAgent(
   tools           = [celsius_to_fahrenheit, PrimeTool(), MemoTool()],
   model           = engine,
   max_steps       = 5,
   verbosity_level = 1,
)


console.print("n[bold yellow]Task 4:[/bold yellow]")
result4 = react_agent.run(
   "Then retrieve both facts and summarise them."
)
show("ToolCallingAgent — Task 4", result4)


section("SECTION 7 · Multi-Agent Orchestration  (v1.8+ API)")


math_agent = CodeAgent(
   tools           = [PrimeTool()],
   model           = engine,
   max_steps       = 4,
   name            = "math_specialist",
   description     = "Handles mathematical questions and primality checks.",
   verbosity_level = 0,
)


research_agent = ToolCallingAgent(
   tools           = [DuckDuckGoTool(), MemoTool()],
   model           = engine,
   max_steps       = 4,
   name            = "research_specialist",
   description     = "Searches the web and stores or retrieves facts from memory.",
   verbosity_level = 0,
)


manager_agent = CodeAgent(
   tools           = [],
   model           = engine,
   managed_agents  = [math_agent, research_agent],
   max_steps       = 8,
   verbosity_level = 1,
)


console.print("n[bold yellow]Task 5:[/bold yellow]")
result5 = manager_agent.run(
   "Find out what year Python was first released (use research_specialist), "
   "then check whether that year is a prime number (use math_specialist)."
)
show("Manager Agent — Task 5", result5)