LangChain just released Open SWE on March 17 (4 days ago) — the first open-source framework for building asynchronous coding agents that work like real teammates. Unlike Cursor or Copilot that block your workflow while they execute, Open SWE runs in cloud sandboxes, accepts mid-run feedback, and integrates with Slack, Linear, and GitHub. Built on battle-tested patterns from Stripe, Ramp, and Coinbase, it’s already trending #2 on GitHub with 7,700+ stars.
Why Async Execution Matters
Tired of watching Cursor think? Existing coding tools (Cursor, Copilot, Claude Code) force synchronous workflows: you trigger a task, watch it execute, and wait until it finishes. Open SWE breaks this model with asynchronous, cloud-based execution.
Tasks run in isolated sandboxes (Modal, Daytona, Runloop, or LangSmith) while you work on other things. Moreover, if you change your mind mid-task, send new feedback via “double texting” — no restarts needed. It’s the paradigm shift from “AI pair programmer” to “AI teammate”: delegate long-running tasks and move on.
The architecture captures patterns from elite engineering orgs. Stripe built Minions for automated refactors. Ramp created Inspect for code review automation. Coinbase developed Cloudbot for infrastructure workflows. Open SWE distills these proven approaches into an open-source framework any team can use.
10-Minute Setup Guide
Getting started requires four steps: connect GitHub, provide an LLM API key, configure a sandbox backend, and trigger your first task.
Basic setup code:
from deepagents import create_deep_agent
from open_swe.tools import http_request, fetch_url, commit_and_open_pr
agent = create_deep_agent(
model="anthropic:claude-opus-4-6",
system_prompt=construct_system_prompt(repo_dir, agents_md_content),
tools=[http_request, fetch_url, commit_and_open_pr, ...],
backend=sandbox_backend,
middleware=[ToolErrorMiddleware(), check_message_queue_before_model],
)The framework handles file-based memory to avoid context overflow, built-in planning, and child agent spawning. Furthermore, each task runs in its own isolated environment, enabling parallel execution without consuming local resources.
Trigger tasks from wherever your team already works. Mention the bot in Slack (@openswe repo:myorg/app fix the race condition), comment on Linear issues (@openswe please implement this), or tag in GitHub PR reviews. Consequently, each invocation creates a deterministic thread ID — follow-ups route to the same running agent.
AGENTS.md: The Secret to Consistent Behavior
Most coding agent tutorials skip this, but it’s critical: AGENTS.md encodes your org-specific conventions. The agent reads this repo-root file from the sandbox and injects it into system prompts automatically.
Without AGENTS.md, agents hallucinate patterns, guess at coding styles, and create inconsistent code. However, developer community feedback (Hacker News) consistently criticizes rapid AI tool releases for “not testing enough” — AGENTS.md is the safeguard that prevents broken PRs.
Example AGENTS.md:
# AGENTS.md
## Architecture
- SvelteKit 5: use runes ($state, $derived), not stores
- Database queries via src/lib/db.ts only
- Run `npm run typecheck` before commits
## Testing
- Unit tests in src/__tests__/, vitest framework
- Zero tolerance for failures—run `npm test` before PRsThis is the difference between “agent that sometimes works” and “reliable internal teammate.” Therefore, don’t rely on the agent “learning” your style — explicitly document architecture rules, testing requirements, and code standards.
How It Works: Three-Agent Architecture
Open SWE uses a three-agent workflow built on LangGraph (orchestration) and Deep Agents (planning, subagents, file systems).
The Manager routes user interactions and initializes task state. The Planner analyzes the codebase, searches files, and drafts step-by-step execution plans — then pauses for human approval. You can accept, edit, or reject the plan before execution starts. Finally, the Programmer executes code changes, runs tests and linters, while the Reviewer checks quality and opens pull requests.
This interruptible planning addresses developer concerns about autonomous agents making wrong choices. In fact, you approve the plan at the critical decision point, then let the agent execute independently.
Open SWE excels at long-running tasks where planning and iterative execution provide leverage: multi-file refactors, test creation and repair, dependency updates, feature scaffolding, documentation generation, and bug fixes from GitHub issues. Nevertheless, it’s not ideal for simple one-liners — LangChain acknowledges this gap and is building a local CLI version for tasks where planning overhead isn’t needed.
What You’re Really Getting
This isn’t Cursor’s synchronous IDE completion (51.7% SWE-Bench, 62.9s avg) or Copilot’s basic autocomplete (56%, 89.9s avg). Instead, Open SWE targets a different workflow: asynchronous, cloud-based tasks that run while you work on other things.
2026 developer surveys show 84% use AI coding tools, but existing tools force you to wait and watch. Meanwhile, Open SWE’s async execution matches how teams actually work: delegate tasks, context-switch, provide feedback when needed.
The cost model differs too. Cursor charges $20/month flat. Copilot costs $10/month. In contrast, Open SWE is usage-based: LLM API costs (Anthropic, OpenAI, etc.) plus sandbox provider fees. Additionally, test with small tasks (documentation updates, simple refactors) before scaling to complex multi-file features.
Most teams use multiple tools in practice: Cursor for IDE workflows, Claude Code for terminal-based hard problems (80.8% SWE-Bench), Copilot as a safety net, and now Open SWE for async background tasks. Know when to use each.
Key Takeaways
- Open SWE brings async coding workflows to reality — delegate long-running tasks and move on
- The 10-minute setup (GitHub connection, API keys, sandbox backend) gets you started fast
- AGENTS.md is critical for consistent agent behavior — document your conventions explicitly
- Excels at multi-file refactors, test generation, and dependency updates (adds overhead for simple one-liners)
- Captures battle-tested patterns from Stripe, Ramp, and Coinbase in an open-source framework
Clone the repo, try the tutorial, and start with low-risk tasks like documentation updates. The coding agent landscape just shifted from synchronous IDE assistants to asynchronous cloud teammates.
