LangChain releases Open SWE, an open-source framework for internal coding agents

Patterns from Stripe, Ramp and Coinbase

LangChain says that over the past year it has seen several engineering organizations build internal coding agents that operate alongside their development teams. Stripe developed Minions, Ramp built Inspect, and Coinbase created Cloudbot. These systems are reached through Slack, Linear and GitHub, so engineers do not have to adopt new interfaces.

Although the systems were built independently, LangChain says they converged on similar designs. It lists five shared patterns:

• Isolated execution environments: tasks run in dedicated cloud sandboxes with full permissions inside strict boundaries, which limits the blast radius of mistakes and lets agents run commands without approval prompts for each action.
• Curated toolsets: according to Stripe's engineering team, its agents have access to around 500 tools, selected and maintained rather than accumulated over time.
• Slack-first invocation: all three systems use Slack as a primary interface.
• Rich context at startup: agents pull full context from Linear issues, Slack threads or GitHub PRs before starting work.
• Subagent orchestration: complex tasks are split and delegated to specialized child agents with isolated context.

LangChain adds that organizations will likely need to adapt specific components to their own environments.

How Open SWE is built

Open SWE is built on Deep Agents and LangGraph. Rather than forking an existing agent or starting from scratch, it composes on the Deep Agents framework, an approach LangChain compares to how Ramp built Inspect on top of OpenCode. LangChain names two advantages: improvements to Deep Agents can be adopted without rebuilding customizations, and org-specific tools, prompts and workflows can be kept as configuration instead of changes to core agent logic.

Each task runs in its own isolated cloud sandbox, described as a remote Linux environment with full shell access. Supported providers out of the box are Modal, Daytona, Runloop and LangSmith, and users can write their own sandbox backend. Each conversation thread gets a persistent sandbox that is reused for follow-up messages, sandboxes are recreated automatically if they become unreachable, and multiple tasks can run in parallel.

The toolset is deliberately small. Open SWE ships with execute, fetch_url, http_request, commit_and_open_pr, linear_comment and slack_thread_reply, plus the built-in Deep Agents tools read_file, write_file, edit_file, ls, glob, grep, write_todos and task. LangChain says a smaller toolset can be easier to test, maintain and reason about, and that teams can add tools such as internal APIs or custom deployment systems explicitly.

Context, orchestration and invocation

Open SWE gathers context from two sources. If a repository has an AGENTS.md file at its root, it is read from the sandbox and injected into the system prompt to encode conventions, testing requirements and team-specific patterns. The full Linear issue, including title, description and comments, or the Slack thread history is also passed to the agent before it starts, which avoids extra tool calls.

Orchestration combines subagents with deterministic middleware. The main agent can delegate independent subtasks through the task tool to subagents, each with its own middleware stack, todo list and file operations. Three middleware hooks are named:

• check_message_queue_before_model: injects follow-up Linear comments or Slack messages that arrive mid-run before the next model call.
• open_pr_if_needed: commits and opens a PR if the agent did not complete that step.
• ToolErrorMiddleware: catches and handles tool errors.

Users can invoke the agent in three ways. In Slack, they mention the bot in a thread and can use repo:owner/name syntax to choose a repository. In Linear, they comment @openswe on an issue. In GitHub, they tag @openswe in comments on agent-created PRs to have it address review feedback and push fixes to the same branch. Each invocation creates a deterministic thread ID, so follow-ups route to the same running agent.

For validation, the agent is instructed to run linters, formatters and tests before committing. LangChain says teams can extend this layer with deterministic CI checks, visual verification or review gates as additional middleware.

What it means for engineering teams

LangChain positions Open SWE as a starting point for organizations exploring internal coding agents, offering the common architecture without requiring a build from zero. The company also points to Deep Agents features that support the design, including file-based context management that offloads large results instead of keeping them in conversation history, which it says can help prevent context overflow on larger codebases. The built-in write_todos tool gives agents a structured way to plan and track complex work.

Because customizations live in configuration rather than in a fork, teams that adopt the framework can in principle follow upstream Deep Agents improvements while keeping their own tools and prompts, according to LangChain.