open-swe README

The project's README from github.com/langchain-ai/open-swe. As one markdown file: README.md.

Open SWE Logo

An open-source software factory built on Deep Agents by LangChain.

License GitHub Stars Built on Deep Agents Powered by LangGraph Twitter / X

Open SWE turns engineering work into a repeatable system. Give it a code-change task from the dashboard, GitHub, Slack, or Linear—or run one on a schedule—and it works in an isolated environment to understand the codebase, make changes, validate them, and deliver a pull request.

It goes beyond code generation. Open SWE can review pull requests, learn a repository's review style, monitor CI, and respond to feedback. It is open source, deployable in your infrastructure, and designed to be adapted to your team's repositories, tools, policies, and workflows.

[!NOTE] Open SWE is under active development. APIs, setup, and product surfaces may continue to evolve.

The software factory loop

flowchart LR
    A[Issues, conversations, PRs, schedules] --> B[Plan and investigate]
    B --> C[Implement in an isolated sandbox]
    C --> D[Validate and deliver a PR]
    D --> E[Review, CI, and feedback]
    E -->|Follow-up work| B

Each cloud coding thread is bound to its own persistent sandbox, so the agent can continue from prior work when you reply. A thread is a durable conversation and work context. It can contain multiple invocations, each an agent execution triggered by a message or automation. An initial request and a follow-up belong to one thread and produce two invocations, each with its own usage. Independent threads run in parallel, and the same thread carries context from request through delivery and follow-up. Read-only PR chat does not need a sandbox, while desktop work can run directly against an allowlisted local project.

What Open SWE does

Build

Review

Operate

Customize

API contract

swagger.json is the generated OpenAPI 3.1 contract for the custom FastAPI backend (agent.webapp:app). Import it into an OpenAPI 3.1-compatible viewer, or run make run and open http://localhost:8000/docs for interactive API documentation (/openapi.json serves the live schema).

Regenerate the file with make swagger after changing backend routes or models. It reflects the current route declarations: some request/response schemas and authentication requirements are not yet documented. LangGraph runtime endpoints (such as /runs, /threads, and /assistants) are not included.

How it works

Deep Agents is the harness

Open SWE composes the agent with Deep Agents. Deep Agents provides the planning, file operations, shell access, skills, state, and subagent primitives; Open SWE adds the software-engineering tools, prompts, middleware, integrations, authorization, and product surfaces needed for end-to-end engineering work.

This composition keeps the system extensible while allowing it to inherit improvements from the underlying LangChain agent stack.

LangGraph is the runtime

LangGraph provides durable execution and thread state. Each Open SWE invocation executes as a LangGraph run within a thread. Open SWE currently ships five graph entrypoints:

Graph Role
Agent Plans, implements, validates, and delivers software changes
Reviewer Performs read-only pull request reviews
Analyzer Learns repository-specific review style
Chat Answers questions about pull requests without changing code
Scheduler Dispatches recurring tasks and CI monitoring work

Sandboxes contain the work

Cloud work runs in isolated Linux sandboxes with the development tooling supplied by the configured environment or snapshot. A sandbox persists with its thread, but an unreachable coding sandbox is not silently replaced—Open SWE fails safely rather than risk discarding uncommitted work.

LangSmith is the default sandbox and tracing provider. Open SWE also supports Modal, Daytona, Runloop, E2B, and local execution, with a pluggable interface for additional providers.

Tools stay curated

Deep Agents supplies the core filesystem, shell, and subagent tools. Open SWE adds focused capabilities for GitHub delivery, Linear, Slack, thread management, web research, browser-based application verification, planning, review, CI monitoring, and connected services. Personal integrations load using the user's connections. Admin-configured workspace MCP tools are available to all coding-agent users.

Work where your team works

Control and safety

A useful software factory needs both autonomy and boundaries. Open SWE includes:

Sandboxes can have network access and powerful tools. Deployments should use least-privilege credentials, restrict enabled repositories and integrations, and tailor approval rules to their environment.

Getting started

Open SWE includes a LangGraph backend, a web dashboard, and an experimental desktop client.

One deployment serves the API, the webhooks, and the dashboard from a single URL. Locally:

git clone https://github.com/langchain-ai/open-swe.git
cd open-swe
uv venv
source .venv/bin/activate
uv sync --all-extras
make build-dashboard   # pnpm install + Vite build of the dashboard
make dev               # http://localhost:2024 serves the API and the dashboard

Create a GitHub App and a Slack app for your machine and fill in .env as described in the development guide, then sign in at http://localhost:2024. For UI work, make dev-ui starts Vite and the backend fronting it, so the same URL hot-reloads. GitHub and Slack deliver to a public webhook URL: locally the static domain of a free ngrok account (make tunnel NGROK_DOMAIN=<name>.ngrok-free.dev, which exposes only /webhooks/*, since the dev server's LangGraph API has no authentication), on LangGraph Platform the deployment URL.

Production self-hosting uses the standalone LangGraph Agent Server and requires its license key.

Project status

Open SWE is built in the open by LangChain and is evolving quickly. The original internal coding-agent framework announcement is available on the LangChain blog; the project has since expanded considerably.

License

Open SWE is licensed under the MIT License.

open-swe (langchain-ai/open-swe)

Searching Database…

11K ·GitHub
Open-swe
What is this?Open SWE is an open-source asynchronous coding agent - a 'software factory' built on LangChain's Deep Agents - that takes a code-change task from a dashboard, GitHub, Slack, or Linear (or a schedule), works in an isolated sandbox to understand the codebase, makes changes, validates them, and delivers a pull request.
Is this a ready-made app or something I deploy myself?It is a self-hosted platform you deploy in your own infrastructure: a LangGraph backend, a web dashboard, and an experimental desktop client, launched via the LangGraph Platform or Docker.
How do I get it running?Deploy it for a team via the LangGraph Platform or Docker, create the GitHub and Slack apps, and configure model providers and environment variables as described in the Installation Guide; for local dev, run with hot reload and an ngrok tunnel for webhooks.
What do I need before deploying it - GitHub and Slack apps, API keys?You need a GitHub App and Slack app for triggers and delivery, model-provider credentials, and a sandbox/tracing provider (LangSmith by default, or Modal, Daytona, Runloop, E2B); production self-hosting also requires a LangGraph Agent Server license key.
Is the desktop client ready to use on any OS?The desktop client is still experimental; packaged releases currently only target macOS, while Windows and Linux only work if you build from source.
Where can I trigger and manage tasks from?You can start and manage tasks from the web dashboard, GitHub issues and PR comments, Slack channels or threads, Linear issues, and run the agent locally against your own machine via the experimental desktop client.
What is Deep Agents and how does it relate to Open SWE?Deep Agents is the LangChain agent harness providing planning, file operations, shell access, and subagent primitives; Open SWE layers software-engineering tools, prompts, integrations, and product surfaces on top of it.
What sandbox providers can I use for cloud work?LangSmith is the default sandbox and tracing provider, with built-in support for Modal, Daytona, Runloop, E2B, and local execution through a pluggable interface.
Does it keep an eye on CI after opening a PR?With the opt-in /baby-sit automation it monitors pull requests, diagnoses CI failures, and reruns only evidence-backed flaky jobs.
What are similar projects?moyai, qwen-code, orca, trueforge, evenfire, useagent, 1code, eve-software-factory-template
Which topics is it in?claudecode, pull-request, llms, slack, code-generation, code-review, ai-coding, fastapi, autonomous-agents, coding-agents, oauth, sandbox
Creator
langchain-ai
Size
76.1 MB
Stars
11K
Updated
CommitOct 18Releasedesktop-v0.3.8Oct 15
Age
1y
Commits · 90 Days