Build an AI Agent in 60 Lines of Python Before Reaching for LangChain

Watch: Build an AI Agent From Scratch in Python - Tutorial for Beginners

Why You Should Write the 60‑Line Agent Yourself

Understanding the agent loop stopped being optional the moment you tried to change one thing in a framework demo and couldn't find where the loop lived. Quickstarts run fine until you need to touch them. A short script you write yourself fixes that, because every decision your agent makes sits in code you can read in one sitting.

If you're learning how to build AI agents for real work, start with the loop. In our experience, developers who skip this step can run a quickstart but stall on the first bug. They've never watched a tool call go out and a result come back.

: a cycle where the model picks a tool, your code runs it, and the result goes back to the model. The cycle ends when the model answers without asking for a tool.

The model never executes anything. It sends back a request with a function name and arguments, and your application does the work. That leaves you three jobs:

The orchestration is small: the agent receives a query, decides which tools to call, runs them, and uses the results to answer. Memory barely adds to that, since memory here is the same messages list carried between calls. You can read the loop and know exactly how many requests you're paying for.

Add the one line some demos leave out: an iteration cap. A bare 

 loop never exits if the model keeps requesting tools. A cap with a fixed failure string also gives your tests something concrete to assert on.

When Should You Outgrow the Plain Script?

Keep the plain script while you have one agent on one provider. Move past it when you reuse the loop across several agents or switch model providers.

A raw script ties you to one provider's message format, down to its stop-reason and tool-ID fields. Providers also retire model names, so a hardcoded string eventually becomes a bug.

One recent preprint describes direct API integration as a "suboptimal approach" and makes efficiency claims for its own framework. Two caveats. The paper hadn't cleared peer review. The lesson worth keeping is narrower than the headline: once the script starts to grow, separate provider configuration, tools, output schema, and memory.

You should be able to point at the line where the model asks for a tool and the line where your code answers. That's the test for anyone learning how to build AI agents. In this script, look for 

 to your API key. The tool is a mock, so you can watch the loop work before you wire in a real API.

import json, os
from huggingface_hub import InferenceClient

# --- Config: everything provider- or model-specific ---
MODEL = os.environ.get("AGENT_MODEL", "moonshotai/Kimi-K2-Thinking")
MAX_ITERATIONS = 6  # stop if the model keeps requesting tools.
MAX_TURNS = 5  # short-term memory: last N user exchanges.
SYSTEM = "You are a concise assistant. Call a tool when you need live data."

# --- Helpers: the tool and the schema the model reads ---
def get_temperature(city: str) -> str:  # mock; swap in a real API call.
 temps = {"san francisco": 72, "paris": 75, "tokyo": 73}
 return f"{temps.get(city.lower(), 70)} degrees Fahrenheit"

TOOLS = {"get_temperature": get_temperature}
SCHEMAS = [{"type": "function", "function": {"name": "get_temperature",
 "description": "Get the current temperature in a given city.",
 "parameters": {"type": "object", "required": ["city"],
 "properties": {"city": {"type": "string"}}}}}]

# --- Agent: observe, think, act ---
class Agent:
 def __init__(self):
 self.client = InferenceClient(model=MODEL, api_key=os.environ["HF_TOKEN"])
        self.messages = [{"role": "system", "content": SYSTEM}]

 def __call__(self, query: str) -> str:
        self.messages.append({"role": "user", "content": query})
        self._trim()
        for _ in range(MAX_ITERATIONS):
            resp = self.client.chat.completions.create(messages=self.messages, tools=SCHEMAS)
            msg = resp.choices[0].message
            if not msg.tool_calls:  # no tool request means a final answer.
                self.messages.append({"role": "assistant", "content": msg.content})
                return msg.content
            calls = [{"id": c.id, "type": "function", "function": {
 "name": c.function.name, "arguments": c.function.arguments}}
                for c in msg.tool_calls]
            self.messages.append({"role": "assistant", "content": msg.content or "", "tool_calls": calls})
            for c in calls:
                self.messages.append({"role": "tool", "tool_call_id": c["id",
                "content": self.execute(c["function"])})
        return "Stopped after max iterations without a final answer."

    def execute(self, fn: dict) -> str:
        try:
            return str(TOOLS[fn["name"]](json.loads(fn["arguments"])))
        except Exception as e:  # report failures to the model instead of crashing.
            return f"Tool error: {e}"

    def _trim(self):
        starts = [i for i, m in enumerate(self.messages) if m["role"] == "user"]
        if len(starts) > MAX_TURNS:
            self.messages = self.messages[:1] + self.messages[starts[-MAX_TURNS]:]

if __name__ == "__main__":  # CLI entry point; an empty line exits.
    agent = Agent()
    while query := input("> ").strip():
        print(agent(query))

How the Four Blocks Map to Observe, Think, Act

The config block holds everything that will change. One widely followed from-scratch tutorial hardcodes its model name in the client call, and the same tutorial warns that not every model supports function calling (the model's ability to return a structured tool request instead of plain text). That's why 

 comes from the environment. You can swap models without touching the code.

The helpers block holds the tool and its schema, the JSON description that is all the model ever sees of your tool. Spell out units in the tool's return value. In one published run, a mock tool returned a bare "72" and the model added "degrees Fahrenheit" on its own. Fine for a weather demo. Less fine when the number is a timeout and nobody said whether it's seconds or milliseconds.

 class handles the request and response. The model reads 

 runs the local function. Arguments arrive as a JSON string, so 

 unpacks the result into the tool function. The 

 block turns malformed input or a failed HTTP call into text the model can read, instead of killing the process.

The last block is a small command-line interface. Because that shell sits apart from the agent, you can swap interactive input for a web request, a scheduled job, or a test harness.

 drops older exchanges at user-message boundaries, so a tool result never outlives the request it answered.

The Message Format Is Where Providers Split

, and arguments as a JSON string. Another provider's SDK signals tool use with 

. The control flow looks the same. The messages don't line up.

That boundary is the natural spot for an adapter, a thin layer that translates between your loop and one provider's format. Put provider-specific request building and response parsing behind a small interface, and leave the tool registry and application logic alone. With only one provider, you can skip the adapter for now and keep the example easy to read.

A lightweight framework can help when several backends or agents share infrastructure. Even then, the completion call and 

Test and Debug the Agent Before You Extend It

Make the first regression test an order lookup. Add 

, and assert the model requests the tool before it answers. In this script's format, the signal is a non-empty 

 with a function name and arguments. Your code runs 

, and the next response carries the grounded answer (one built from the tool's data rather than the model's guess).

We use that query as a smoke test because the correct behavior is easy to state. Without tools, the model either admits it doesn't know or invents a plausible status. With the schema attached, it pauses and asks for the lookup. Any other pattern in your logs usually points to a bug, and tracing those bugs is most of what learning 

Run these checks as tests before you extend the script:

Check the ID match in every tool-result test. On one major provider's schema, every 

 of the request it answers. Other providers call that field 

 and send arguments as a JSON string you have to parse. Code copied between SDKs often fails right here. Finally, check the model string: one provider has announced it will retire the model used in a widely shared tutorial on November 30, 2026. With the name in an environment variable, that becomes a config change instead of a code rewrite.

When Should You Split the Script Into Modules?

If you try a framework like that, measure its orchestration overhead before you commit.

A good halfway step is a provider interface, a separate tool registry, an output schema, and a memory component you can test on its own. Replace one part at a time. When something fails, you'll know it was the part you just changed.

When to Graduate to LangChain, and Where the newline AI Bootcamp Fits

Graduating pays off when the same loop shows up in a second project and the two copies start to drift. Until then, the 60-line script stays easy to inspect, because every request, tool result, and stopping decision is visible.

Most guides on how to build AI agents treat the framework jump as a rite of passage. We treat it as a cost you take on once specific signals appear.

One agent, one provider, and a few tools don't justify a dependency.

Independent tutorials make a narrower point. A Machine Learning Mastery walkthrough describes the core of an agent as a model, a loop that manages the interaction, and a small set of well-defined functions. It calls 

 a reasonable move, eventually, and argues that writing the loop from scratch first makes the underlying architecture clear.

That order gives you a migration plan instead of a forced rewrite. Pull out the tool definitions, the request-execute-respond cycle, and context handling as each one grows its own job. Bring in a framework after those boundaries already match what your project needs.

Our AI Bootcamp Picks Up Where the Script Ends

We built our AI Bootcamp for developers who can follow a tutorial but stall when they apply it to a real project. Like our other courses, it's project-based and includes complete source code, full transcripts with code snippets, and a Discord community.

Check the current syllabus for exact framework coverage before you enroll. We don't promise specific LangChain modules or graduate outcomes here. If one working agent is all you need, the script you already wrote is enough.

Why does the 60-line script throw errors when I paste it and run it?

The version above is corrected; an older copy had typos that broke it. In any paste, check that 

 are called, and that tool arguments are unpacked with 

The smoke test uses a different provider's message format than the script does. The script, through 

 and pairs each result with its request by 

 belong to another provider's SDK. The order-status query also needs a 

 function, which the script never defines. Add it to 

Does the agent remember earlier conversations after I restart it?

Memory lasts only while the process runs. It is the 

 object, so quitting the CLI erases it. Within a session, 

 and cuts only at user messages, which keeps each tool result next to its request. Saving history across restarts is code you'd write yourself.

Does the Newline AI Bootcamp teach LangChain?

The article doesn't promise specific LangChain coverage, so check the current syllabus before you enroll. The bootcamp is project-based and aimed at developers who stall when moving from tutorials to real projects. If you run one agent on one provider, you don't need a course.

AUTHOR

Dr. Dipen

Watch: Build an AI Agent From Scratch in Python - Tutorial for Beginners by Tech With Tim Understanding the agent loop stopped being optional the moment you tried to change one thing in a framework demo and couldn't find where the loop lived. Quickstarts run fine until you need to touch them. A…

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Free Tools

Build an AI Agent in 60 Lines of Python Before Reaching for LangChain

Tags

Responses (0)

Free AI Career Tools

AI Job Listings

ATS Resume Checker

Startup Perks

Masterclasses

Tutorials

Fullstack React with TypeScript