LangGraph Subgraphs Explain #

As AI applications grow larger, managing everything inside a single graph quickly becomes difficult. Imagine building an AI assistant that performs multiple independent tasks such as:

• Researching information
• Summarizing documents
• Translating text
• Reviewing code
• Asking for human approval

Putting all these workflows into one giant graph makes the application difficult to understand, debug, and maintain.

This is where Subgraphs become extremely useful.

A subgraph is simply a LangGraph workflow that runs inside another LangGraph workflow. From the parent graph’s perspective, the entire subgraph behaves like a single node.

Instead of creating one massive workflow, you divide your application into smaller reusable graphs.

---

What is a Subgraph? #

A Subgraph is a complete LangGraph that is embedded inside another graph.

The parent graph only knows that it is calling another graph.

Everything happening inside that graph is isolated from the parent unless explicitly shared.

---

Why Use Subgraphs? #

Subgraphs provide several important advantages.

Modular Design #

Each workflow performs one specific responsibility.

For example:

• Research Agent
• Translation Agent
• Code Review Agent
• SQL Agent
• Document QA Agent

Each can be developed independently.

---

Reusability #

A translation workflow can be reused across multiple AI applications without rewriting the logic.

---

Easier Maintenance #

Instead of editing one graph with hundreds of nodes, developers can update only the affected subgraph.

---

Better Multi-Agent Architecture #

Every AI agent can have its own graph while the parent graph coordinates them.

This is the recommended design for complex AI systems.

---

Two Ways to Create Subgraphs in LangGraph #

LangGraph provides two mechanisms for using subgraphs.

Method 1: Invoke a Graph from a Node #

In this approach:

• Parent graph and subgraph have separate states.
• The parent explicitly calls the subgraph using .invoke().
• Data is manually passed between the graphs.

---

Step 1: Define the Subgraph State #

The subgraph contains only the data it needs.

class SubState(TypedDict):
    input_text: str
    translated_text: str

---

Step 2: Build the Subgraph #

def translate_node(state):
    return {
        "translated_text": "नमस्ते"
    }

Compile the graph normally.

subgraph = workflow.compile()

---

Step 3: Invoke the Subgraph #

Inside the parent graph:

def parent_translate_node(state):

    result = subgraph.invoke(
        {
            "input_text": state["english_answer"]
        }
    )

    return {
        "hindi_answer": result["translated_text"]
    }

The parent passes only the required data.

The subgraph processes it independently and returns the output.

---

# Full code You can Test
from typing_extensions import TypedDict
from dotenv import load_dotenv

from langgraph.graph import StateGraph, START, END
from langchain_openai import ChatOpenAI

load_dotenv()

# ----------------------------
# Subgraph State
# ----------------------------
class SubState(TypedDict):
    input_text: str
    translated_text: str


subgraph_llm = ChatOpenAI(model="gpt-4o")


def translate_text(state: SubState):
    prompt = f"""
Translate the following text to Hindi.
Keep it natural and clear. Do not add extra content.

Text:
{state["input_text"]}
""".strip()

    translated = subgraph_llm.invoke(prompt).content

    return {
        "translated_text": translated
    }


subgraph_builder = StateGraph(SubState)

subgraph_builder.add_node("translate_text", translate_text)

subgraph_builder.add_edge(START, "translate_text")
subgraph_builder.add_edge("translate_text", END)

subgraph = subgraph_builder.compile()

# ----------------------------
# Parent State
# ----------------------------
class ParentState(TypedDict):
    question: str
    answer_eng: str
    answer_hin: str


parent_llm = ChatOpenAI(model="gpt-4o-mini")


def generate_answer(state: ParentState):
    answer = parent_llm.invoke(
        f"You are a helpful assistant.\n\nQuestion: {state['question']}"
    ).content

    return {
        "answer_eng": answer
    }


def translate_answer(state: ParentState):
    # Invoke the compiled subgraph
    result = subgraph.invoke({
        "input_text": state["answer_eng"]
    })

    return {
        "answer_hin": result["translated_text"]
    }


parent_builder = StateGraph(ParentState)

parent_builder.add_node("answer", generate_answer)
parent_builder.add_node("translate", translate_answer)

parent_builder.add_edge(START, "answer")
parent_builder.add_edge("answer", "translate")
parent_builder.add_edge("translate", END)

graph = parent_builder.compile()

# Execute
result = graph.invoke({
    "question": "What is quantum physics?"
})

print(result)

---

---

Advantages of Method 1 #

1. Complete state isolation
2. Prevents state pollution
3. Better modularity
4. Easy debugging
5. Independent testing

This approach is recommended when different AI agents should maintain separate memory.

---

Method 2: Add a Graph as a Node #

Instead of invoking the graph manually, the compiled graph itself becomes a node inside the parent graph.

Both graphs share the same state.

---

Shared State #

Both graphs use the same state object.

class ParentState(TypedDict):
    question: str
    answer: str
    translated_answer: str

---

Build the Subgraph #

Create the workflow normally.

subgraph = workflow.compile()

---

Add Subgraph as a Node #

Instead of passing a function:

workflow.add_node(
    "generate",
    generate_answer
)

Pass the compiled graph.

workflow.add_node(
    "translate",
    compiled_subgraph
)

Then connect it.

workflow.add_edge(
    "generate",
    "translate"
)

The parent graph treats the entire subgraph as one node.

---

# Full Code 
from typing_extensions import TypedDict
from dotenv import load_dotenv

from langgraph.graph import StateGraph, START, END
from langchain_openai import ChatOpenAI

load_dotenv()

# =====================================================
# Shared State
# =====================================================

class State(TypedDict):
    question: str
    answer_eng: str
    answer_hin: str

# =====================================================
# LLMs
# =====================================================

answer_llm = ChatOpenAI(model="gpt-4o-mini")
translator_llm = ChatOpenAI(model="gpt-4o")

# =====================================================
# Build Subgraph
# =====================================================

def translate_text(state: State):

    prompt = f"""
Translate the following text into Hindi.

Text:
{state['answer_eng']}
"""

    translated = translator_llm.invoke(prompt).content

    return {
        "answer_hin": translated
    }


subgraph_builder = StateGraph(State)

subgraph_builder.add_node("translate_text", translate_text)

subgraph_builder.add_edge(START, "translate_text")
subgraph_builder.add_edge("translate_text", END)

subgraph = subgraph_builder.compile()

# =====================================================
# Parent Graph
# =====================================================

def generate_answer(state: State):

    answer = answer_llm.invoke(
        f"Answer the following question:\n\n{state['question']}"
    ).content

    return {
        "answer_eng": answer
    }


parent_builder = StateGraph(State)

parent_builder.add_node("answer", generate_answer)

# Add the entire subgraph as a node
parent_builder.add_node("translator", subgraph)

parent_builder.add_edge(START, "answer")
parent_builder.add_edge("answer", "translator")
parent_builder.add_edge("translator", END)

graph = parent_builder.compile()

# =====================================================
# Execute
# =====================================================

result = graph.invoke(
    {
        "question": "What is Artificial Intelligence?"
    }
)

print(result)

---

Notice that every node—including those inside the subgraph—works on the same shared state.

---

Advantages of Method 2 #

1. Less code
2. Automatic state sharing
3. Easier data flow
4. Suitable for sequential workflows

This is useful when every node should read and update the same state.

---

Method 1 vs Method 2 #

Feature	Invoke Graph	Graph as Node
State	Separate	Shared
Data Transfer	Manual	Automatic
Isolation	High	Low
Reusability	Excellent	Good
Complexity	Slightly Higher	Simple
Best For	Multi-Agent Systems	Sequential Pipelines

---

Real-World Example #

Suppose you’re building a multilingual AI chatbot.

The parent graph:

1. Receives the question
2. Generates the answer
3. Sends the answer to a Translation Subgraph
4. Returns both English and Hindi responses

User Question
      │
      ▼
Generate Answer
      │
      ▼
Translation Subgraph
      │
      ▼
English + Hindi Response

The translation logic remains reusable across multiple applications.

---

Benefits of Using Subgraphs #

1. State Separation #

Different AI agents maintain independent memory.

No accidental overwriting of state variables.

---

2. Failure Isolation #

If one subgraph fails, it is less likely to crash the entire workflow.

This improves the reliability of large AI systems.

---

3. Better Observability #

LangGraph allows monitoring each subgraph independently.

You can analyze:

• Execution time
• Token usage
• LLM cost
• Errors
• Performance

This makes debugging much easier.

---

4. Human-in-the-Loop Support #

One of the biggest advantages is checkpoint management.

If the parent graph uses a checkpointer for persistence or Human-in-the-Loop (HITL), child subgraphs automatically participate in the checkpointing process.

There is usually no need to configure separate checkpointers for every subgraph.

---

When Should You Use Each Method? #

Use Method 1 (Invoke) #

Choose this approach when:

• Multiple AI agents work independently
• Different state objects are required
• Agents should remain isolated
• You want maximum modularity

Examples:

• Research Agent
• SQL Agent
• Coding Agent
• Planning Agent

---

Use Method 2 (Graph as Node) #

Choose this approach when:

• The workflow is sequential
• Every node shares the same state
• Simplicity is more important than isolation
• The graph behaves like a reusable module

Examples:

• Translation
• Summarization
• Formatting
• Validation

---

Best Practices #

• Keep each subgraph focused on one responsibility.
• Reuse subgraphs across multiple parent workflows.
• Use isolated state for independent AI agents.
• Use shared state for linear processing pipelines.
• Add Human-in-the-Loop at the parent graph level whenever possible.
• Test each subgraph independently before integrating it.

---

Conclusion #

Subgraphs are one of LangGraph’s most powerful features for building scalable AI applications.

Whether you’re designing a multi-agent system or simply organizing a complex workflow, subgraphs make your code easier to understand, reuse, test, and maintain.

Use Invoke Graph when you need isolated state and independent agents.

Use Graph as Node when you want a clean, shared-state workflow.

As your AI applications grow, adopting a modular architecture with subgraphs will help keep your LangGraph projects organized, scalable, and production-ready.

---

Key Takeaways #

• A subgraph is a graph inside another graph.
• LangGraph supports two approaches:
  • Invoke a Graph (isolated state)
  • Graph as a Node (shared state)
• Isolated state is ideal for multi-agent systems.
• Shared state is ideal for sequential workflows.
• Subgraphs improve modularity, reusability, observability, and maintainability.
• Human-in-the-Loop checkpointing is typically managed from the parent graph.

Quiz #