First stable v1.0 release in late October 2025
I have always been a fan of Langchain. The early versions were fragile, poorly written, abstracted and often changed, and he felt it was too early to use them in Prod. But v1.0 felt more intentional, and had a consistent mental model of how data should flow through agents and tools.
This one this is not the case Sponsored post – I'd love to hear your thoughts, feel free to follow me here!
This article is not here to recount the documents. I think you are already out with Langchain (or heavy user). Instead of throwing out a laundry list of points, I'm going to cherry-pick four main points.
Quick recovery: Langchain, Langgraph & Langsmith
At a high level, Langchain is a framework for building applications and agents, allowing devs to deploy fast AI features with standard attstrings.
Langgraph is a graph-based workflow engine for robust, scalable agent workflows. Finally, LangSmith is an alert platform for tracking and monitoring.
Simply put: Langchain helps you build agents quickly, langgraph runs them reliably, and langsmith lets you monitor and optimize production.
My stack
By nature, most of my recent work has focused on building the multi-agent aspects of a task-oriented AI platform. My Backlend stack is Fastapi, with Pydantic Power Cooling Schema for authentication and data contracts.
Lesson 1: Casting Support for Pydantic models
The biggest change in the migration to V1.0 was the new launch create_agent way. It directs how agents are defined and invoked, but also loses support for Pydantic models and Agent State dactaplases. Everything should now be displayed as typeddds that expand AgentState.
If you're using Fastapi, pydantic is usually a validated and structured schema. I've exposed schema variables across the codebase and realized that mixing typeddds and Pydantic models can cause confusion – especially for new developers who may not know which schema format is which.
To solve this, I introduce a small helper that converts a Pydantic model into a passing typeddict AgentState Right before it passes create_agent . It is important to note that Langchain attaches a custom metadata code to type annotations that you must save. Python utilities like get_type_hints() ride these annotations, which means a naïve conversion will not work.
Lesson 2: Deep Agents have visual perception
Next to the New create_agent API in Langchain 1.0 came something that got my attention: deepagents the library. Inspired by tools like Claude Code and Manus, deep agents can program, break down tasks into steps, and extract logs.
When I first saw this, I wanted to use it all over. Why don't you want to search for the right “smart” agents? But after experimenting with other workflows, I realized that this extra independence was unnecessary – and in some cases, counterproductive – for my use cases.
This page deepagents The library has ideas well, and very creatively. Each deep agent comes with some built-ins – things like ToDoListMiddleware, FilesystemMiddleware, SummarizationMiddlewareetc. These conditions are how the agent thinks, plans, and manages the context. Catching that you cannot directly control When this is the default operation of Middleware, and you can disable what they need.
After digging in deepagents source code here, you can see that the Middleware parameter – more Middleware will apply After the standard Middleware. Any middleware that was passed internally middleware=[...] it is installed after default.
All of these orchestrations are also introduced with noticeable latency, and may not provide a meaningful benefit. So if you want more granular control, stick with lula create_agent way.
I am not saying that deep agents are bad, they are powerful in the right circumstances. However, this is a good reminder of an old engineering principle: don't chase anything “shiny”. Use the technology that solves your real problem, even if it's the “low” option.
My favorite feature: Systematic release
Since I've released agents into production, especially those that include deterministic business systems, agents will consistently produce the output of some important schema.
Langchain 1.0 makes this easy. You can define a schema (eg, a pydantic model) and transfer it create_agent with response_format parameter. The agent then produces an output that conforms to that schema Inside one agent loop without further steps.
This is very useful whenever I need an agent to strictly trace a json structure with certain fields validated. So far, systematic exit has been very reliable.
What I want to test most of: Middleware
One of the trickier parts of people working with integrity Context engineering– Ensuring that the agent always has the right information at the right time. Middleware was introduced to give developers direct control over each step of agent configuration, and I think it's worth going deeper.
Middleware can mean different things depending on the context (pun intended). In Langgraph, this would mean controlling the exact sequence of node executions. In the best discussions, it can include summarizing the content gathered before the next LLM call. In man-in loop situations, the middleware can stop the execution and wait for the user to accept or reject the tool call.
Recently, in the latest V1.1 minor release, Langchain has also added a retry model with renewable backoff, which allows better recovery of last errors.
I personally think mididware is a game changer as agentic workflows become more integrated, scalable, and secure, especially when you need sophisticated error handling or robust error handling.
This list of Middleware is growing and it really helps to keep it more powerful. If you've tried Middleware in your work, I'd love to hear how useful it is!
To finish
That's it for now – four key takeaways from what I've learned so far about Langchain. And if anyone from the Langchain team starts reading this, I'm always happy to share user feedback at any time or just chat 🙂
Happy building!
