Build Your First AI Agent from Scratch

What We’re Building

A simple AI agent that can:

• Search for information in files
• Perform calculations
• Answer questions with context

Prerequisites

• Python 3.10+
• Claude API key (get one at console.anthropic.com)

Step 1: Project Setup

mkdir my-agent && cd my-agent
python -m venv venv
source venv/bin/activate
pip install anthropic

Step 2: Define the Tools

# agent.py
import anthropic
import json
import os

client = anthropic.Anthropic()

tools = [
    {
        "name": "read_file",
        "description": "Reads the contents of a file at the given path",
        "input_schema": {
            "type": "object",
            "properties": {
                "path": {
                    "type": "string",
                    "description": "Path to the file"
                }
            },
            "required": ["path"]
        }
    },
    {
        "name": "calculate",
        "description": "Evaluates a mathematical expression",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {
                    "type": "string",
                    "description": "Math expression, e.g.: 2 + 2 * 3"
                }
            },
            "required": ["expression"]
        }
    },
    {
        "name": "list_files",
        "description": "Lists files in a directory",
        "input_schema": {
            "type": "object",
            "properties": {
                "directory": {
                    "type": "string",
                    "description": "Path to the directory"
                }
            },
            "required": ["directory"]
        }
    }
]

Step 3: Implement Tool Execution

def execute_tool(name: str, input_data: dict) -> str:
    """Execute a tool and return the result."""
    if name == "read_file":
        try:
            with open(input_data["path"], "r") as f:
                return f.read()
        except FileNotFoundError:
            return f"File not found: {input_data['path']}"

    elif name == "calculate":
        try:
            result = eval(input_data["expression"], {"__builtins__": {}})
            return str(result)
        except Exception as e:
            return f"Calculation error: {e}"

    elif name == "list_files":
        try:
            files = os.listdir(input_data["directory"])
            return "\n".join(files)
        except FileNotFoundError:
            return f"Directory not found: {input_data['directory']}"

    return f"Unknown tool: {name}"

Step 4: The Agentic Loop — The Heart of the Agent

def run_agent(user_message: str, max_iterations: int = 10):
    """Run the agent loop."""
    messages = [{"role": "user", "content": user_message}]

    system = """You are a helpful AI agent. You can read files,
    perform calculations, and answer questions.
    Use tools when needed. Be concise."""

    for i in range(max_iterations):
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=4096,
            system=system,
            tools=tools,
            messages=messages,
        )

        messages.append({"role": "assistant", "content": response.content})

        # If the model finished — return text
        if response.stop_reason == "end_turn":
            for block in response.content:
                if hasattr(block, "text"):
                    return block.text
            return "Agent finished without a text response."

        # If the model wants to call tools
        if response.stop_reason == "tool_use":
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    print(f"  Tool: {block.name}({json.dumps(block.input)})")
                    result = execute_tool(block.name, block.input)
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": result,
                    })

            messages.append({"role": "user", "content": tool_results})

    return "Max iterations reached."

Step 5: Run It

if __name__ == "__main__":
    while True:
        user_input = input("\nYou: ")
        if user_input.lower() in ("quit", "exit"):
            break
        print(f"\nAgent: {run_agent(user_input)}")

Testing

export ANTHROPIC_API_KEY=sk-ant-...
python agent.py

You: List the files in the current directory and count them

  Tool: list_files({"directory": "."})
  Tool: calculate({"expression": "5"})

Agent: There are 5 files in the current directory:
1. agent.py
2. venv
3. requirements.txt
4. data.csv
5. README.md

What’s Next

This is a basic agent. To make it production-ready:

1. Add error handling and retry logic
2. Add logging
3. Restrict filesystem access
4. Add more tools (HTTP requests, database)
5. Consider MCP servers for standardized integration