Build Your First AI Agent in 60 Lines of Python — No Framework Needed

Everyone's talking about AI agents, but most tutorials start with heavyweight frameworks, API keys, and 500+ lines of boilerplate.

What if you could build a functional AI agent in just 60 lines of pure Python?

No LangChain. No CrewAI. No framework at all.

Let's do it.

What We're Building

A simple AI agent that can:

• Take a goal as input
• Break it into subtasks
• Execute each subtask using tools
• Return a final result

Think of it as the minimal viable agent — the skeleton you can extend into anything.

The Architecture

Our agent follows the classic Observe → Think → Act loop:

┌─────────────┐
│   USER GOAL │
└──────┬──────┘
       │
       ▼
┌──────────────┐
│  THINK (LLM) │◄──────┐
└──────┬───────┘       │
       │               │
       ▼               │
┌──────────────┐       │
│  ACT (Tool)  │───────┘
└──────┬───────┘
       │
       ▼
┌──────────────┐
│    RESULT    │
└──────────────┘

The Code (60 Lines)

import json
import os
from anthropic import Anthropic

client = Anthropic()

# Define tools the agent can use
tools = [
    {
        "name": "calculator",
        "description": "Performs arithmetic calculations",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {"type": "string", "description": "Math expression to evaluate"}
            },
            "required": ["expression"]
        }
    },
    {
        "name": "search_notes",
        "description": "Search through local notes/files",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "Search query"}
            },
            "required": ["query"]
        }
    }
]

def execute_tool(name, input_data):
    if name == "calculator":
        try:
            return str(eval(input_data["expression"]))
        except:
            return "Error: Invalid expression"
    elif name == "search_notes":
        # Simulate search — replace with real implementation
        return f"Found 3 notes matching '{input_data['query']}'"
    return "Unknown tool"

def run_agent(goal, max_steps=5):
    messages = [{"role": "user", "content": goal}]
    system = "You are an AI agent. Use the provided tools to accomplish the user's goal. When done, provide a final answer."

    for step in range(max_steps):
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            system=system,
            tools=tools,
            messages=messages
        )

        # Check if agent wants to use a tool
        if response.stop_reason == "tool_use":
            tool_block = next(b for b in response.content if b.type == "tool_use")
            result = execute_tool(tool_block.name, tool_block.input)
            messages.append({"role": "assistant", "content": response.content})
            messages.append({"role": "user", "content": [{"type": "tool_result", "tool_use_id": tool_block.id, "content": result}]})
            print(f"Step {step+1}: Used {tool_block.name} → {result}")
        else:
            # Agent is done
            final = next(b.text for b in response.content if hasattr(b, "text"))
            print(f"\nAgent Result: {final}")
            return final

    return "Max steps reached"

# Run it
run_agent("What is 15% of 847, then round to nearest integer?")

How It Works

Lines 1-4: Import dependencies. We only need the Anthropic SDK.

Lines 6-30: Define tools as JSON schemas. Claude understands these natively — no wrapper needed.

Lines 32-40: Tool execution. Dead simple if/else. Replace with real implementations (API calls, database queries, file operations).

Lines 42-65: The agent loop. This is the core. Send messages → check if Claude wants a tool → execute → feed result back → repeat.

Why This Matters

Every "agent framework" is essentially wrapping this exact loop with abstractions. Understanding the raw pattern means:

1. You debug faster — no framework magic to untangle
2. You extend easier — add tools by adding elif blocks
3. You own the code — no dependency updates breaking your agent

What to Build Next

From this 60-line skeleton, you can build:

• A personal assistant — add calendar, email, and file tools
• A code reviewer — add git diff and lint tools
• A content pipeline — add publishing APIs as tools (I use this exact pattern to automate my content across 6 platforms)
• A data analyst — add SQL and chart tools

The Takeaway

You don't need a framework to build AI agents. You need:

1. An LLM that supports tool use (Claude, GPT-4, etc.)
2. A loop that feeds tool results back
3. Tools defined as JSON schemas

That's it. 60 lines. No magic.

---

I'm Archit — I automate chaos. Follow me for more practical AI automation tutorials.

Currently building a system that runs scheduled AI agents across 6 platforms daily with zero human intervention. More on that soon.