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:
- You debug faster — no framework magic to untangle
- You extend easier — add tools by adding elif blocks
- 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:
- An LLM that supports tool use (Claude, GPT-4, etc.)
- A loop that feeds tool results back
- 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.