A Tour of Agent Frameworks

A new agent framework seems to appear each week. Which should you learn? Here's the secret. They're all wrappers around the loop that you built by hand. So you can read any of them in an afternoon, because you already know what they must do.

• A new framework each week
• They all wrap the same loop
• You already know the core

The main options

Here's a quick map. LangGraph gives you control, with graphs, checkpoints, and approvals. CrewAI is role based, and quick to prototype. The Open AI Agents SDK is light, built around handoffs. Google's ADK suits Gemini and Google Cloud. Pydantic AI is type safe, for Python developers. And the Claude Agent SDK is built around a powerful coding agent loop. They change quickly, so check the docs.

Start with no framework

Remember how little you need. This is a working tool agent, in ten lines, using only the model's own library. Run it. Before you add a framework, ask what it's giving you that this doesn't. If the answer is checkpoints, approvals, or streaming, then great, go ahead. If the answer is that everybody else uses it, wait.

from google import genai
from google.genai import types
from shop import check_stock

client = genai.Client()
reply = client.models.generate_content(
    model="gemini-flash-latest",
    config=types.GenerateContentConfig(tools=[check_stock]),
    contents="Is the Helmet in stock? Answer in five words.")
print(reply.text)

Helmet is out of stock.

ORDERS = {
    "A17": {"item": "Carbon wheelset", "price": 640, "status": "delivered", "days_ago": 12},
    "B42": {"item": "Chain", "price": 28, "status": "shipped", "days_ago": 2},
    "C09": {"item": "Helmet", "price": 95, "status": "delivered", "days_ago": 45},
}
STOCK = {"Carbon wheelset": 3, "Chain": 14, "Helmet": 0}
REFUNDS = []

def get_order(order_id: str) -> dict:
    """Look up one order by its ID, such as A17."""
    return ORDERS.get(order_id, {"error": f"No order {order_id}"})

def check_stock(item: str) -> dict:
    """Return how many of an item are in stock."""
    return {"item": item, "in_stock": STOCK.get(item, 0)}

def refund(order_id: str, amount: float) -> dict:
    """Refund money to the customer for an order."""
    REFUNDS.append((order_id, amount))
    return {"refunded": amount, "order_id": order_id}

class Scripted:
    """A stand-in model that replays a fixed list of replies."""
    def __init__(self, replies):
        self.replies = list(replies)
        self.calls = 0

    def ask(self, messages):
        self.calls += 1
        return self.replies.pop(0)

How to choose

Here are the questions to ask. How much control do you need? Do you need durable runs, and approvals? Which model and cloud are you tied to? Can your team debug it? And can you leave? Keep your tools and prompts as plain code and text, so that you can move them. Your tools and your test set are your real assets. The framework isn't.

Summary