Elite engineering orgs like Stripe, Ramp, and Coinbase are building their own internal coding agents — Slackbots, CLIs, and web apps that meet engineers where they already work. These agents are connected to internal systems with the right context, permissioning, and safety boundaries to operate with minimal human oversight.

Open SWE is the open-source version of this pattern. Built on LangGraph and Deep Agents, it gives you the same architecture those companies built internally: cloud sandboxes, Slack and Linear invocation, subagent orchestration, and automatic PR creation — ready to customize for your own codebase and workflows.

[!NOTE] 💬 Read the announcement blog post here

---

Architecture

Open SWE makes the same core architectural decisions as the best internal coding agents. Here's how it maps to the patterns described in this overview of Stripe's Minions, Ramp's Inspect, and Coinbase's Cloudbot:

1. Agent Harness — Composed on Deep Agents

Rather than forking an existing agent or building from scratch, Open SWE composes on the Deep Agents framework — similar to how Ramp built on top of OpenCode. This gives you an upgrade path (pull in upstream improvements) while letting you customize the orchestration, tools, and middleware for your org.

create_deep_agent(
    model="openai:gpt-5.6-sol",
    system_prompt=construct_system_prompt(...),
    tools=[http_request, fetch_url, linear_comment, slack_thread_reply],
    backend=sandbox_backend,
    middleware=[ToolErrorMiddleware(), check_message_queue_before_model, ...],
)

2. Sandbox — Isolated Cloud Environments

Every task runs in its own isolated cloud sandbox — a remote Linux environment with full shell access. The repo is cloned in, the agent gets full permissions, and the blast radius of any mistake is fully contained. No production access, no confirmation prompts.

Open SWE supports multiple sandbox providers out of the box — Modal, Daytona, Runloop, E2B, and LangSmith — and you can plug in your own. See the Customization Guide for details.

This follows the principle all three companies converge on: isolate first, then give full permissions inside the boundary.

• Each thread gets a persistent sandbox (reused across follow-up messages)
• Sandboxes auto-recreate if they become unreachable
• Multiple tasks run in parallel — each in its own sandbox, no queuing

3. Tools — Curated, Not Accumulated

Stripe's key insight: tool curation matters more than tool quantity. Open SWE follows this principle with a small, focused toolset:

Tool	Purpose
execute	Shell commands in the sandbox
fetch_url	Fetch web pages as markdown
http_request	API calls (GET, POST, etc.)
list_threads / get_thread	Discover and inspect readable Open SWE threads
manage_thread	Perform authorization-checked dashboard thread actions
linear_comment	Post updates to Linear tickets
linear_search_issues	Search Linear issues by free text
output_iframe	Render sandboxed HTML visualizations in the dashboard
slack_add_reaction	React to Slack messages
slack_thread_reply	Reply in Slack threads

GitHub operations are performed with gh inside the sandbox, backed by the LangSmith proxy. Plus the built-in Deep Agents tools: read_file, write_file, edit_file, delete, ls, glob, grep, execute, and task (subagent spawning). Thread discovery and management tools run only on the parent agent, derive the actor from trusted run configuration plus application-generated follow-up attribution, recheck allowed-organization membership, and preserve the dashboard's owner, participant, and admin authorization checks.

Optional observability tools (server-side): Admins can connect Datadog and LangSmith from team settings (Admin → Observability credentials). When connected, the agent gains Datadog tools (via Datadog's hosted MCP server, default toolsets=core) and read-only LangSmith tools (langsmith_get_trace, langsmith_list_runs). These run in the LangGraph server process using credentials encrypted at rest — the sandbox never holds Datadog or LangSmith keys. They are loaded only for runs triggered by an authorized user (admins plus any emails in OBSERVABILITY_AUTHORIZED_EMAILS; active members of ALLOWED_GITHUB_ORGS also receive LangSmith tools), so a prompt-injected run from an untrusted contributor cannot reach team observability data. Use scoped, read-oriented keys regardless: observability data (logs, traces) is attacker-influenced content that can carry prompt injection, and the agent has network egress — the same residual-risk class as web_search / fetch_url.

Optional Corridor guardrails (server-side MCP): Set CORRIDOR_API_TOKEN (or CORRIDOR_MCP_TOKEN / CORRIDOR_TOKEN) to load Corridor's hosted MCP server for each agent run. Open SWE exposes only Corridor's analyzePlan tool. CORRIDOR_MCP_URL defaults to https://app.corridor.dev/api/mcp; if set explicitly, Open SWE only accepts the same HTTPS host and /api/mcp path. Tokens are sent via Authorization: Bearer ... from the LangGraph server process and are never placed in the sandbox. A legacy ?token=... URL is accepted and normalized into the header form.

4. Context Engineering — AGENTS.md + Source Context

Open SWE gathers context from two sources:

• AGENTS.md — If the repo contains an AGENTS.md file at the root, it's read from the sandbox and injected into the system prompt. This is your repo-level equivalent of Stripe's rule files: encoding conventions, testing requirements, and architectural decisions that every agent run should follow.
• Source context — The full Linear issue (title, description, comments) or Slack thread history is assembled and passed to the agent, so it starts with rich context rather than discovering everything through tool calls.

5. Orchestration — Subagents + Middleware

Open SWE's orchestration has two layers:

Subagents: The Deep Agents framework natively supports spawning child agents via the task tool. The main agent can fan out independent subtasks to isolated subagents — each with its own middleware stack and file operations. This is similar to Ramp's child sessions for parallel work.

Middleware: Deterministic middleware hooks run around the agent loop:

• check_message_queue_before_model — Injects follow-up messages (Linear comments or Slack messages that arrive mid-run) before the next model call. You can message the agent while it's working and it'll pick up your input at its next step.
• notify_step_limit_reached — After-agent hook that posts a Slack reply when the agent hits the model-call limit, so users get a clear signal instead of silence.
• ToolErrorMiddleware — Catches and handles tool errors gracefully.

6. Invocation — Slack, Linear, and GitHub

All three companies in the article converge on Slack as the primary invocation surface. Open SWE does the same:

• Slack — Mention the bot in any thread. Supports repo:owner/name syntax to specify which repo to work on. The agent replies in-thread with status updates and PR links.
• Linear — Comment @openswe on any issue. The agent reads the full issue context, reacts with 👀 to acknowledge, and posts results back as comments.
• GitHub — Tag @openswe in PR comments on agent-created PRs to have it address review feedback and push fixes to the same branch.

Each invocation creates a deterministic thread ID, so follow-up messages on the same issue or thread route to the same running agent.

7. Validation — Prompt-Driven

The agent is instructed to run linters, formatters, and tests before committing, and is responsible end-to-end for committing, pushing, opening/updating the draft PR, and replying in the source channel. This is an area where you can extend Open SWE for your org: add deterministic CI checks, visual verification, or review gates as additional middleware. See the Customization Guide for how.

---

Comparison

Decision	Open SWE	Stripe (Minions)	Ramp (Inspect)	Coinbase (Cloudbot)
Harness	Composed (Deep Agents/LangGraph)	Forked (Goose)	Composed (OpenCode)	Built from scratch
Sandbox	Pluggable (Modal, Daytona, Runloop, etc.)	AWS EC2 devboxes (pre-warmed)	Modal containers (pre-warmed)	In-house
Tools	~15, curated	~500, curated per-agent	OpenCode SDK + extensions	MCPs + custom Skills
Context	AGENTS.md + issue/thread	Rule files + pre-hydration	OpenCode built-in	Linear-first + MCPs
Orchestration	Subagents + middleware	Blueprints (deterministic + agentic)	Sessions + child sessions	Three modes
Invocation	Slack, Linear, GitHub	Slack + embedded buttons	Slack + web + Chrome extension	Slack-native
Validation	Prompt-driven	3-layer (local + CI + 1 retry)	Visual DOM verification	Agent councils + auto-merge

---

Features

• Trigger from Linear, Slack, or GitHub — mention @openswe in a comment to kick off a task
• Instant acknowledgement — reacts with 👀 the moment it picks up your message
• Message it while it's running — send follow-up messages mid-task and it'll pick them up before its next step
• Run multiple tasks in parallel — each task runs in its own isolated cloud sandbox
• GitHub OAuth built-in — authenticates with your GitHub account automatically
• Opens PRs automatically — commits changes and opens a draft PR when done, linked back to your ticket
• Subagent support — the agent can spawn child agents for parallel subtasks
• Web dashboard — a companion app (in ui/) for GitHub login, per-user model/profile settings, team defaults, enabled-repo and review-style management, user mappings, and an Agents chat UI
• Desktop app (experimental) — an Electron wrapper (in desktop/) around the same dashboard; the web UI remains the recommended way to use Open SWE

---

Getting Started

• Installation Guide — local dev (backend + dashboard), GitHub App creation, LangSmith, Linear/Slack/GitHub triggers, and production deployment
• macOS Desktop beta — clone this repository and run make install-desktop from the root to install or update the app
• Customization Guide — swap the sandbox, model, tools, triggers, system prompt, and middleware for your org

License

MIT