Mastering LangChain Runnables: Primitives and LCEL

LangChain simplifies the creation of LLM-powered applications by structuring workflows into modular, reusable components. While core components like models, prompts, and output parsers handle specific operations, Runnable Primitives act as the architectural glue that binds them together. This guide explores the two fundamental classes of Runnables, dives deep into the core orchestration primitives (RunnableSequence, RunnableParallel, RunnablePassthrough, RunnableLambda, and RunnableBranch), and demonstrates how the LangChain Expression Language (LCEL) provides a declarative syntax for building flexible, production-ready AI pipelines.

1. Architectural Evolution: Standardization via Runnables

In the early versions of LangChain, developers interacted with disjointed components that lacked a unified interface:

• Prompt Templates used .format() or .format_messages()
• Language Models (LLMs) used .predict() or .__call__()
• Output Parsers used .parse()
• Retrievers used .get_relevant_documents()

This lack of uniformity introduced architectural friction. Developers had to write custom glue code to extract outputs from one component and format them for the next.

Disjointed Early Architecture:
PromptTemplate (.format()) 
   | (requires manual glue code)
   v
ChatOpenAI (.predict()) 
   | (requires manual glue code)
   v
StrOutputParser (.parse())

To resolve this, LangChain introduced the Runnable protocol—an abstract base class that standardizes execution across the entire framework. Every component inheriting from Runnable implements a uniform interface:

• .invoke(): Synchronous single-input execution.
• .batch(): Batched inputs processed concurrently.
• .stream(): Streaming chunked outputs in real-time.
• Async equivalents: .ainvoke(), .abatch(), .astream().

Standardization ensures that the output of any upstream Runnable can automatically serve as the input to a downstream Runnable, establishing a plug-and-play foundation for complex AI workflows.

2. Taxonomy of Runnables: Task-Specific vs. Primitives

Runnables fall into two distinct operational categories:

3. Sequential Orchestration: RunnableSequence

RunnableSequence chains two or more runnables sequentially. The output of runnable $R_n$ automatically becomes the input to runnable $R_{n+1}$.

Vertical Execution Flow

Implementation: Multi-Step Sequential Chain

Below is an implementation where a joke is first generated by an LLM and subsequently passed into a second sequence to generate an explanation:

from dotenv import load_dotenv
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
from langchain.schema.runnable import RunnableSequence

load_dotenv()

# Step 1: Instantiate task-specific components
prompt1 = PromptTemplate(
    template="Write a joke about {topic}",
    input_variables=["topic"]
)
prompt2 = PromptTemplate(
    template="Explain the following joke: {text}",
    input_variables=["text"]
)

model = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)
parser = StrOutputParser()

# Step 2: Construct the sequential execution pipeline
chain = RunnableSequence(
    prompt1,
    model,
    parser,
    prompt2,
    model,
    parser
)

# Step 3: Execute the pipeline
result = chain.invoke({"topic": "AI"})
print(result)

Note: Every component in this sequence satisfies the Runnable interface. The string emitted by the first parser satisfies the {text} variable required by prompt2.

4. Concurrent Execution: RunnableParallel

RunnableParallel executes multiple runnables simultaneously on the same input. It processes branches independently and packages the individual outputs into a single dictionary where keys correspond to the branch names.

Real-World Use Case: Multi-Platform Content Generation

Generating content formatted for different social networks (e.g., a Twitter/X post and a LinkedIn post) simultaneously from a single central topic.

Vertical Execution Flow

Implementation: Parallel Content Pipeline

from dotenv import load_dotenv
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
from langchain.schema.runnable import RunnableSequence, RunnableParallel

load_dotenv()

prompt_tweet = PromptTemplate(
    template="Generate a concise tweet about {topic}",
    input_variables=["topic"]
)
prompt_linkedin = PromptTemplate(
    template="Generate a detailed professional LinkedIn post about {topic}",
    input_variables=["topic"]
)

model = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)
parser = StrOutputParser()

# Define independent sequential branches
tweet_chain = RunnableSequence(prompt_tweet, model, parser)
linkedin_chain = RunnableSequence(prompt_linkedin, model, parser)

# Define the parallel orchestrator
parallel_chain = RunnableParallel({
    "tweet": tweet_chain,
    "linkedin": linkedin_chain
})

# Execution runs both branches concurrently
response = parallel_chain.invoke({"topic": "Generative AI"})

print("--- TWEET ---")
print(response["tweet"])
print("\n--- LINKEDIN POST ---")
print(response["linkedin"])

5. Preserving State and Intermediate Outputs: RunnablePassthrough

A major limitation of strict sequential pipelines is data shadowing: once an upstream component produces an output, previous inputs or intermediate outputs are lost unless explicitly retained.

RunnablePassthrough acts as an identity operator: it takes its input and passes it through unchanged without any modification or side effects ($f(x) = x$).

The Dual-Output Dilemma

Suppose you generate a joke and then generate an explanation. A standard sequence outputs only the explanation; the joke itself is discarded downstream. By pairing RunnablePassthrough with RunnableParallel, you retain both the original intermediate output (the joke) and the downstream transformation (the explanation).

Vertical Execution Flow

Implementation: State Retention via Passthrough

from dotenv import load_dotenv
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
from langchain.schema.runnable import (
    RunnableSequence, 
    RunnableParallel, 
    RunnablePassthrough
)

load_dotenv()

# Components
prompt_joke = PromptTemplate.from_template("Write a funny joke about {topic}")
prompt_explain = PromptTemplate.from_template("Explain why this joke is funny: {text}")

model = ChatOpenAI(model="gpt-4o-mini", temperature=0.5)
parser = StrOutputParser()

# Step 1: Upstream generator
joke_gen_chain = RunnableSequence(prompt_joke, model, parser)

# Step 2: Downstream parallel aggregator with Passthrough
parallel_chain = RunnableParallel({
    "joke": RunnablePassthrough(),
    "explanation": RunnableSequence(prompt_explain, model, parser)
})

# Step 3: Composite pipeline
final_chain = RunnableSequence(joke_gen_chain, parallel_chain)

# Execution
output = final_chain.invoke({"topic": "cricket"})

print(f"JOKE:\n{output['joke']}\n")
print(f"EXPLANATION:\n{output['explanation']}")

6. Injecting Custom Python Logic: RunnableLambda

LLMs are not optimal for programmatic or deterministic calculations (e.g., string manipulation, mathematical calculations, token/word counting, or regex operations).

RunnableLambda wraps arbitrary Python functions or lambda expressions into a fully-fledged Runnable. This allows standard Python code to natively participate in LCEL chains, receiving upstream data and passing returns downstream.

Implementation: Combining Passthrough and Custom Logic

Below, a joke is generated, and a custom Python word-counter function executes alongside the raw text output.

from dotenv import load_dotenv
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
from langchain.schema.runnable import (
    RunnableSequence, 
    RunnableParallel, 
    RunnablePassthrough, 
    RunnableLambda
)

load_dotenv()

prompt = PromptTemplate.from_template("Write a one-liner joke about {topic}")
model = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)
parser = StrOutputParser()

# Deterministic Python helper
def calculate_words(text: str) -> int:
    return len(text.split())

# Chains
joke_chain = RunnableSequence(prompt, model, parser)

analysis_chain = RunnableParallel({
    "joke": RunnablePassthrough(),
    "word_count": RunnableLambda(calculate_words)  # Alternatively: RunnableLambda(lambda x: len(x.split()))
})

pipeline = RunnableSequence(joke_chain, analysis_chain)

result = pipeline.invoke({"topic": "software engineering"})

print(f"Joke: {result['joke']}")
print(f"Word Count: {result['word_count']}")

7. Dynamic Routing: RunnableBranch

RunnableBranch implements conditional evaluation within chains, analogous to programmatic if-elif-else control flow. It evaluates condition-runnable pairs sequentially. The first condition that evaluates to True triggers its corresponding runnable. If no condition matches, it triggers a fallback default runnable.

Syntax Structure

branch = RunnableBranch(
    (condition_1, runnable_1),  # if condition_1(input) is True -> execute runnable_1
    (condition_2, runnable_2),  # elif condition_2(input) is True -> execute runnable_2
    default_runnable            # else -> execute default_runnable
)

Implementation: Conditional Summarization Workflow

In this scenario:

1. An LLM generates a detailed report.
2. If the report exceeds 300 words, a secondary summarization chain is triggered.
3. If the report is within 300 words, the text is passed through unchanged via RunnablePassthrough.

from dotenv import load_dotenv
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
from langchain.schema.runnable import (
    RunnableSequence, 
    RunnableBranch, 
    RunnablePassthrough
)

load_dotenv()

model = ChatOpenAI(model="gpt-4o-mini", temperature=0.3)
parser = StrOutputParser()

prompt_report = PromptTemplate.from_template("Write a detailed analytical overview on {topic}")
prompt_summary = PromptTemplate.from_template("Summarize the following text in two sentences:\n\n{text}")

# Upstream generator
report_chain = RunnableSequence(prompt_report, model, parser)

# Conditional Branch
branch_logic = RunnableBranch(
    # Condition tuple: (Callable[[Any], bool], Runnable)
    (
        lambda text: len(text.split()) > 300,
        RunnableSequence(prompt_summary, model, parser)
    ),
    # Default fallback runnable
    RunnablePassthrough()
)

# Composition
full_workflow = RunnableSequence(report_chain, branch_logic)

output = full_workflow.invoke({"topic": "The geopolitical timeline of Space Exploration"})
print(output)

8. Declarative Chaining: LangChain Expression Language (LCEL)

While instantiating RunnableSequence(R1, R2, R3) is functionally complete, writing nested sequences creates boilerplate.

Because sequential composition is the most frequent pattern in LLM orchestration, LangChain introduced LangChain Expression Language (LCEL), overloading the Python bitwise OR operator (|) as a Unix-style pipe for Runnables.

Syntax Evolution: Classic vs. LCEL

# Verbose explicit instantiation
chain = RunnableSequence(prompt, model, parser)

# Clean, declarative LCEL pipe notation
chain = prompt | model | parser

Under the hood, R1 | R2 automatically constructs a RunnableSequence(R1, R2).

Expressing Complex Topologies with LCEL

LCEL cleanly combines sequential pipes, dictionaries (which coerce implicitly to RunnableParallel), lambdas, and branches:

from dotenv import load_dotenv
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
from langchain.schema.runnable import RunnablePassthrough

load_dotenv()

model = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)
parser = StrOutputParser()

prompt_joke = PromptTemplate.from_template("Tell a tech joke about {topic}")
prompt_explain = PromptTemplate.from_template("Explain why this is funny: {joke}")

# Composing sequences and parallel branches using declarative LCEL pipes
composed_chain = (
    prompt_joke 
    | model 
    | parser 
    | {
        "original_joke": RunnablePassthrough(),
        "explanation": prompt_explain | model | parser,
        "word_count": lambda x: len(x.split())  # Implicitly wrapped in RunnableLambda
    }
)

result = composed_chain.invoke({"topic": "pointers in C"})

print(f"JOKE:\n{result['original_joke']}\n")
print(f"EXPLANATION:\n{result['explanation']}\n")
print(f"COUNT:\n{result['word_count']}")

Framework Evolution Note: Currently, the pipe syntax (|) represents RunnableSequence. Future versions of LangChain aim to expand declarative syntax to other primitives (such as dedicated operators for parallel execution or dynamic branching).

9. Comprehensive Comparison of Runnable Primitives

10. Summary and Key Takeaways

• Uniform Interface: The Runnable abstract base class standardizes disparate components with uniform methods (.invoke(), .batch(), .stream()), enabling modular assembly.
• Two Runnable Types: LangChain separates Task-Specific Runnables (domain components like ChatOpenAI and PromptTemplate) from Runnable Primitives (workflow orchestrators like RunnableParallel and RunnableSequence).
• Linear Workflows: RunnableSequence chains components sequentially, automatically feeding the output of one step as the input to the next.
• Concurrent Branches: RunnableParallel broadcasts a single input across multiple execution branches concurrently, aggregating the results into a unified dictionary.
• State Retention: RunnablePassthrough serves as an identity function, forwarding data unchanged to prevent intermediate state from being lost in downstream branches.
• Arbitrary Code Integration: RunnableLambda converts custom Python functions and lambdas into first-class Runnables, integrating deterministic logic seamlessly into AI chains.
• Dynamic Routing: RunnableBranch provides conditional execution, routing inputs to specific sub-chains based on predicate functions.
• Declarative Composition with LCEL: The pipe operator (|) serves as syntactic sugar for RunnableSequence, enabling clean, readable pipeline definitions that scale from simple prompts to complex multi-step workflows.