GitHub Copilot suggests code as you type. Open SWE completes entire features while you’re in meetings. That’s the difference between a copilot and an autonomous coding agent—and it’s the shift happening right now in software development. LangChain launched Open SWE on March 17, 2026, an open-source framework that captures the patterns major companies like Stripe, Ramp, and Coinbase use for their internal coding agents. It’s not trying to replace developers. It’s trying to work like one of them.
What Is Open SWE?
Open SWE is an asynchronous coding agent that integrates directly with your GitHub repositories and works independently on complex tasks. Unlike copilots that provide real-time suggestions, Open SWE operates like another engineer on your team: you assign it a task, it researches your codebase, creates a plan, writes code, runs tests, and opens a pull request.
The architecture uses three specialized agents orchestrated through LangGraph:
Manager Agent serves as the entry point, handling task routing and state initialization. When you mention @openswe in a GitHub issue or Slack thread, the Manager receives the request and kicks off the workflow.
Planner Agent does the research. It examines your codebase, searches files, reads documentation, and produces a detailed execution strategy. Critically, it requires your approval before any code gets written. You can edit the plan, add constraints, or tell it to dig deeper.
Programmer and Reviewer Agent executes the approved plan in an isolated sandbox environment. The Programmer writes code, runs tests, and generates documentation. The Reviewer component analyzes the output, identifies issues, and feeds them back for refinement. This loop continues until the code passes quality checks.
This isn’t experimental. It’s built on LangGraph (for precise workflow control and state management) and Deep Agents (which uses file-based memory to handle large codebases without context overflow). The system deploys on LangGraph Platform, designed specifically for long-running agents that can work for minutes or hours instead of seconds.
How It Works in Practice
Here’s the workflow from task to pull request:
You create a GitHub issue: “Add rate limiting to API endpoints.” Open SWE’s Manager agent picks it up and hands it to the Planner. The Planner researches your API routes, identifies where rate limiting should apply, checks if you’re using Redis or another store, and proposes a plan: implement middleware, add distributed rate limiting with Redis, update route handlers, write tests, document the new behavior.
You review the plan. It looks good, but you add a note: “Make the rate limit configurable per endpoint.” Open SWE adjusts the plan and you approve.
The Programmer executes in an isolated sandbox. It writes the middleware, modifies your route configuration, adds tests that verify rate limiting works correctly and respects per-endpoint config, updates the API documentation. The Reviewer checks for edge cases, identifies a potential race condition in the Redis increment logic, and sends it back. The Programmer fixes it.
Twenty minutes later, Open SWE opens a pull request. Your time investment: two minutes to review the plan and one minute to add a constraint. The agent did the research, implementation, testing, and documentation.
This is what autonomous means: you’re not writing code with AI assistance. You’re delegating the entire task to an AI that works asynchronously while you focus on something else.
Enterprise Patterns That Actually Work
Stripe, Ramp, and Coinbase didn’t copy each other when they built internal coding agents. They independently converged on the same architecture. That convergence tells you something: these patterns work at scale, in production, with real engineering teams.
The common patterns Open SWE captures:
Isolated cloud sandboxes provide full execution permissions within strict boundaries. Mistakes stay contained. The agent can run commands, modify files, and execute tests without approval prompts for every action—but it can’t touch production systems.
Curated toolsets give agents about 15 specific tools: shell execution, web fetching, API calls, Git operations, Slack and Linear integrations. This isn’t unlimited access. It’s enough capability to complete tasks without overwhelming the agent with options.
Subagent orchestration allows the main agent to spawn child agents for parallel subtasks. Each subagent gets isolated context so different pieces of work don’t pollute each other’s reasoning.
Workflow integration means agents trigger from Slack, Linear, or GitHub. You don’t switch contexts to use the agent. It meets you where you already work.
LangChain built Open SWE because these patterns proved themselves at multiple companies. The framework gives you the architecture; you customize it for your codebase and workflows.
Getting Started Takes Minutes
Want to try it? The hosted version at swe.langchain.com gets you running fast:
- Connect your GitHub account (OAuth authorization)
- Select which repositories Open SWE can access
- Add your Anthropic API key (required for the AI models)
- Create a GitHub issue with a task description
- Mention
@openswein the issue or your Slack channel - Review the plan when prompted
- Approve and let it work
For enterprise use, the full source code is available on GitHub under an MIT license. You can self-host on your infrastructure, customize the prompts, swap sandbox providers (Modal, Daytona, Runloop, LangSmith), and extend the toolset for your specific needs.
This matters for companies with security or compliance requirements. You’re not sending code to a third-party service. You control where the agent runs and what data it accesses.
When to Use Agents vs Copilots
Not every task needs an autonomous agent. Copilots still win for certain workflows, and LangChain acknowledges this: “For small one-liner bug fixes or simple style updates, this architecture is not optimal.” They’re building a local CLI version for simpler tasks.
Here’s the decision framework:
Use copilots (GitHub Copilot, Cursor inline suggestions) when you’re writing a single function, making quick style updates, learning a new API, or need immediate feedback as you code. Copilots give you fast iteration.
Use autonomous agents (Open SWE, Devin) when the task spans multiple files, requires research and planning, can run while you work on something else, involves extensive testing, or handles repetitive refactoring. Agents give you slow deliberation.
The best developers in 2026 know when to use each. Copilots for fast iteration. Agents for delegated execution. Neither replaces the other.
The Bigger Industry Shift
Agentic AI adoption surged 920% between early 2023 and mid-2025. LangChain and CrewAI now appear in 1.6 million GitHub repositories. Every major IDE is racing to add agent capabilities: GitHub Copilot added Agent Mode, Cursor shipped Background Agents, Windsurf’s Cascade became fully agentic.
The defining shift in 2026: agents are no longer limited to short prompt-response interactions. They run for minutes or hours. This transition from chat-based assistance to autonomous execution loops changes how developers work.
Open SWE positions itself as the open-source framework for enterprise internal agents. While Cursor and Claude Code target individual developers with proprietary IDEs, Open SWE gives engineering organizations a customizable, self-hosted solution. No per-seat licensing. No vendor lock-in. You own the infrastructure and adapt it to your workflows.
That’s the bet LangChain is making: enterprises want the patterns Stripe, Ramp, and Coinbase discovered, but they want them open-source, extensible, and under their control. Based on the convergence those companies demonstrated, it’s a reasonable bet.
