# Open SWE

> An open-source framework for building internal coding agents that integrate with Slack, Linear, and GitHub, built on LangGraph and Deep Agents.

Open SWE is an MIT-licensed, open-source framework released by LangChain in March 2026 for building internal coding agents that operate alongside engineering teams. It is built on LangGraph and Deep Agents, and provides the core architectural components observed across production coding agent deployments at companies like Stripe, Ramp, and Coinbase. The framework is available on GitHub and is designed to be customized for any organization's codebase and workflows.

## What It Is

Open SWE is a customizable agent harness that gives engineering organizations a starting point for deploying AI coding agents internally. Rather than requiring teams to build from scratch, it packages the architectural patterns that have converged across multiple production deployments: isolated cloud sandboxes, curated toolsets, subagent orchestration, and integration with developer workflows like Slack, Linear, and GitHub. The framework composes on top of Deep Agents and LangGraph, meaning organizations can pull in upstream improvements without rebuilding their customizations.

## Architecture and Core Components

Open SWE is structured around seven architectural decisions:

- **Agent harness**: Composed on Deep Agents, similar to how Ramp built Inspect on OpenCode. Provides an upgrade path and customization without forking.
- **Sandbox**: Each task runs in an isolated cloud Linux environment. Supported providers include Modal, Daytona, Runloop, E2B, and LangSmith. Sandboxes persist per thread and auto-recreate if unreachable.
- **Curated toolset**: Approximately 15 tools including `execute` (shell), `fetch_url`, `http_request`, `linear_comment`, `slack_thread_reply`, and built-in Deep Agents tools (`read_file`, `write_file`, `edit_file`, `ls`, `glob`, `grep`, `write_todos`, `task`).
- **Context engineering**: Reads an `AGENTS.md` file from the repository root and injects it into the system prompt alongside full Linear issue or Slack thread history.
- **Orchestration**: Combines subagent spawning via the `task` tool with deterministic middleware hooks (`check_message_queue_before_model`, `notify_step_limit_reached`, `ToolErrorMiddleware`).
- **Invocation surfaces**: Slack (mention the bot in any thread), Linear (comment `@openswe` on an issue), and GitHub (tag `@openswe` in PR comments).
- **Validation**: Prompt-driven, with the agent instructed to run linters, formatters, and tests before committing and opening a draft PR.

## Why Deep Agents as the Foundation

The blog post from LangChain explains that Deep Agents provides several infrastructure capabilities that make Open SWE composable: file-based context management to prevent context overflow on large codebases, a built-in `write_todos` planning primitive, native subagent isolation so subtasks don't pollute each other's conversation history, and middleware hooks for injecting deterministic logic at specific points in the agent loop. Because Deep Agents is maintained as a standalone library, improvements to context compression, prompt caching, and subagent orchestration flow to Open SWE without requiring rebuilds.

## Customization for Organizations

Every major component is pluggable. Organizations can swap the sandbox provider, configure any LLM (the README shows both Claude Opus 4 and GPT-5.6-sol as examples), add tools for internal APIs or deployment systems, modify Slack/Linear/GitHub trigger logic, customize the system prompt and `AGENTS.md` incorporation logic, and add middleware hooks for validation, approval gates, or safety checks. Optional server-side integrations include Datadog and LangSmith observability tools (loaded only for authorized users) and Corridor guardrails via a hosted MCP server. A companion web dashboard (`ui/`) handles GitHub login, per-user model and profile settings, team defaults, enabled-repo management, user mappings, and an Agents chat UI.

## Update: Released March 2026

Open SWE was announced on March 17, 2026 via the LangChain blog. The GitHub repository was created on May 21, 2025 and had accumulated over 10,000 stars and 1,167 forks as of July 2026, with active development continuing (last push July 10, 2026). The project is MIT-licensed and positioned as a reference implementation of production coding agent patterns, with a Customization Guide and Installation Guide included in the repository docs.

## Features
- Trigger from Slack, Linear, or GitHub via @openswe mention
- Isolated cloud sandbox per task (Modal, Daytona, Runloop, E2B, LangSmith)
- Subagent spawning for parallel subtasks via task tool
- AGENTS.md context injection from repository root
- Automatic PR creation and GitHub draft PR opening
- Mid-run message injection via middleware
- Curated toolset: execute, fetch_url, http_request, linear_comment, slack_thread_reply
- Persistent sandbox per conversation thread with auto-recreation
- Optional Datadog and LangSmith observability tools (admin-authorized)
- Optional Corridor guardrails via hosted MCP server
- Web dashboard for GitHub login, model settings, team defaults, and Agents chat UI
- Pluggable sandbox provider, model, tools, triggers, system prompt, and middleware
- Deterministic thread ID routing for follow-up messages
- Parallel task execution across isolated sandboxes

## Integrations
Slack, Linear, GitHub, Modal, Daytona, Runloop, E2B, LangSmith, Datadog, Corridor, Anthropic Claude, OpenAI GPT, LangGraph, Deep Agents

## Platforms
LINUX, WEB, API, DEVELOPER_SDK, CLI

## Pricing
Open Source

## Links
- Website: https://www.langchain.com/blog/open-swe-an-open-source-framework-for-internal-coding-agents
- Documentation: https://github.com/langchain-ai/open-swe/blob/main/docs/INSTALLATION.md
- Repository: https://github.com/langchain-ai/open-swe/
- EveryDev.ai: https://www.everydev.ai/tools/open-swe