LangChain, which said on 13 November that it raised $300 million at a $3 billion valuation, began in October 2022 as a Python package with two parts: LLM abstractions and “Chains”. Its documentation now opens with a different formula: “Agent = Model + Harness.” This explainer walks through the nine concepts most tutorials teach, layer by layer, and checks each against LangChain’s own docs.
The nine-concept map comes from a thread posted on X on 8 November by the account AI Guides, which groups the concepts into three layers: the core, abilities and your own data. Our news coverage of the round is here and here.
Business Pill · The Model and the Harness
An evergreen Business Engineer explainer on why products built on the same model differ: the harness around it. It teaches the general idea only and does not discuss LangChain.
The key insight: As we read the docs, the nine concepts survive but their centre has moved: since version 1.0 LangChain builds everything around one agent loop, and its own definition of an agent is a model plus a harness, the layer its LangSmith platform is pitched to run, improve and govern.
The thread argues that “Most LangChain confusion comes from seeing nine separate names instead of three layers that stack”. Its core layer is models, prompts and chains. Its abilities layer is memory, tools and agents. Its data layer is document loaders, text splitters and retrievers.
LangChain’s own component architecture page cuts the same parts differently. It lists five layers: input processing, embedding and storage, retrieval, generation and orchestration. In that diagram, agents form the orchestration layer and connect to the chat model, the tools, the retrievers and memory.
As we read them, the two maps agree on the parts and differ on the order: the thread stacks the parts from the model up, while the docs draw data flowing in from documents and a query, with the agent orchestrating everything. Our diagram below uses the thread’s three layers and the docs’ definitions.
LangChain’s nine core concepts in the three layers of the AI Guides thread (8 November 2026), each with a short phrase from LangChain’s own documentation. Since version 1.0 (October 2025), one agent abstraction built on LangGraph replaces chains, and legacy chains live in the langchain-classic package. Concept diagram by FourWeekMBA; source: LangChain docs.
What Was Posted on X
Most LangChain confusion comes from seeing nine separate names instead of three layers that stack. These are the nine concepts that build, customize, and scale an AI application.
Start with the core. Models give you one interface to many providers, like OpenAI, Anthropic, and Google, so you can swap supported models without rewriting your app. Prompts are dynamic, reusable templates where you insert variables like the question and context and format the messages. Chains connect input, prompt, model, and output into a repeatable sequence, which is how you solve bigger tasks from small components.
Next, give it abilities. Memory stores and recalls past interactions through chat history, so relevant context carries across turns. Tools connect models to external capabilities like search, a calculator, a database, or a custom API. Agents combine reasoning, planning, and execution, choosing steps and tools for a goal, then deciding, acting, and repeating.
Finally, feed it your own data. Document loaders bring PDFs, CSVs, web pages, text files, and other sources into one common document format. Text splitters break large documents into chunks, and you control the chunk size and overlap. Retrievers take a query, search a vector store like FAISS, Chroma, or Pinecone, and return the top documents that supply context for RAG.
Put together, the cycle is build, test, deploy, improve, and repeat.
Bookmark this before you start your next LangChain project and check that you can place every piece in one of the three layers.
The account AI Guides posted this thread at 16:00 UTC on 8 November 2026; it had about 5,300 views when we read it. It groups nine LangChain concepts into three layers: the core (models, prompts, chains), abilities (memory, tools, agents) and your own data (document loaders, text splitters, retrievers). This explainer uses the thread’s three-layer map as its structure and checks each concept against LangChain’s own documentation.
Layer One, the Core: Models, Prompts and Chains
Models. LangChain’s models page calls chat models “the reasoning engine of agents”. The point of the abstraction is the standard interface: the docs say it “makes it easy to experiment with and switch between models to find the best fit for your use case”. The thread names OpenAI, Anthropic and Google as examples.
Prompts. The thread describes prompts as reusable templates with variables. The current docs frame the same job through messages, which they call “the fundamental unit of context for models”, and through the agent’s system prompt, which “accepts a string or SystemMessage”. For prompts that change at runtime, the docs point to middleware.
Chains. This is the concept that has moved most. LangChain’s history page says the first version shipped “Chains”, or “predetermined steps of computation to run, for common use cases”, and that the name comes from “Language” and “Chains”. Version 1.0, released on 20 October 2025 according to that page, replaced all chains and agents with “only one high level abstraction: an agent abstraction built on top of LangGraph”.
Old chains still run. The v1 release notes say legacy functionality moved to a separate package, langchain-classic, including “Legacy chains and chain implementations” and the hub module for managing prompts. The docs pages we read do not mention the LangChain Expression Language by name.
Layer Two, Abilities: Memory, Tools and Agents
Memory. The docs define it as “a system that remembers information about previous interactions”. Short-term memory works “within a single thread or conversation”, and “Conversation history is the most common form of short-term memory”. The docs warn that a full history may not fit inside a model’s context window, so many applications can benefit from removing or forgetting stale information. Long-term memory stores data across threads and sessions.
Tools. In the docs’ words, tools are “callable functions with well-defined inputs and outputs that get passed to a chat model”. The model, not the developer, picks the moment: “The model decides when to invoke a tool based on the conversation context, and what input arguments to provide”.
Agents. The agents page gives the shortest definition in the docs: “An agent is a model calling tools in a loop until a given task is complete”. The harness is “everything around that loop: the prompt, the tools, and any middleware that shapes the model’s behavior”. In v1 the standard way to build one is create_agent, which the release notes say replaces LangGraph’s prebuilt create_react_agent.
LangGraph sits underneath. Its overview calls it “a low-level orchestration framework and runtime for long-running, stateful agents”, and adds that “LangGraph does not require LangChain”. Because create_agent is built on LangGraph, the release notes say, agents get persistence, streaming and human-in-the-loop support. Deep Agents, an agent harness built on LangGraph with planning, a virtual filesystem and subagents, was released on 15 March 2026, the history page says.
Layer Three, Your Data: Loaders, Splitters and Retrievers
Document loaders. They provide “a standard interface for reading data from different sources (such as Slack, Notion, or Google Drive) into LangChain’s Document format”, the loaders page says. Every loader shares two methods: load() reads everything at once and lazy_load() streams documents for large datasets.
Text splitters. They “break large docs into smaller chunks that will be retrievable individually and fit within model context window limit”, per the splitters page. For most cases the docs recommend starting with the RecursiveCharacterTextSplitter, which tries to keep paragraphs intact, moving to sentences and then words only when a unit exceeds the chunk size.
Retrievers. The retrievers page defines one as “an interface that returns documents given an unstructured query” and says it “is more general than a vector store”: it only has to return documents, not store them. All vector stores can be cast to retrievers. The docs list Chroma, Pinecone and FAISS as vector stores, the same three the thread names.
Together these make retrieval-augmented generation (RAG). The docs’ RAG diagram runs from the user’s question to a retriever, then to the relevant documents, and on to the chat model, which also sees the question. Our piece on plain RAG against 11 memory systems covers one test of how far that simple pattern goes.
Where the $3 Billion Comes In
LangChain and LangGraph are what its 2025 post called its open source frameworks; the 2026 round is pitched on the platform above them. In its 13 November post, LangChain calls LangSmith “the framework-agnostic platform to run, improve, and govern agents” and says “More than 7,000 organizations already rely on LangSmith”. CapitalG led the round, the post says.
When LangChain raised $125 million at a $1.25 billion valuation on 20 October 2025, its post said langchain and langgraph had “a combined 90M monthly downloads” and that “35 percent of the Fortune 500 use our services”. By our arithmetic, the new valuation is 2.4 times that mark, about 13 months later. The same 2025 post announced the 1.0 releases described above.
The 2026 post sorts LangSmith into three pillars: Agent Runtime, Agent Improvement and Agent Governance. The frameworks in this explainer, Deep Agents, LangGraph and LangChain, sit under Agent Runtime, the post says. Chief executive Harrison Chase has also argued that goal engineering comes after harness engineering, and named five parts of a company harness.
The Structural Read
As we read the history page, the concept in LangChain’s name is the one it retired: chains gave the project its name in 2022, and version 1.0 replaced them with a single agent abstraction built on LangGraph.
As we read the Series C post, the round is pitched on the layer above the frameworks: Deep Agents, LangGraph and LangChain sit under Agent Runtime, one of three LangSmith pillars next to Agent Improvement and Agent Governance.
LangChain docs, Agents
“The job of a harness: get the model the right context at the right time for the given task.”
Three Implications
FOR DEVELOPERS LangChain’s v1 release notes say legacy chains moved to langchain-classic, so code built on the old chains needs that package or a move to create_agent.
FOR ENTERPRISE BUYERS LangChain’s 13 November post says more than 7,000 organizations rely on LangSmith and that Workday cut the time to deploy a new agent from five months to under a day.
FOR LEARNERS The docs list Chroma, Pinecone and FAISS as vector stores and recommend starting text splitting with the RecursiveCharacterTextSplitter.
The framework states: “The surface, not the model, governs autonomy.”
As we read it, LangChain’s docs now use the framework’s word: an agent is a model plus a harness, and the company’s platform is pitched on running, improving and governing agents. The framework predates this piece and does not discuss LangChain’s documentation.
What Is Not Established
The three-layer grouping is the thread’s, not LangChain’s; LangChain’s component page uses five layers. The 13 November post gives no revenue figure and does not say how many of the 7,000 organizations pay for LangSmith. The 2025 download and Fortune 500 figures are LangChain’s own and do not appear in the 2026 post we read.
This Week In The AI Supercycle
AI Lost Its Central Banker, the Lab Oligopoly, and the Future of Open Source
This week’s issue: the Nvidia leadership change, read as the AI build-out losing its central banker: who now finances the GPU landlords, backstops the data centres and sponsors open models, and why two labs are becoming the bank.
The nine concepts still describe how a LangChain app is built: models and messages at the core, memory, tools and agents on top, and loaders, splitters and retrievers feeding in your data. What changed is the centre of gravity. Since version 1.0 in October 2025, LangChain’s docs build everything around one agent loop on LangGraph, with legacy chains moved to langchain-classic, while the company raised $300 million at a $3 billion valuation for LangSmith, the platform it says more than 7,000 organizations rely on.
A note on sourcing. The nine-concept, three-layer map comes from the AI Guides thread on X of 8 November 2026, which we credit as the prompt for this explainer and embed in the piece. Every definition here comes from LangChain’s own documentation at docs.langchain.com, which we read on 15 November 2026: the overview, models, messages, agents, tools, short-term memory, document loader, text splitter, retriever, component architecture, LangGraph overview, v1 release notes and philosophy pages.
The funding figures come from LangChain’s Series C post of 13 November 2026 and its Series B post of 20 October 2025, both read in full. The 2.4x multiple is our arithmetic. The diagram is our own layout of those definitions. We did not contact LangChain for this piece.
Gennaro Cuofano is a CRO and tech executive who has worked in AI since late 2015, starting with bringing NLP, natural-language generation, voice and chatbot products to the marketing industry. His background is in law and finance: he holds a Master's degree in Law and an International MBA with an emphasis on corporate finance (LUISS Business School and the University of San Diego, 2012), and worked as a financial analyst at a real-estate investment firm in San Diego and as an assistant controller. His work focuses on business model strategy, business engineering and, more broadly, structural analysis: how companies make money, read from their own filings. He created FourWeekMBA and leads research there and at The Business Engineer, his newsletter on AI and business strategy, with over 95,000 subscribers and more than 1,000 published analyses. His writing has also appeared on Entrepreneur (for example, How to Digitize a Family Business in Europe) and HackerNoon. Find him on LinkedIn and Substack. See how we source.
