Dev & Engineering coding-automationpull-request-creationcloud-sandboxessubagent-orchestrationslack-integrationlinear-integrationgithub-integrationlanggraph

Open SWE

Build an asynchronous internal coding agent that works through your organization’s existing collaboration channels.

FollowAgents review · FARS-2.1
Use with care
68/ 100 5-point scale 3.4 / 5
1 2 3 4 5 6
1Trust16 / 29 · 2.8/5

The evidence shows per-task cloud sandboxing, authorization or scope gates for admin, repository, thread, observability, and subagent capabilities, server-side handling of selected credentials, encryption-at-rest claims, and narrow CI permissions. Deductions apply because the agent receives full shell access and network egress inside the sandbox, explicitly uses no confirmation prompts, and can commit, push, and open PRs automatically. Data flows are described reasonably well but not exhaustively for every provider, GitHub credential path, or telemetry route. Locked installs, some exact versions, and commit-pinned Actions support dependency security, while numerous lower-bound ranges and explicit overrides of conflicting transitive constraints reduce assurance. Draft PRs and sandbox isolation offer limited recovery, but no explicit rollback protocol is documented. MIT ownership and upstream framework attribution are clear; publisher identity remains unknown in the stated registry, and comparative provenance relies mainly on project assertions.

2Reliability11 / 14 · 3.9/5

The README, configuration, CI, and tests covering authorization, tool assembly, middleware, and environment fallback are strongly self-consistent. Multiple sandbox providers, sandbox recreation, locked installation, and broad CI improve availability, but the product depends on several cloud services, model providers, GitHub, Slack, Linear, and fast-moving frameworks, with explicit dependency-constraint overrides. Error middleware, retry behavior, step-limit notification, and concrete tested error messages show ordinary failure handling; full marks are withheld because the supplied evidence does not establish consistently actionable errors across every external integration.

3Adaptability16 / 18 · 4.4/5

The project clearly targets internal organizational coding agents across Slack, Linear, GitHub, web, and an experimental desktop surface. It supports replacing models, sandboxes, tools, triggers, prompts, and middleware, providing thorough environment-fit evidence. Trigger syntax, deterministic thread routing, source-specific tool assembly, and admin gating are precise. Capability-boundary deductions reflect that broad code modification, push, and PR powers are bounded principally by sandboxing and prompts, while deterministic validation and review gates are left for adopters to add.

4Convention10 / 18 · 2.8/5

The README is sensibly organized around architecture, tools, invocation, validation, features, and onboarding, with links to installation and customization guides. Because those guide contents are absent from the supplied evidence, installation notes receive only partial credit. Naming is mostly stable, although the repository, Python package, and experimental desktop product use slightly different layers of naming. Examples and comparison tables are useful, but there is no actual FAQ. The source acknowledges experimental desktop status, prompt-driven validation, network egress, and prompt-injection residual risk, though it lacks a systematic limitations section. The complete MIT license justifies full credit. Version 0.1.0 and a SemVer desktop release workflow exist, but no changelog or repository-wide release policy is supplied. A copyright holder and security address are present, while no verified publisher identity, maintainer roster, support commitment, or explicit update-responsibility process is shown.

5Effectiveness9 / 13 · 3.5/5

The output path is operationally useful: the agent can commit changes, push a branch, create or update a draft PR, and report status and links in the originating channel. Full credit is withheld because quality validation is primarily prompt-driven and no mandatory review or deterministic acceptance gate is demonstrated. Persistent sandboxes, multi-channel context, parallel subagents, live message intake, and automated PR handling provide substantial marginal value over a basic conversational coding assistant. Cost-benefit evidence is thin: model usage, cloud sandbox expense, concurrency cost, observability cost, operating burden, budgets, and default resource controls are not quantified.

6Verifiability6 / 8 · 3.8/5

Many concrete claims are traceable across configuration, CI, and focused tests, including admin gates, read-only skill backends, source-dependent tools, failure middleware, and release verification; cross-source corroboration is therefore strong. Deductions apply because this is an unexecuted static review, and README claims about leading organizational patterns, peer-company practices, and fully contained blast radius are promotional or inferential statements without independent corroboration in the supplied files. Facts and comparisons are not always explicitly separated from inference.

Evidence confidence: Low Reviewed Aug 25, 2026 Reviewed revision daab5de0baf2
The upstream repository has new commits since this review. The score still applies to the reviewed revision shown and may not cover the latest changes.
Safety controls not found in source: confirmation before acting
Before you use it
  • The agent can execute arbitrary shell commands with network access inside its sandbox and uses no step-by-step confirmation. Restrict egress, repository scope, GitHub permissions, and exposed tools before deployment.
  • Automatic commit, push, and PR creation lacks an explicit rollback protocol. Enforce draft PRs, branch protection, required CI, and human merge approval.
  • Observability records, web content, issues, Slack messages, and repository instructions can all carry prompt injection. Use least-privileged read-only credentials and audit outbound requests despite the authorization gates.
  • Dependency resolution deliberately overrides constraints declared by langchain-e2b. Revalidate compatibility on upgrades and maintain vulnerability and supply-chain scanning.
  • This assessment is static and limited to the supplied files; no tests, dependency installation, external services, or security claims were independently verified.
See the full review method →

What does this agent do, and when should you use it?

Open SWE is an open-source framework for building internal asynchronous coding agents on LangGraph and Deep Agents. Tasks can start in Slack, Linear, or GitHub and execute inside isolated, persistent cloud Linux sandboxes. The agent consumes the full issue or conversation context plus a repository-level AGENTS.md, then edits the checkout using file tools, shell commands, network requests, and GitHub CLI. It is instructed to run tests, formatters, and linters before committing, pushing, and opening or updating a draft pull request, with results returned to the originating channel. The repository also includes a web dashboard and an experimental Electron desktop wrapper, while exposing customization points for models, sandboxes, tools, triggers, prompts, and middleware.

A bot mention in a Slack thread, an @openswe comment on a Linear issue, or a GitHub comment on an agent-created PR creates or resumes a deterministic thread. Open SWE assembles the Slack history or the Linear title, description, and comments, and injects a root AGENTS.md into the system prompt when one exists. It composes the runtime through create_deep_agent, combining the model, construct_system_prompt, tools, sandbox_backend, and middleware; each task runs in an isolated remote Linux environment supplied by Modal, Daytona, Runloop, E2B, LangSmith, or a custom provider. The agent uses Deep Agents operations including read_file, write_file, edit_file, delete, ls, glob, execute, and task, together with integrations such as fetch_url, http_request, linear_comment, linear_search_issues, and slack_thread_reply. Searches run through rg under execute, while GitHub work uses gh in the sandbox. The task operation can fan work out to child agents, and check_message_queue_before_model inserts new channel messages before the next model call. The final workflow covers validation, commit, push, draft PR creation or update, and a response containing status and PR links in the source channel.

  1. An engineering team wants developers to request code changes from an existing Slack thread and receive progress plus a draft PR in that thread.
  2. A Linear-based product organization wants an agent to implement an issue after reading its full description and comment history, then post the result back to the issue.
  3. A platform team managing several repositories wants each repository to supply coding conventions, test requirements, and architecture rules through AGENTS.md.
  4. A team with concurrent development requests wants each task isolated in its own cloud sandbox and independent subtasks distributed to child agents.
  5. A team reviewing an agent-created pull request wants to mention @openswe in GitHub comments so the agent addresses feedback on the same branch.
  6. An organization with strict permission boundaries wants broad shell and filesystem access confined to sandboxes that have no production access.

What are this agent's strengths and limitations?

Pros
  • Native Slack, Linear, and GitHub invocation keeps requests, progress, and pull-request links in the team’s existing work context.
  • Every task receives an isolated, persistent cloud sandbox; tasks run concurrently, and unreachable sandboxes can be recreated automatically.
  • The system composes LangGraph and Deep Agents instead of maintaining a framework fork, with documented extension points for models, sandboxes, tools, triggers, and middleware.
  • It covers the full path from context ingestion and repository edits through validation, commit, push, and draft pull-request creation.
  • Optional Datadog, LangSmith, and Corridor capabilities keep their credentials in the server process rather than exposing those keys to the sandbox.
Limitations
  • Adoption requires operating a backend, dashboard, GitHub App, channel integrations, and cloud sandboxes, making it heavier than a local-only coding tool.
  • Validation is prompt-driven; deterministic CI enforcement, visual verification, and review gates must be added by the adopting organization.
  • The sandbox needs network, shell, and repository filesystem access. Despite production isolation, network egress and prompt injection through web, log, or trace content remain documented residual risks.
  • Execution depends on Modal, Daytona, Runloop, E2B, LangSmith, or a custom sandbox adapter, so changing providers entails configuration or integration work.
  • The desktop application is experimental, and the project recommends the web interface.

How do you install or deploy this agent?

The only concrete installation command in the supplied material is for the macOS desktop beta: clone the repository and run make install-desktop from its root to install or update the application. The complete process is assigned to docs/INSTALLATION.md and covers local backend and dashboard development, GitHub App creation, LangSmith, Linear/Slack/GitHub triggers, and production deployment. The supplied material does not include the underlying commands, software versions, environment variables, or complete credential list, so a fully copyable backend deployment sequence cannot be stated from this source alone. A deployment at least needs GitHub authentication and a supported cloud sandbox selection; consult the installation document for the exact required values.

How do you use this agent?

After configuring the backend, dashboard, GitHub App, and desired channel integrations, mention the bot in any Slack thread; use repo:owner/name when the repository must be specified. Alternatively, comment @openswe on a Linear issue, where the agent acknowledges the request with 👀 and reads the complete issue context. On a pull request created by the agent, mention @openswe in a GitHub comment to request review fixes on the existing branch. Additional Slack messages or Linear comments can be sent while a task runs and will be picked up before the next model call. The web dashboard provides GitHub login, per-user model and profile settings, team defaults, enabled-repository and review-style management, user mappings, and an Agents chat interface.

How does this agent compare with similar options?

In the repository’s comparison, Open SWE uses a composed Deep Agents/LangGraph harness and pluggable sandboxes. Stripe Minions forks Goose and uses pre-warmed AWS EC2 development boxes; Ramp Inspect composes OpenCode and uses pre-warmed Modal containers; Coinbase Cloudbot is built in-house. Open SWE combines roughly 15 curated tools, AGENTS.md plus issue or thread context, subagents with middleware, and prompt-driven validation. The table contrasts that with Minions’ roughly 500 tools and three-layer validation, Inspect’s OpenCode SDK, child sessions, and visual DOM verification, and Cloudbot’s MCPs, custom Skills, three modes, and agent councils. These are project-authored architectural comparisons, not independent benchmark results.

FAQ

Does the agent receive production access?
The described default boundary is an isolated remote Linux sandbox. The repository is cloned into it and the agent has broad permissions inside, but no production access. A custom deployment must preserve that boundary itself.
Can we change the model or sandbox provider?
Yes. The framework explicitly supports replacing the model and includes Modal, Daytona, Runloop, E2B, and LangSmith sandbox options, with a path for custom providers.
What happens when a run or sandbox fails?
Unreachable sandboxes are recreated, and ToolErrorMiddleware handles tool errors. If the model-call limit is reached, notify_step_limit_reached posts a Slack notification. The source does not promise automatic completion after every failure.
Are Datadog, LangSmith, or Corridor required?
No. They are optional server-side capabilities. Datadog and read-only LangSmith access are restricted to authorized users, while a configured Corridor connection exposes only analyzePlan.
Does Open SWE automatically merge pull requests?
The documented workflow commits, pushes, and creates or updates a draft pull request. It does not claim automatic merging; additional review gates or deterministic CI must be added separately.

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents