first steady v1.0 launch in late October 2025. After spending the previous two months working with their new APIs, I genuinely really feel that is essentially the most coherent and thoughtfully designed model of LangChain up to now.
I wasn’t at all times a LangChain fan. The early variations had been fragile, poorly documented, abstractions shifted often, and it felt too untimely to make use of in prod. However v1.0 felt extra intentional, and had a extra constant psychological mannequin for the way knowledge ought to circulation by way of brokers and instruments.
This isn’t a sponsored put up by the way in which — I’d love to listen to your ideas, be at liberty to DM me here!
This text isn’t right here to regurgitate the docs. I’m assuming you’ve already dabbled with LangChain (or are a heavy person). Somewhat than dumping a laundry listing of factors, I’m going to cherry-pick simply 4 key factors.
A fast recap: LangChain, LangGraph & LangSmith
At a excessive degree, LangChain is a framework for constructing LLM apps and brokers, permitting devs to ship AI options quick with frequent abstractions.
LangGraph is the graph-based execution engine for sturdy, stateful agent workflows in a controllable manner. Lastly, LangSmith is an observability platform for tracing and monitoring.
Put merely: LangChain helps you construct brokers quick, LangGraph runs them reliably, and LangSmith helps you to monitor and enhance them in manufacturing.
My stack
For context, most of my latest work focuses on constructing multi-agent options for a customer-facing AI platform at work. My backend stack is FastAPI, with Pydantic powering schema validation and knowledge contracts.
Lesson 1: Dropping assist for Pydantic fashions
A significant shift within the migration to v1.0 was the introduction of the brand new create_agent methodology. It streamlines how brokers are outlined and invoked, however it additionally drops assist for Pydantic fashions and dataclasses in agent state. Every little thing should now be expressed as TypedDicts extending AgentState.
Should you’re utilizing FastAPI, Pydantic is usually the really useful and default schema validator. I valued schema consistency throughout the codebase and felt that mixing TypedDicts and Pydantic fashions would inevitably create confusion — particularly for brand new engineers who won’t know which schema format to observe.
To unravel this, I launched a small helper that converts a Pydantic mannequin right into a TypedDict that extends AgentState proper earlier than it’s handed to create_agent . It’s important to notice that LangChain attaches customized metadata to kind annotations which you have to protect. Python utilities like get_type_hints() strip these annotations, that means a naïve conversion received’t work.
Lesson 2: Deep brokers are opinionated by design
Alongside the brand new create_agent API in LangChain 1.0 got here one thing that caught my consideration: the deepagents library. Impressed by instruments like Claude Code and Manus, deep brokers can plan, break duties into steps, and even spawn subagents.
After I first noticed this, I needed to make use of it all over the place. Why wouldn’t you need “smarter” brokers, proper? However after attempting it throughout a number of workflows, I realised that this further autonomy was typically pointless — and in sure circumstances, counterproductive — for my use circumstances.
The deepagents library is pretty opinionated, and really a lot by design. Every deep agent comes with some built-in middleware — issues like ToDoListMiddleware, FilesystemMiddleware, SummarizationMiddleware, and so forth. These form how the agent thinks, plans, and manages context. The catch is that you just can’t management precisely when these default middleware run, nor are you able to disable those you don’t want.
After digging into the deepagents supply code here, you’ll be able to see that the middleware parameter is extra middleware to use after normal middleware. Any middleware that was handed in middleware=[...] will get appended after the defaults.
All this further orchestration additionally launched noticeable latency, and will not present significant profit. So in order for you extra granular management, persist with the less complicated create_agent methodology.
I’m not saying deep brokers are dangerous, they’re highly effective in the fitting eventualities. Nonetheless, this can be a good reminder of a basic engineering precept: don’t chase the “shiny” factor. Use the tech that solves your precise drawback, even when it’s the “much less glamorous” choice.
My favorite characteristic: Structured output
Having deployed brokers in manufacturing, particularly ones that combine with deterministic enterprise methods, getting brokers to constantly produce output of a particular schema was essential.
LangChain 1.0 makes this gorgeous straightforward. You may outline a schema (e.g., a Pydantic mannequin) and move it to create_agent through the response_format parameter. The agent then produces output that conforms to that schema inside a single agent loop with no extra steps.
This has been extremely helpful each time I would like the agent to strictly adhere to a JSON construction with sure fields assured. To date, structured output has been very dependable too.
What I need to discover extra of: Middleware
One of many trickiest elements of constructing dependable brokers is context engineering — ensuring the agent at all times has the fitting info on the proper time. Middleware was launched to offer builders exact management over every step of the agent loop, and I feel it’s price diving deeper into.
Middleware can imply various things relying on context (pun meant). In LangGraph, this could imply controlling the precise sequence of node execution. In long-running conversations, it would contain summarising amassed context earlier than the following LLM name. In human-in-the-loop eventualities, middleware can pause execution and anticipate a person to approve or reject a instrument name.
Extra not too long ago, within the newest v1.1 minor launch, LangChain additionally added a mannequin retry middleware with configurable exponential backoff, permitting swish restoration for transient endpoint errors.
I personally assume middleware is a recreation changer as agentic workflows get extra complicated, long-running, and stateful, particularly if you want fine-grained management or sturdy error dealing with.
This listing of middleware is growing and it actually helps that it stays supplier agnostic. Should you’ve experimented with middleware in your individual work, I’d love to listen to what you discovered most helpful!
To finish off
That’s it for now — 4 key reflections from what I’ve learnt to this point about LangChain. And if anybody from the LangChain group occurs to be studying this, I’m at all times pleased to share person suggestions anytime or just chat 🙂
Have enjoyable constructing!
