Build Your First Autonomous AI Agent in a Weekend

A genuinely useful autonomous agent is a weekend project in 2026 - if you keep the scope tight and the loop disciplined. This guide builds the official LangGraph quickstart agent verbatim (with one swap: it runs against your local Ollama), then adds memory and a human-in-the-loop permission gate. No pseudo-code, no framework roulette: this is the canonical scaffold, documented.

The mental model

An agent is: a model, a loop, tools, memory, and a permission layer. Almost all failures - agentic runaway, hallucinations on tool results, prompt injection - live in one of those five boxes. Respect them.

Step 1: Install the stack

uv init
uv add langchain langchain-openai langgraph

This installs the framework that now documents itself as “build resilient agents” - the low-level graph primitives behind most production agent stacks in 2026. Running against your local model from our Ollama guide:

from langchain_openai import ChatOpenAI

model = ChatOpenAI(
    base_url="http://localhost:11434/v1",  # your local Ollama
    model="deepseek-v4-flash",
    temperature=0,
)

Step 2: Define tools and bind them

Keep the surface small - every tool is a new attack surface for prompt injection and a new failure mode to debug. Two well-typed tools beat ten loose ones.

from langchain.tools import tool

@tool
def multiply(a: int, b: int) -> int:
    """Multiply `a` and `b`."""
    return a * b

@tool
def add(a: int, b: int) -> int:
    """Adds `a` and `b`."""
    return a + b

tools = [add, multiply]
tools_by_name = {tool.name: tool for tool in tools}
model_with_tools = model.bind_tools(tools)

Step 3: State and the two nodes

State persists through the whole run. We use operator.add so messages append instead of replacing - the agent’s full history survives each loop iteration.

from langchain.messages import AnyMessage, SystemMessage, ToolMessage
from typing_extensions import TypedDict, Annotated
import operator

class MessagesState(TypedDict):
    messages: Annotated[list[AnyMessage], operator.add]

def llm_call(state: MessagesState):
    """LLM decides whether to call a tool or not."""
    return {"messages": [model_with_tools.invoke(state["messages"])]}

def tool_node(state: MessagesState):
    """Performs the tool calls."""
    result = []
    for tool_call in state["messages"][-1].tool_calls:
        tool = tools_by_name[tool_call["name"]]
        observation = tool.invoke(tool_call["args"])
        result.append(ToolMessage(content=observation, tool_call_id=tool_call["id"]))
    return {"messages": result}

Step 4: Wire the loop and compile

If the last message carries tool calls, route back to the tool node; otherwise stop. That conditional edge is the entire ReAct loop, made explicit.

from typing import Literal
from langgraph.graph import StateGraph, START, END

def should_continue(state: MessagesState) -> Literal["tool_node", END]:
    if state["messages"][-1].tool_calls:
        return "tool_node"
    return END

agent_builder = StateGraph(MessagesState)
agent_builder.add_node("llm_call", llm_call)
agent_builder.add_node("tool_node", tool_node)
agent_builder.add_edge(START, "llm_call")
agent_builder.add_conditional_edges("llm_call", should_continue, ["tool_node", END])
agent_builder.add_edge("tool_node", "llm_call")

agent = agent_builder.compile()

Step 5: Memory and the human gate

Two additions turn this from a demo into something you can leave running:

• Memory: attach a checkpointer from langgraph.checkpoint.memory so the agent recalls this session later - the official “memory & persistence” page shows the one-line change.
• Human gate: wrap any write/delete tool in an interrupt() - the graph pauses mid-run, you approve in your terminal, and it resumes. Read-only tools skip the gate.

Step 6: Ship it safe

Log every tool call with payloads and a trace ID. If your agent touches the network or the filesystem, run it inside Docker’s Sandboxes - disposable microVMs with filesystem and network controls built for exactly this - never on your bare host.

When you’re done

You have a stateful, safe, extensible agent that can answer research questions with citations from live search - the same pattern underpinning today’s enterprise agent platforms, and the same code path the official docs teach. This is Terminal-Bench 2.1’s test subject, and now it’s yours.