Dev & Engineering autonomous-codingaws-bedrockgithub-actionsslack-integrationmcp-clientpull-request-automationsession-monitoringcost-analytics

Remote SWE Agents

Run asynchronous software-development tasks in isolated AWS environments.

FollowAgents review · FARS-2.1
Use with care
66/ 100 5-point scale 3.3 / 5
1 2 3 4 5 6
Per-dimension scores and reasoning
1Trust17 / 29 · 2.9/5

The documentation describes dedicated-VM isolation, minimally scoped default worker IAM permissions, granular GitHub App permissions, Slack user restrictions, optional VPC egress filtering, and the flow of Slack and GitHub credentials, API keys, and message history. Secrets are placed in SSM, but the examples use String rather than SecureString, and agents still receive configured tokens; the suggested PAT scopes of repo, workflow, and read:org are broad. The agent can autonomously clone repositories, commit code, create pull requests, and gain more external capabilities through MCP. These effects are disclosed, but no per-task confirmation, write approval gate, or enforced egress policy is shown. Production deployment disables CDK approval, although that workflow is manually triggered. CDK destroy and a deletion-failure recovery note provide infrastructure rollback, but code-change reversal, session recovery, and backups are not documented. CI uses npm ci and major-version-pinned actions, but no dependency audit, vulnerability scanning, update policy, or stronger supply-chain controls are shown. Example PRs and architectural components have attribution, and copyright and licensing are explicit; publisher identity remains treated as unknown.

2Reliability8 / 14 · 2.9/5

The README's architecture and deployment requirements generally align with the monorepo scripts and CI workflows. CI performs component builds, formatting checks, unit tests, CDK snapshots, and a Docker boot check, while the supplied code includes a focused regression suite. Points are deducted because the evidence covers only selected components and behaviors and cannot establish consistency for every product claim. Dependencies are installed reproducibly with npm ci, and Node.js, npm, AWS CLI, and Docker prerequisites are explicit, but operation depends on cloud services, regions, models, and optional MCP services without documented fallback behavior. Failure guidance is limited to scattered deployment timing, cleanup-race, and configuration notes; no consistent, actionable runtime error model is demonstrated.

3Adaptability14 / 18 · 3.9/5

Audience and scenario coverage is thorough: personal and team deployments, web, Slack, REST API, GitHub Actions, multiple repositories, images, multiple languages, and MCP are addressed. Configuration supports an existing VPC, cross-region inference, additional IAM policies, two GitHub authentication approaches, and optional integrations. Boundaries are partly explicit, including single tenancy, equal privileges for Cognito users, API-key access, the single-organization GitHub App restriction, and reduced functionality before GitHub setup. However, the autonomous agent's tool boundaries and those introduced by MCP are not comprehensively enumerated. Entry points and prompting guidance are clear, but there is no complete specification for ambiguity handling, permission-aware routing, or accidental-trigger prevention. Environment fit is strong for AWS with Node 22 and Docker but lacks a compatibility matrix or alternatives for other clouds and local-only deployment.

4Convention12 / 18 · 3.3/5

The README is well organized around installation, optional integrations, access control, architecture, security, cost, and cleanup, and its deployment procedure is concrete; this justifies full scores for information architecture and installation notes. Environment-variable, SSM-path, and workspace naming is mostly consistent, though TARGET_ENV handling and instructions to edit source configuration reduce stability. Screenshots, real PR examples, usage tips, and workflow references are useful, but there is no dedicated FAQ or complete API example. Several limitations are candidly documented, including single tenancy, a single GitHub organization, shared-Slack risks, equal web-user privileges, and delayed cleanup, but there is no centralized limitations inventory. MIT-0 metadata, the README, and the full license text agree, justifying full license marks. No release/version policy or changelog is supplied. Maintenance responsibility is only partly inferable from copyright, the security-reporting reference, and repository context; named maintainers, support lifecycle, and update commitments are absent, and registry-verified publisher identity is unavailable.

5Effectiveness10 / 13 · 3.8/5

The product produces monitorable sessions, progress updates, commits and pull requests, image interactions, API access, and cost analytics, with public PR examples showing the intended result format. It does not document output acceptance thresholds, mandatory human review, or merge protections, so output usability is not fully established. A dedicated asynchronous cloud development environment, multiple interfaces, per-task isolation, and MCP extensibility provide substantial marginal value over manual remote operation. The cost table gives service-level assumptions for 100 sessions and an approximately USD 115 monthly estimate, plus idle-cost and scaling guidance. Cost-benefit is deducted because the assumptions are region- and price-sensitive and omit deployment labor, operations, security controls, and failed-session costs.

6Verifiability5 / 8 · 3.1/5

Core claims can be traced to the README's architecture, configuration, cost table, example pull requests, and the supplied CI, test, and license files. Some promotional claims, including full autonomy, reliability, and minimal maintenance cost, lack claim-by-claim implementation evidence. Node requirements, workspace structure, builds, tests, CDK use, and some permission statements are cross-corroborated by package.json, workflows, and tests, but the supplied implementation excerpts do not corroborate every security default, data path, or feature. The documentation sometimes distinguishes facts, recommendations, conditions, and limitations, notably through recommended-language and explicit cost assumptions. It does not systematically separate measured outcomes and source-backed facts from inference or unverified capability claims.

Evidence confidence: Low Reviewed Sep 11, 2026 Reviewed revision 73609e95dcf3
Before you use it
  • The agent can autonomously modify code, push commits, and create pull requests; configure branch protection, a dedicated identity, and human merge review before granting write access.
  • The SSM examples store GitHub and Slack secrets as String parameters; evaluate SecureString, rotation, log redaction, and minimally scoped tokens.
  • Without SLACK_ADMIN_USER_ID_LIST in a shared Slack workspace, any member may invoke the agent and potentially access GitHub content.
  • REST API access is bearer-key based, and Cognito users currently have equal privileges; this deployment should not be treated as a multi-tenant isolation boundary.
  • Agents and MCP tools may make unintended outbound connections; egress filtering is recommended but not demonstrated as an enforced default.
  • Additional managed policies can substantially expand worker privileges, while the production workflow disables CDK approval; independently review synthesized templates and permission diffs before deployment.
  • The cost figures are examples under specific region and usage assumptions, not spending limits.
Review evidence [1][2][3][4][5][6][7][8]
See the full review method →

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

Remote SWE Agents is a self-hosted, fully open-source implementation of an autonomous software-development agent on AWS. Users create and monitor development sessions through a Next.js web application, Slack, a REST API, or GitHub Actions. Lambda, API Gateway, AppSync Events, and DynamoDB handle messages and state, while each worker unit receives a dedicated EC2 instance and EBS volume. The agent works on code in that isolated environment, can interact with GitHub to produce commits and pull requests, supports image input and output, and can call configured MCP servers. Amazon Bedrock supplies the foundation models, and the deployment is a pay-as-you-go, single-tenant system whose GitHub and Slack integrations require separate setup.

A task enters through the web interface, Slack, the REST API, or GitHub Actions. For Slack traffic, API Gateway forwards the webhook to a Slack Bolt Lambda function, which publishes messages to AppSync Events; DynamoDB retains message history and job status. When a new thread or session is created, Worker Manager provisions a Worker Unit containing an EC2 instance, an EBS volume, and the SWE agent, which subscribes to events and performs development work in its dedicated filesystem. Progress and results travel back through the event flow and appear as thread replies in Slack. With a GitHub PAT or GitHub App configured, the agent can clone authorized repositories, act on issue-driven requests, push autonomously written commits, and create pull requests; the supplied GitHub Action can also start sessions from issue comments, assignments, and PR reviews. MCP servers are configured in packages/worker/mcp.json, while the web application provides session management, real-time monitoring, image uploads, settings, and cost analytics.

  1. An individual developer who wants long-running coding work off their laptop can launch an isolated AWS session and monitor it from the web interface.
  2. A GitHub team can trigger work from issues, comments, assignments, or pull-request reviews and have the agent produce commits and pull requests.
  3. An engineering group that coordinates in Slack can assign tasks in threads and receive progress updates, with access restricted to approved Slack users.
  4. A platform team can integrate session creation and management into internal tools or CI/CD workflows through the deployed REST API and API keys.
  5. An AWS team that needs additional engineering integrations can configure MCP servers in packages/worker/mcp.json for new agents to use.
  6. An open-source maintainer working with forked repositories can give the agent repository and task details for changes spanning one or multiple repositories.

What are this agent's strengths and limitations?

Pros
  • Each Worker Unit has its own EC2 instance and EBS volume, isolating its filesystem from the user's machine and other workers.
  • One deployment exposes web, Slack, REST API, and GitHub Actions entry points, with real-time session monitoring and cost analytics.
  • GitHub integration supports both personal tokens and a more granular GitHub App that is not tied to an individual's account.
  • MCP integrations can be added through packages/worker/mcp.json and made available to newly created agents.
  • The infrastructure is usage-based, with ongoing cost documented as approximately zero when no sessions are active.
Limitations
  • The core deployment is tied to AWS services and Amazon Bedrock and requires familiarity with IAM, CDK, Docker, and several managed services.
  • The system is explicitly single-tenant; all Cognito users in one deployment currently have equal authority to configure it, create sessions, issue API keys, and view costs.
  • The GitHub App option currently supports repositories from only one organization.
  • Agents receive configured GitHub and Slack credentials and may make unintended outbound requests, so least-privilege credentials and VPC egress controls require careful administration.
  • The sample estimate is about $115 per month for 100 sessions under its stated Sonnet 3.7 token assumptions, with model usage accounting for most of the cost.
  • GitHub and Slack integrations each require external credential creation, SSM parameters, CDK configuration changes, and redeployment.

How do you install or deploy this agent?

Prerequisites are Node.js 22 or later, npm 9 or later, AWS CLI, an AWS IAM profile with appropriate permissions, and Docker. Run:

git clone https://github.com/aws-samples/remote-swe-agents.git
cd remote-swe-agents
cd cdk
cp .env.local.example .env.local
npm ci
npx cdk bootstrap
npx cdk deploy --all

Set [email protected] in cdk/.env.local if you want deployment to create an initial Cognito user and email a temporary password; otherwise, create users manually in the Cognito console. Deployment normally takes about 10 minutes. Open the WebappUrl shown in the CDK outputs after completion. GitHub access is not enabled by the base deployment: configure either a PAT or GitHub App and then run cd cdk && npx cdk deploy --all again.

How do you use this agent?

For the first working session, open the WebappUrl from the CDK output, sign in as a Cognito user, create a session, and provide at least the target GitHub repository, the feature or bug to address, and the first file path or keyword to inspect. A GitHub issue URL containing those details can be supplied instead, allowing the repository to be inferred and a resulting PR to be linked to the issue. GitHub operations require either a PAT with repo, workflow, and read:org scopes stored at /remote-swe/$TARGET_ENV/github/personal-access-token, or a GitHub App with read/write access to Actions, Issues, Pull requests, and Contents. Slack use requires an app, its bot token and signing secret in SSM, Slack properties in the CDK configuration, and redeployment; shared workspaces should set SLACK_ADMIN_USER_ID_LIST. REST API clients need an API key generated from the deployed web interface. GitHub Actions workflows must store the deployed API base URL and key as repository secrets.

How does this agent compare with similar options?

The project positions itself as a self-hosted AWS alternative offering an experience similar to cloud asynchronous coding agents such as Devin, OpenAI Codex, and Google Jules. Its stated distinction is that adopters operate the infrastructure, worker environments, and access controls in their own AWS deployment. The supplied material does not provide direct benchmarks for capability coverage, quality, speed, or cost against those services.

FAQ

What does it cost while idle and under use?
The documented ongoing cost is approximately $0 when no messages or sessions are running. The example for us-east-1 estimates about $115 per month for 100 sessions, assuming one hour of t3.large usage per session and the listed Bedrock token volumes; actual cost varies with session and model usage.
Can an agent access GitHub immediately after the base deployment?
No. The web interface and API can run first, but cloning repositories, pushing commits, and creating pull requests require a configured GitHub PAT or GitHub App followed by redeployment.
Can several isolated organizations safely share one deployment?
The documented design is single-tenant and recommends one deployment per tenant. Cognito users within a deployment currently have equal permissions, so it is not presented as a multi-tenant service.
Which permissions create the main security exposure?
Default worker IAM policies are limited to functions such as logging, self-termination, and S3 read access, but the agent can receive GitHub and Slack credentials. Additional IAM policies, GitHub scopes, Slack scopes, and outbound network access should all be restricted to what is necessary.
Is there a caveat when removing the deployment?
Resources can be removed with npx cdk destroy --force. Because cdk deploy starts an EC2 Image Builder pipeline asynchronously, the instructions say to wait at least 30 minutes after deployment before destroying the stack and to retry after another roughly 30 minutes if deletion fails.

Compare agents like this one

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

Related agents