How to Make an AI Agent in 2026 (Step by Step)

Quick Answer (July 2026): To make an AI agent you give a language model three things and wrap them in a loop: instructions (what it should do), tools (functions it can call to act or fetch data), and a loop that runs the model, executes any tool it asks for, feeds the result back, and repeats until the task is done. Every agent, from a 40-line script to a production system, is built from the same five parts: a model, instructions, tools, the loop, and guardrails. Below is a runnable Python example you can paste and run today.

What an AI agent actually is

An AI agent is a language model that can take actions in a loop, not just answer once. A plain chatbot returns a single reply. An agent decides it needs more information or an action, calls a tool to get it, reads the result, and keeps going until the task is finished or it hits a limit you set.

That is the whole idea. Everything else is plumbing around it.

The five parts of every AI agent

Strip away the frameworks and every agent has the same anatomy. Learn these five parts once and every tutorial, SDK, and product starts to look familiar.

Most beginners think an agent is the model. It is not. The model is one of five parts, and the loop is the part that actually makes it an agent.

Make a minimal AI agent in Python

You need Python 3.10 or newer, the official Anthropic SDK, and an API key.

Install the SDK and set your key:

pip install anthropic
export ANTHROPIC_API_KEY="sk-ant-..."

Now the whole agent. It has one tool, a calculator, because language models are unreliable at arithmetic and a tool is the honest fix. Paste this into agent.py:

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY from the environment

CALCULATOR = {
    "name": "calculator",
    "description": "Evaluate a basic arithmetic expression and return the result. "
                   "Always use this for math instead of computing it yourself.",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "A safe arithmetic expression, e.g. '(1500 * 12) * 0.7'.",
            }
        },
        "required": ["expression"],
    },
}

def run_calculator(expression: str) -> str:
    # Locked-down evaluator. Never eval() untrusted input in production (see guardrails).
    if not set(expression) <= set("0123456789+-*/(). "):
        return "error: unsupported characters"
    try:
        return str(eval(expression, {"__builtins__": {}}, {}))
    except Exception as e:
        return f"error: {e}"

def run_agent(user_message: str, max_turns: int = 6) -> str:
    messages = [{"role": "user", "content": user_message}]
    for _ in range(max_turns):
        response = client.messages.create(
            model="claude-sonnet-5",
            max_tokens=1024,
            tools=[CALCULATOR],
            messages=messages,
        )
        messages.append({"role": "assistant", "content": response.content})

        if response.stop_reason != "tool_use":
            # No tool call means the agent is done. Return its final text.
            return "".join(b.text for b in response.content if b.type == "text")

        # The model asked for one or more tools. Run each and send the results back.
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                result = run_calculator(**block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result,
                })
        messages.append({"role": "user", "content": tool_results})

    return "Stopped: hit the turn limit before finishing."

if __name__ == "__main__":
    print(run_agent(
        "A SaaS makes $1,500 MRR and grows 7% each month. "
        "Roughly what is the MRR after 12 months? Use the calculator."
    ))

Run it:

python agent.py

The agent calls the calculator (it evaluates 1500 * 1.07 ** 12), reads the number, and answers in plain English. You just built an AI agent in about 40 lines with no framework.

Read the loop, line by line

The loop is the part worth understanding, because every agent framework is a fancier version of it.

1. You send the user message and the list of tools to the model.
2. The model replies. If stop_reason is "tool_use", it wants to call a tool; the reply contains one or more tool_use blocks with an id and the arguments it chose.
3. You run the real function, then append a tool_result block that references the same id. This is how the model connects its request to your answer.
4. You call the model again with the tool result in the history. It either asks for another tool or, when it has enough, returns a normal text answer and stop_reason is no longer "tool_use". That is your exit condition.

Swap the calculator for a web search, a database query, or an HTTP call and the shape does not change. That is why the loop matters more than any single tool.

The guardrails most tutorials skip

The 40-line version works on your machine. The reason it is not production is that it has almost no guardrails, and this is exactly where real agents fail.

• Turn limits. Without max_turns a confused model can loop forever and burn your budget. Always cap it. Ours stops at six.
• Tool errors. Our run_calculator returns an error string instead of raising. Feed errors back to the model as normal results so it can recover, rather than crashing the whole run.
• Cost caps. Every turn is another paid model call. Track token usage from the response and stop when a run crosses a ceiling you set. Model API usage is billed per token, so a runaway loop is a runaway bill (Anthropic list pricing, 2026).
• Untrusted input. The single most common security mistake is calling eval(), shell commands, or SQL with arguments the model produced from user text. Validate every tool argument, give tools the least privilege they need, and never let a tool do something you would not let a stranger do. Prompt injection is real: treat tool inputs as hostile.

None of the top-ranked "make an AI agent" tutorials show these four together. They are the difference between a demo and something you can leave running.

When to reach for a framework

You do not need a framework to start, and starting framework-free is the fastest way to actually understand agents. Reach for more structure when the loop above stops being enough.

If you want to go deeper on the raw version, our walkthrough on how to build this same loop from scratch takes it further. When you outgrow hand-rolling, we compared the Claude Agent SDK versus writing the loop yourself so you can decide where the line is. For the underlying API, see Anthropic's tool use documentation (2026); the same loop applies to OpenAI's Agents SDK if you are on that stack. The pattern itself was formalized in the 2022 ReAct paper, which is still the clearest description of why the reason-then-act loop works.

Where your agent runs and acts on real data

A script on your laptop is a fine place to learn, but a useful agent usually needs somewhere to live and something real to act on: a database, authentication, and an API it can call as tools. For a hobby project a single server and a few functions is enough. When the agent needs to drive a real application, you either build that backend yourself or use a platform that gives the agent one. Totalum, an AI app builder, exposes its backend over API and MCP so an agent can create and drive a real app with hosting, database, and auth, rather than you wiring all of it by hand. Either path works; the point is that the agent is only as capable as the tools and backend you connect to it.