Do we still need LangChain? Making sense of the AI stack as models get smarter

---

I was reading a post in Medium.com talking about evolution of AI framework and one of the questions it raises is:

"If the models are this capable now, and we have MCP and Skills, do we still need frameworks like LangChain?"

I think this is an interesting question. Frameworks come and go, most of time they die down in usage before we realise. I felt it's a great opportunity for me myself to reflect on this. My experience recently tells me that LangChain is no longer the automatic starting point it once was. But LangGraph — its orchestration sibling — is more relevant than ever for serious, production-grade agents. To see why, it helps to stop thinking about brand names and start thinking about jobs to be done.

A simple way to picture the stack

Imagine you've just hired a brilliant generalist. Sharp, fast, capable of almost anything you explain clearly. That's roughly where frontier models are today.

A brilliant new hire still can't do much in isolation. To turn raw capability into reliable work, they need four more things — and each maps to a piece of the modern AI stack:

• The model is the reasoning engine — the brain. Today's models are good enough that a lot of the "glue code" we used to write by hand is no longer necessary.

• MCP is how the model plugs into your world — your tools, data, and systems. Think of it as a universal adapter, a kind of USB-C for AI. It standardises connection, not control.

• Skills are packaged know-how: a folder of instructions, examples, and optional scripts that teaches an agent how your organisation does a specific task, loaded only when that task comes up. Think of it as an onboarding guide or a standard operating procedure.

• Provider SDKs (such as OpenAI's or Anthropic's agent toolkits) are starter kits for building a single-model agent quickly, now with built-in loops, handoffs, and tracing.

• Orchestration (LangGraph) is the operations layer — the part that makes an agent behave like a reliable business process rather than a clever chatbot. It tracks state, handles approvals, recovers from failures, and leaves an audit trail.

The mistake the "do we still need it?" question makes is treating these as competitors. They aren't. They sit at different layers and increasingly work together.

What actually changed

As models get stronger, value shifts from prompt orchestration to operational orchestration.

Prompt orchestration is the plumbing developers used to write around the model to make it behave reliably — the "glue code." The model supplied raw intelligence; the glue made it usable. As models improved, much of that plumbing simply stopped being necessary. Three everyday examples:

• Getting clean, structured data out. Suppose you want to pull {name, company, budget} from a sales email. Older models answered in chatty prose — "Sure! John from Acme has a budget of around $50k" — so you wrote code to dig the values out of that text and a retry loop to handle the times it came back malformed. Today you ask for JSON (or switch on a structured-output mode) and reliably get {"name": "John", "company": "Acme", "budget": 50000} the first time. The parser and the retry loop largely disappear.

• Deciding when to use a tool. Say your assistant can either search the web or query your database. You used to hand-write the decision logic: work out what the user wants, pick the tool, extract the parameters, call it, feed the result back, decide whether to go again. That "agent loop" was one of the main reasons to reach for LangChain. Now models do tool calling natively — you describe the available tools and the model decides which to call, with what arguments, and when it has enough to answer.

• Breaking a big task into steps. For "research these three competitors and summarise each," you used to split the work into steps yourself, prompt for each, and stitch the outputs together. A capable model now holds that multi-step thread on its own, so you're not hand-orchestrating every hop.

This is why LangChain is no longer an obvious default for every project. For a simple chatbot, a retrieval-based Q&A tool, or an agent tied to one model provider, you can often go straight to the provider's SDK, add a Skill for repeatable tasks, and connect your systems through MCP.

Operational orchestration is different, and it doesn't get easier just because the model got smarter. State management, branching logic, retries, human approvals, recovery after a crash, observability, and governance are process problems, not intelligence problems. That's the territory LangGraph was built for: durable, stateful execution for long-running and multi-agent workflows. Notably, the two have converged — recent releases mean LangChain's higher-level agent building now runs on top of LangGraph, so it's less "either/or" than it used to be.

A two-question test

Rather than memorise a feature matrix, my experience is that we should ask two questions:

1. Does this need to behave like a reliable business process — with persistent state, approval checkpoints, failure recovery, and an audit trail?

2. Do we need to stay vendor-neutral across model providers, rather than tying ourselves to one?

If the answer to either is yes, an orchestration layer like LangGraph earns its place. If the answer to both is no, keep it simple — a provider SDK, a Skill, and MCP will usually do the job with far less overhead.

To make it concrete:

Keep it simple when you're building a single assistant with a handful of tools, a straightforward retrieval chatbot, or a repeatable document or reporting task. A Skill or a provider SDK is enough; reaching for a heavy framework here just adds abstraction you'll have to maintain.

Invest in orchestration when you have multi-step workflows with branching and approvals, long-running agents that must survive a restart and pick up where they left off, multiple agents handing work to each other with shared state, or regulated processes that demand human checkpoints and a defensible audit trail.

The bottom line

LangChain has lost its status as the default; LangGraph has kept its strategic relevance. As raw model capability becomes a commodity, advantage shifts to how reliably, safely, and observably you can put that capability to work.

Or, framed for the board: frameworks aren't disappearing — their job is changing. The hard part is no longer making a model talk. It's making an agent accountable.