Open SWE: An Open-Source Framework for Internal Coding Agents

LangChain has released Open SWE, an open-source framework for building internal coding agents, available now on GitHub under the MIT license. The announcement says the framework generalizes architectural patterns LangChain observed over the past year across engineering organizations that built their own agents: Stripe's Minions, Ramp's Inspect, and Coinbase's Cloudbot. Those systems were built independently but converged on similar designs, and Open SWE packages that convergence into a customizable starting point. It is built on Deep Agents and LangGraph.
The patterns LangChain identifies are specific. Tasks run in dedicated cloud sandboxes with full permissions inside strict boundaries, isolating mistakes from production systems while letting agents execute commands without per-action approval prompts. Toolsets are curated rather than accumulated; LangChain cites Stripe's engineering team saying their agents have access to around 500 tools, carefully selected and maintained. All three internal systems use Slack as a primary invocation surface. Agents pull full context from Linear issues, Slack threads or GitHub PRs before starting work. And complex tasks are decomposed into specialized subagents with isolated context.
Open SWE's first component is the agent harness, composed on Deep Agents rather than forked from an existing agent. LangChain compares this to how Ramp built Inspect on OpenCode, and argues composition buys two things: an upgrade path, so improvements to context management, planning or token usage flow in without rebuilding customizations, and customization without forking, so org-specific tools, prompts and workflows live as configuration. The documented entry point is create_deep_agent, which takes a model, a constructed system prompt, a tool list, a sandbox backend and middleware hooks.
The second component is the sandbox. Each task gets its own isolated remote Linux environment with full shell access; the repository is cloned in and errors stay contained. Supported providers out of the box are Modal, Daytona, Runloop and LangSmith, and you can implement your own backend. Each conversation thread gets a persistent sandbox reused across follow-up messages, sandboxes automatically recreate if they become unreachable, and multiple tasks run in parallel in separate sandboxes.
Tools are deliberately narrow. Alongside Deep Agents' built-in read_file, write_file, edit_file, ls, glob, grep, write_todos and task tools, Open SWE ships a focused set that includes http_request, fetch_url, commit_and_open_pr, linear_comment and slack_thread_reply. LangChain's position is that a smaller curated toolset is easier to test, maintain and reason about, with org-specific tools for internal APIs, deployment systems or testing frameworks added explicitly.
Context comes from two layers. If a repository has an AGENTS.md file at its root, it is read from the sandbox and injected into the system prompt, carrying conventions, testing requirements and architectural decisions that should apply to every run. Task-specific context — the full Linear issue including title, description and comments, or Slack thread history — is assembled and passed to the agent before it starts, so the agent does not have to discover requirements through tool calls.
Orchestration splits into agentic and deterministic halves. On the agentic side, Deep Agents supports spawning child agents via the task tool, each with its own middleware stack, todo list and file operations, so subtasks do not pollute each other's context. On the deterministic side, middleware hooks run around the agent loop: check_message_queue_before_model injects follow-up messages that arrive mid-run, such as Linear comments or Slack messages, before the next model call; open_pr_if_needed commits and opens a pull request if the agent did not; ToolErrorMiddleware handles tool failures gracefully. LangChain frames this split as a way to balance reliability with flexibility.
Invocation covers Slack, Linear and GitHub, each in the tool developers already use. In Slack you mention the bot in a thread and can pass repo:owner/name to pick a repository; the agent replies in-thread with status and PR links. In Linear you comment @openswe on an issue; the agent reads the issue, reacts with a eyes emoji to acknowledge and posts results as comments. On GitHub you tag @openswe in PR comments on agent-created PRs to 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. Validation is prompt-driven — the agent is told to run linters, formatters and tests before committing — with open_pr_if_needed as a backstop.
LangChain lists five reasons for building on Deep Agents: file-based memory that offloads large intermediate data such as file contents and command output instead of keeping it in conversation history; the write_todos planning primitive; subagent isolation; middleware hooks for deterministic logic; and the upgrade path from a standalone, actively developed library. The default model is Claude Opus 4, and LangChain notes you can configure different models for different subtasks.
Every major component is described as pluggable: sandbox provider, model, tools, triggers, system prompt and middleware. The Customization Guide covers each extension point. Installation requires GitHub App creation, LangSmith setup, Linear, Slack and GitHub triggers, and production deployment. LangChain also points to a LangSmith Sandboxes waitlist.
Two caveats are worth flagging. LangChain describes Open SWE as a customizable foundation rather than a finished product, and the comparison to the internal systems at Stripe, Ramp and Coinbase is explicitly based on publicly available information — the differences lie in implementation details, internal integrations and org-specific tooling. In practice, that means the hard part for most teams is unlikely to be the framework itself but the surrounding work: creating the GitHub App, wiring triggers, deciding which tools to expose, and getting the AGENTS.md conventions right. The sandbox abstraction also has real operational consequences. Persistent sandboxes reused across a thread make multi-turn work smoother but raise questions about state drift and cost that the announcement does not address; automatic recreation helps but can silently discard in-progress files.
Why it matters: Teams that have watched Stripe, Ramp and Coinbase build internal coding agents but lacked the staffing to replicate them now have a reference implementation to fork, MIT-licensed and installable today. Developers should expect to spend their time on configuration rather than agent internals — sandbox choice, tool curation, prompt and middleware — because that is where Open SWE puts its extension points. As inference, the main risk is that a framework designed from publicly described systems may not match an organization's internal constraints, so a small pilot before broad rollout seems the safer path.
Based on reporting from the original publisher. Visit the source for full context and later updates.
Publisher excerpt
Built on Deep Agents and LangGraph, Open SWE provides the core architectural components for internal coding agents.