# How Open-SWE Integrates with LangChain: Architecture and Implementation

> Discover how Open-SWE integrates with LangChain using its Core message types and init_chat_model factory. Build a customizable coding assistant with DeepAgents and LangGraph.

- Repository: [LangChain/open-swe](https://github.com/langchain-ai/open-swe)
- Tags: architecture
- Published: 2026-03-19

---

**Open-SWE integrates with LangChain by leveraging LangChain Core message types, the `init_chat_model` factory for LLM abstraction, and DeepAgents orchestration on top of LangGraph state machines, enabling a customizable coding assistant with deterministic execution and multimodal support.**

The `langchain-ai/open-swe` repository demonstrates how Open-SWE integrates with LangChain to build a powerful internal coding assistant. This architecture combines LangChain's standardized message abstractions and chat model factories with DeepAgents orchestration and LangGraph persistence layers to create an extensible agent framework.

## Core LangChain Message Abstractions

Open-SWE builds upon LangChain Core's message model to represent and manipulate LLM-generated content. The framework uses **`ContentBlock`**, **`AIMessage`**, and related types to normalize multimodal conversation data.

In [`agent/utils/messages.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/utils/messages.py), the system imports `ContentBlock` directly from `langchain_core.messages` to handle message normalization. The web application layer in [`agent/webapp.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/webapp.py) leverages `create_text_block` from `langchain_core.messages.content` to construct properly formatted text content blocks for LLM consumption.

## Chat Model Integration via `init_chat_model`

All LLM calls in Open-SWE funnel through LangChain's **`init_chat_model`** factory, which abstracts provider-specific implementations such as OpenAI, Anthropic, and others behind a unified interface.

The [`agent/utils/model.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/utils/model.py) file implements a `make_model` wrapper that calls `init_chat_model` to construct the underlying model instance. This implementation specifically handles provider-specific configuration, including injecting the OpenAI response streaming URL when model IDs begin with the `openai:` prefix. This abstraction allows Open-SWE to switch between different LLM providers without modifying the core agent logic.

## DeepAgents and LangGraph Orchestration

The primary integration point for agent behavior is the **`create_deep_agent`** function from the DeepAgents package, which composes a LangChain-compatible agent on top of a LangGraph execution graph.

In [`agent/server.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/server.py), the system imports `create_deep_agent` and invokes it to build the final agent instance. This construction passes the LangChain model (from `make_model`), system prompts, tool registries, and middleware pipelines to create a deterministic state machine. The resulting agent supports sub-agent spawning, middleware processing, and precise state handling through LangGraph's graph-based execution model.

For long-running conversations, Open-SWE utilizes the **`LangGraphClient`** from `langgraph_sdk`. The [`agent/webapp.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/webapp.py) module acquires this client via `get_client` to read and write per-thread metadata, including sandbox IDs and repository configuration, enabling persistent agent state across interactions.

## Tool Integration with LangChain Interface

Open-SWE registers LangChain-style tools that the LLM can invoke through standard tool-calling interfaces. These tools follow LangChain's tool definition patterns and integrate directly with the agent's execution loop.

The `agent/tools/` directory contains implementations for **`http_request`**, **`fetch_url`**, **`commit_and_open_pr`**, **`linear_comment`**, **`slack_thread_reply`**, and **`github_comment`**. In [`agent/server.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/server.py), these tools are collected into a list and passed directly to `create_deep_agent`, making them available for the LLM to invoke during task execution. This design allows external service integration (GitHub, Slack, Linear) through LangChain's standardized tool interface.

## Multimodal Support via LangChain Core

When processing visual content, Open-SWE utilizes LangChain Core's multimodal utilities to embed images into messages. The [`agent/utils/multimodal.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/utils/multimodal.py) file imports **`create_image_block`** from LangChain Core to handle image data, while [`agent/webapp.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/webapp.py) uses **`create_text_block`** for text content. This enables the coding assistant to process architecture diagrams, screenshots, and other visual inputs alongside code and text.

## Implementation Examples

### Building an Open-SWE Agent

This example demonstrates the core integration pattern: initializing a LangChain model and wrapping it with DeepAgents orchestration.

```python
from open_swe.agent.utils.model import make_model
from deepagents import create_deep_agent
from open_swe.agent.tools import (
    http_request,
    fetch_url,
    commit_and_open_pr,
    linear_comment,
    slack_thread_reply,
    github_comment,
)

# Initialize any LangChain-compatible model

model = make_model(
    "anthropic:claude-opus-4-6",
    temperature=0,
    max_tokens=20_000,
)

# Construct the agent with LangChain tools and DeepAgents middleware

agent = create_deep_agent(
    model=model,
    system_prompt="You are an internal coding assistant.",
    tools=[
        http_request,
        fetch_url,
        commit_and_open_pr,
        linear_comment,
        slack_thread_reply,
        github_comment,
    ],
    middleware=[],
)

```

### Invoking the Agent with State Management

This pattern shows how Open-SWE uses LangGraph's state management through the `RunnableConfig` interface.

```python
from langgraph.graph.state import RunnableConfig

# Configure thread metadata for LangGraph persistence

config: RunnableConfig = {
    "configurable": {
        "thread_id": "thread-123",
        "repo": {"owner": "langchain-ai", "name": "open-swe"},
        "__is_for_execution__": True,
    },
    "metadata": {},
}

# Get the configured agent (spawns sandbox and clones repo)

agent = await get_agent(config)

# Send user prompt through the LangChain-compatible interface

response = await agent.ainvoke(
    {"messages": [{"role": "user", "content": "Create a new Python file that prints hello"}]},
    config,
)

```

### Processing Multimodal Content

This example utilizes LangChain Core utilities for handling mixed content types.

```python
from langchain_core.messages.content import create_text_block, create_image_block

# Construct multimodal message using LangChain primitives

msg = [
    create_text_block("Here is an architecture diagram:"),
    create_image_block(url="https://example.com/arch.png"),
]

# Pass to the agent for processing

response = await agent.ainvoke({"messages": msg}, config)

```

## Summary

- **LangChain Core Types**: Open-SWE uses `ContentBlock` and message utilities from `langchain_core.messages` to standardize multimodal content handling.
- **Model Abstraction**: The `init_chat_model` factory in [`agent/utils/model.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/utils/model.py) enables provider-agnostic LLM integration supporting OpenAI, Anthropic, and others.
- **DeepAgents Orchestration**: `create_deep_agent` in [`agent/server.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/server.py) combines LangChain components with LangGraph state machines for deterministic execution.
- **Persistent State**: The `LangGraphClient` manages thread metadata and sandbox state through the `langgraph_sdk` integration in [`agent/webapp.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/webapp.py).
- **Tool Ecosystem**: LangChain-compatible tools in `agent/tools/` provide standardized interfaces for GitHub, Slack, Linear, and HTTP operations.

## Frequently Asked Questions

### What LangChain components does Open-SWE use?

Open-SWE utilizes **LangChain Core** for message abstractions (`ContentBlock`, `AIMessage`), **LangChain Chat Models** via `init_chat_model` for LLM provider abstraction, and **LangGraph** through the `langgraph_sdk` for state persistence and thread management. The integration also uses DeepAgents, which builds upon LangChain's agent architecture to provide advanced orchestration capabilities.

### How does Open-SWE handle different LLM providers?

The framework handles provider diversity through the `make_model` function in [`agent/utils/model.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/utils/model.py), which wraps LangChain's `init_chat_model`. This factory method accepts model identifiers like `anthropic:claude-opus-4-6` or `openai:gpt-4` and automatically configures the appropriate client, handling provider-specific parameters such as streaming URLs and authentication without requiring changes to the agent logic.

### What is the role of DeepAgents in the integration?

DeepAgents serves as the orchestration layer that combines LangChain's model and tool interfaces with LangGraph's state machine execution. The `create_deep_agent` function accepts LangChain-compatible models and tools, then constructs an agent capable of deterministic state management, sub-agent spawning, and middleware pipeline processing. This extends standard LangChain agents with advanced workflow capabilities required for complex coding tasks.

### How does Open-SWE manage conversation state?

Conversation state persists through the **LangGraphClient** from `langgraph_sdk`, as implemented in [`agent/webapp.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/webapp.py). The system stores per-thread metadata—including sandbox IDs, repository configurations, and execution context—in a LangGraph server. This enables the agent to resume operations across multiple interactions while maintaining context about the current coding environment and previous tool invocations.