Context overview

Context engineering is the practice of building dynamic systems that provide the right information and tools, in the right format, so that an AI application can accomplish a task. Context can be characterized along two key dimensions:

1. By mutability:

• Static context: Immutable data that doesn’t change during execution (e.g., user metadata, database connections, tools)
• Dynamic context: Mutable data that evolves as the application runs (e.g., conversation history, intermediate results, tool call observations)

2. By lifetime:

• Runtime context: Data scoped to a single run or invocation
• Cross-conversation context: Data that persists across multiple conversations or sessions

Runtime context refers to local context: data and dependencies your code needs to run. It does not refer to:

• The LLM context, which is the data passed into the LLM’s prompt.
• The “context window”, which is the maximum number of tokens that can be passed to the LLM.

The runtime context is how you thread data through your agent. Rather than storing things in global state, you can attach values — like a database connection, user session, or configuration — to the context and access them inside tools and middleware. This keeps things stateless, testable, and reusable. For example, you can use user metadata in the runtime context to fetch user preferences and feed them into the context window.

LangGraph provides three ways to manage context, which combines the mutability and lifetime dimensions:

Context type	Description	Mutability	Lifetime
Config	data passed at the start of a run	Static	Single run
Dynamic runtime context (state)	Mutable data that evolves during a single run	Dynamic	Single run
Dynamic cross-conversation context (store)	Persistent data shared across conversations	Dynamic	Cross-conversation

Config

Config is for immutable data like user metadata or API keys. Use this when you have values that don’t change mid-run.

Specify configuration using a key called “configurable” which is reserved for this purpose.

await graph.invoke(
  { messages: [{ role: "user", content: "hi!" }] },
  { configurable: { user_id: "user_123" } } 
);

Dynamic runtime context

Dynamic runtime context represents mutable data that can evolve during a single run and is managed through the LangGraph state object. This includes conversation history, intermediate results, and values derived from tools or LLM outputs. In LangGraph, the state object acts as short-term memory during a run.

In an agent

Example shows how to incorporate state into an agent prompt.

State can also be accessed by the agent’s tools, which can read or update the state as needed. See tool calling guide for details.

import { createAgent, createMiddleware } from "langchain";
import type { AgentState } from "langchain";
import * as z from "zod";

const CustomState = z.object({ 
  userName: z.string(),
});

const personalizedPrompt = createMiddleware({ 
  name: "PersonalizedPrompt",
  stateSchema: CustomState,
  wrapModelCall: (request, handler) => {
    const userName = request.state.userName || "User";
    const systemPrompt = `You are a helpful assistant. User's name is ${userName}`;
    return handler({ ...request, systemPrompt });
  },
});

const agent = createAgent({  
  model: "claude-sonnet-4-5-20250929",
  tools: [/* your tools here */],
  middleware: [personalizedPrompt] as const, 
});

await agent.invoke({
  messages: [{ role: "user", content: "hi!" }],
  userName: "John Smith",
});

Turning on memory Please see the memory guide for more details on how to enable memory. This is a powerful feature that allows you to persist the agent’s state across multiple invocations. Otherwise, the state is scoped only to a single run.

Dynamic cross-conversation context

Dynamic cross-conversation context represents persistent, mutable data that spans across multiple conversations or sessions and is managed through the LangGraph store. This includes user profiles, preferences, and historical interactions. The LangGraph store acts as long-term memory across multiple runs. This can be used to read or update persistent facts (e.g., user profiles, preferences, prior interactions).

See also

• Memory conceptual overview
• Short-term memory in LangChain
• Long-term memory in LangChain
• Memory in LangGraph

---

Edit the source of this page on GitHub.

Connect these docs programmatically to Claude, VSCode, and more via MCP for real-time answers.