Let's Build an AI Agent That Actually Learns: A Deep Dive into LangGraph and OpenAI

Let’s be honest for a second. Most of the AI "agents" you see out there are a bit… one-dimensional. You give them a task, they execute a series of steps, and then they’re done. They don’t really learn from the experience. They’re like a brilliant but forgetful intern who needs to be told how to do everything from scratch, every single time.

What if we could build something better? What if we could design an agent that remembers what it did yesterday, learns from its mistakes, and even decides for itself how much mental energy to spend on a new problem? An agent that doesn't just execute, but evolves.

That’s exactly what we’re going to explore today. We're going under the hood to build a genuinely advanced agent using some incredible tools: LangGraph for the workflow and OpenAI for the brains. This isn't just another planner-executor loop. We're talking about an architecture that can reason, act, and most importantly, improve over time.

So grab a coffee, and let's get started.

Getting Our Tools Ready for the Build

Before we can start building our intelligent agent, we need to set up our digital workshop. Every great project starts with gathering the right tools, and this is no different.

We'll be relying on a few key libraries:

• LangGraph: Think of this as the nervous system or the flowchart for our agent. It lets us define complex, stateful workflows with loops and decision points, which is perfect for building something that does more than just go from A to B.
• LangChain & OpenAI: These are our building blocks and the core intelligence. LangChain provides handy abstractions for tools and models, while OpenAI’s models (like GPT-4o-mini in this case) provide the raw reasoning power.
• A few helpers: We'll also use libraries like networkx for creating a memory graph (more on that in a bit!) and pydantic to keep our data structures clean and predictable.

First things first, you’ll need to get your OpenAI API key. We’ll load it securely so we can talk to the models.

One of the first interesting things we do is set up three different language model instances, even if they point to the same model like gpt-4o-mini: llm_fast, llm_deep, and llm_reflect. Why? This is a deliberate design choice. It allows us to give each "mode" of the agent a different personality or configuration. For instance, the llm_fast model could be tuned for quick, simple decisions, while llm_deep could be for more complex reasoning. It gives us flexibility.

Building the Agent's Memory: A Brain Made of Notes

Here’s where things get really cool. A standard agent has the memory of a goldfish. Ours is going to have a sophisticated, interconnected brain inspired by a system called a Zettelkasten.

Imagine instead of one giant, messy notebook, you have thousands of little index cards. Each card contains a single, atomic idea. When you create a new card, you link it to other related cards. Over time, you build this incredible web of knowledge that you can traverse to find connections you never would have seen otherwise.

That’s what we're building for our agent. We'll create a MemoryGraph where:

• Each interaction is a "Note": Every time the agent completes a task, its findings are stored as a structured Note with a title, content, and tags.
• Notes are connected by meaning: We use an embedding model (text-embedding-3-small) to turn the text of each note into a vector (a list of numbers). This allows us to find notes that are semantically similar, even if they don't use the exact same words.
• The graph evolves: When a new note is added, our system automatically searches for related notes and creates links between them.

This gives our agent a long-term memory. It can search for past experiences, find out what it learned from a similar task, and even explore neighboring ideas in its own "mind." It's a huge step up from starting fresh every time.

Giving Our Agent a Toolbox to Work With

An agent that can only "think" is pretty limited. To be useful, it needs to be able to interact with the world. We give it a set of tools it can call upon when needed.

For this project, we're giving it three fundamental tools:

1. web_get(url): This is its window to the internet. It can pull information from a webpage to answer questions or get up-to-date context.
2. memory_search(query): This allows the agent to query its own Zettelkasten memory graph. It can ask questions like, "What have I learned about LangGraph before?" and get back the most relevant notes from its past.
3. memory_neighbors(note_id): This is a fascinating one. It lets the agent look at a specific memory (a note) and see all the other memories directly linked to it. It’s like asking, "What other ideas are related to this one?"

By defining these tools, we’re giving the agent the ability to not only fetch new information but also to introspect on its own knowledge base.

The Agent's Internal Blueprint: Structuring Thoughts and Goals

To prevent our agent from descending into chaos, we need to give it a clear structure for its internal monologue. We use Pydantic models to define the "shape" of its thoughts and decisions. This makes its reasoning interpretable and keeps everything running smoothly.

Here are the key blueprints we define:

• RunSpec: This is the mission briefing. It outlines the goal, any constraints (e.g., "don't use this tool"), and the deliverable_format.
• DeliberationDecision: This is the output of the agent's first thinking step. It decides whether to go into fast mode or deep mode for the task at hand and explains its reason.
• Reflection: After a task is complete, this structure guides the agent's self-reflection. It prompts it to think about what worked, what failed, and what new rules it can create for itself for the future.
• AgentState: This is the global state that gets passed around the graph. It tracks everything: the original mission, the messages exchanged, the remaining budget, and more.

We also define a few simple system prompts, which act as the agent’s guiding principles. For example, DECIDER_SYS tells the model its job is to choose between fast and deep thinking, while AGENT_FAST gives it instructions for operating in its quick-and-dirty mode.

The Core Logic: A Day in the Life of Our Agent

Now we get to the heart of it all: the actual functions, or "nodes," that make up our agent's workflow in LangGraph. Each node is a distinct step in its thought process.

1. Deliberate: This is the starting point. The agent looks at the RunSpec and makes its first crucial decision: "Is this a simple task I can handle quickly, or do I need to engage my 'deep thinking' brain?" This is what we call adaptive deliberation. It’s a powerful concept that saves time and resources on easy tasks while ensuring complex ones get the attention they deserve.

2. Agent: Now it's time to act. Based on the deliberation, this node invokes either the llm_fast or llm_deep model. It takes the current state and the user's goal and decides what to do next—which might be to call a tool or to formulate an answer.

3. Tools Node: If the agent decides it needs to use a tool (like searching the web or its memory), this node gets called. It executes the tool function and returns the result back to the agent so it can continue its work. We also enforce a budget here, making sure the agent doesn't get stuck in an endless loop of tool calls.

4. Finalize: Once the agent believes it has enough information and has completed all the necessary steps, this node generates the final, polished output for the user.

5. Reflect: This is the secret sauce. After the work is delivered, the agent doesn't just shut down. It enters a reflection phase. It looks at the final output and the whole process, then fills out the Reflection structure. This reflection is then turned into a new Note and saved to its memory graph. This is the reflexion loop—the mechanism through which the agent learns and improves for the next time.

Assembling the Pieces into a Working Machine

With all our nodes defined, the final step is to wire them together into a coherent graph using LangGraph. It’s like connecting all the stations on an assembly line.

Our graph’s flow looks something like this:

START → deliberate → agent → (conditional: either tools or finalize)

If tools is called, the graph loops back to the agent node with the new information. If not, it moves on:

finalize → reflect → END

We compile this graph and add a checkpointer. This is crucial because it saves the state at every step, meaning the agent can be paused and resumed, and we have a full history of its thought process.

And that's it! We've designed a system that does more than just follow instructions. It deliberates on its strategy, uses tools to interact with the world, reflects on its performance, and stores its learnings in a persistent, interconnected memory.

This approach is a practical foundation for building agents that feel less like rigid tools and more like adaptable, learning partners. By combining deliberation, memory, and reflection, we're taking a meaningful step toward creating AI that can truly grow with experience.