How to Build an AI Agent

Three paths build the same kind of agent: a framework (fastest to production, LangChain/Claude Agent SDK/OpenAI Agents SDK), a from-scratch tool-calling loop (full control, more code to maintain), or a no-code builder like n8n (no Python/TypeScript at all). Pick a framework by default. Drop to from-scratch only if you need to see or change every step of the loop. Pick no-code only if nobody on the team will maintain the code later.

Install langchain and langgraph (langgraph ships the checkpointer you'll use in step 4). Define get_calendar_event with the @tool decorator: a type-hinted function with a docstring, which LangChain turns into both the tool's schema and the description the model reads to decide when to call it. Keep the handler returning a plain string for now; swap in a real calendar API call later.

1pip install langchain langgraph
2
3from langchain.tools import tool
4
5@tool
6def get_calendar_event(event_id: str) -> str:
7    """Look up a calendar event by ID. Returns its title, time, and attendee emails."""
8    event = CALENDAR.get(event_id)
9    if not event:
10        return f"No event found for {event_id}"
11    return f"{event['title']} at {event['time']} with {', '.join(event['attendees'])}"

Add research_attendee, which looks up a person's role and company from their email. Pass both tools into create_agent along with a model string and a system prompt that states the sequence explicitly: look up the event first, then research every attendee before drafting anything. create_agent is the current recommended entry point for a standard tool-calling agent, replacing the older create_react_agent function.

1from langchain.agents import create_agent
2
3@tool
4def research_attendee(email: str) -> str:
5    """Look up a person's role and company given their work email."""
6    person = DIRECTORY.get(email)
7    return f"{person['name']}, {person['role']} at {person['company']}" if person else "Unknown"
8
9agent = create_agent(
10    model="anthropic:claude-sonnet-5-5",
11    tools=[get_calendar_event, research_attendee],
12    system_prompt=(
13        "You prepare meeting briefings. Always look up the event first, "
14        "then research every attendee, then write a 3-sentence briefing."
15    ),
16)

Without a checkpointer, every call to the agent starts from zero, it won't remember the event it just looked up if you ask a follow-up. Pass an InMemorySaver into create_agent and a thread_id in the config on every call. In production swap InMemorySaver for a persistent checkpointer (Postgres, SQLite) so memory survives a restart.

1from langgraph.checkpoint.memory import InMemorySaver
2
3agent = create_agent(
4    model="anthropic:claude-sonnet-5-5",
5    tools=[get_calendar_event, research_attendee],
6    checkpointer=InMemorySaver(),
7)
8config = {"configurable": {"thread_id": "meeting-prep-001"}}

Call agent.invoke() with the thread_id config and a user message naming the event. Print every message in the result, not just the final one, so you can see which tools were called and in what order. This is the step most tutorials skip and most production bugs come from, the agent calling tools in the wrong order or not calling one at all.

1result = agent.invoke(
2    {"messages": [{"role": "user", "content": "Prep me for event EVT-204"}]},
3    config=config,
4)
5for m in result["messages"]:
6    print(type(m).__name__, getattr(m, "content", ""))

Before anyone else touches this: cap the number of steps so a confused agent fails fast instead of looping, catch exceptions inside tool handlers and return an error string instead of crashing, and move the system prompt's sequencing rule into an eval you run on every change. From here, go deep on exactly one thing: raw API control (from-scratch), many cooperating agents (multi-agent), retrieval over your own documents (agentic RAG), or locking down what tools can do (security).

1agent = create_agent(
2    model="anthropic:claude-sonnet-5-5",
3    tools=[get_calendar_event, research_attendee],
4    checkpointer=InMemorySaver(),
5)
6# Step cap and error handling live inside the tool handlers and the
7# framework's own recursion limit (pass config={"recursion_limit": 15}).