How to Build a Multi-Agent Restaurant Order System with Claude API (Step-by-Step)

What You'll Build

If you've ever wanted to build a multi-agent restaurant order system with Claude, you're in the right place. Most restaurant operations still rely on staff to manually relay orders, check stock, and notify the kitchen — which means errors, delays, and a lot of unnecessary chaos.

In this tutorial, you'll build a 3-agent pipeline in Python that takes a customer order as JSON input, validates it, checks inventory availability, and fires a kitchen notification — all automatically using the Claude API.

By the end, you'll have a fully working local system you can extend into a real restaurant automation tool. No prior AI experience required.

Prerequisites

Python 3.9 or higher installed
An Anthropic API key (get one at console.anthropic.com)
Basic Python knowledge — if you've written a function before, you're good
anthropic Python SDK installed (pip install anthropic)
A text editor or IDE (VS Code works great)

📦 Full Source Code Note: The complete, working code for this project is built step-by-step in the sections below. Every snippet connects to the next one. By Step 6, you'll have the entire system running. Copy each block as we go and you'll have a complete file at the end.

Full Source Code Overview

The project lives in a single file called restaurant_agents.py. It contains a main orchestrator class, three agent functions, tool definitions, and a run loop that handles Claude's tool call responses.

Here's the file structure we're building toward before we dive into each piece:

project structure

restaurant-agent-system/
├── restaurant_agents.py   # Main file — everything lives here
├── .env                   # Stores your ANTHROPIC_API_KEY
└── requirements.txt       # Just one dependency: anthropic

Create a folder called restaurant-agent-system, then open a terminal inside it and run:

terminal

pip install anthropic python-dotenv

Create a .env file in that folder with your key:

.env

ANTHROPIC_API_KEY=sk-ant-your-key-here

Step 1: Set Up Claude API and Project Structure

Let's start by wiring up the Anthropic client and building the skeleton of our orchestrator class. This class will hold all three agents and coordinate how they talk to each other.

Open restaurant_agents.py and add this at the top:

restaurant_agents.py

import os
import json
from anthropic import Anthropic
from dotenv import load_dotenv

load_dotenv()

client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

# Simulated inventory database — replace with a real DB in production
INVENTORY = {
    "margherita_pizza": 8,
    "caesar_salad": 5,
    "spaghetti_carbonara": 3,
    "tiramisu": 10,
    "sparkling_water": 20,
}

# Tracks notifications sent to the kitchen during this session
KITCHEN_LOG = []


class RestaurantAgentSystem:
    """Orchestrates the three-agent order processing pipeline."""

    def __init__(self):
        self.model = "claude-sonnet-4-6"
        self.order_agent_system = (
            "You are an order processing agent for an Italian restaurant. "
            "Your job is to validate customer orders, extract structured data, "
            "and use tools to check inventory and notify the kitchen. "
            "Always check inventory before confirming an order."
        )

    def run(self, raw_order: dict) -> dict:
        """Entry point — takes a raw order dict and returns a final result."""
        print(f"\n[Orchestrator] New order received: {json.dumps(raw_order, indent=2)}")
        result = self._run_order_agent(raw_order)
        return result

The INVENTORY dict acts as our mock database for now. In a real system you'd swap this out for a Postgres query or a POS API call. The KITCHEN_LOG list collects every notification the kitchen agent sends so you can inspect the full pipeline output at the end.

Step 2: Define the Order Processing Agent

The order processing agent is the brain of the system. It reads the raw customer order, parses it into a clean structure, and decides which tools to call next.

Add this method inside the RestaurantAgentSystem class: