# Open SWE Roadmap: Future Direction of the Open‑Source Coding Agent Framework

> Discover the future direction of Open SWE, the open-source coding agent framework. Explore its modular architecture and customization guides within the langchain-ai/open-swe repository.

- Repository: [LangChain/open-swe](https://github.com/langchain-ai/open-swe)
- Tags: roadmap
- Published: 2026-03-19

---

**Open‑SWE does not publish a formal roadmap document; instead, its future direction is encoded in the modular architecture, TODO markers, and customization guides found throughout the `langchain-ai/open-swe` repository.**

The `langchain-ai/open-swe` repository powers internal coding agents at companies like Stripe, Ramp, and Coinbase. While you won't find a traditional "roadmap.md" file, understanding the **open swe roadmap** requires analyzing the codebase itself—specifically its pluggable sandbox system, middleware stack, and extensible tool architecture.

## Where the Open SWE Roadmap Is Documented

Because the project follows an **implicit roadmap** approach, you must examine specific files to understand planned evolution:

| File | What It Reveals About Future Direction |
|------|----------------------------------------|
| [`README.md`](https://github.com/langchain-ai/open-swe/blob/main/README.md) | The Architecture section emphasizes a **modular, pluggable design** (sandbox, tools, middleware, sub‑agents) intended to remain stable while allowing organizations to swap components. |
| [`CUSTOMIZATION.md`](https://github.com/langchain-ai/open-swe/blob/main/CUSTOMIZATION.md) | Contains a step‑by‑step recipe for adding new sandbox providers, signaling an upcoming expansion beyond current integrations. |
| [`agent/integrations/daytona.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/integrations/daytona.py) | Contains a `# TODO: Update this to include your specific sandbox configuration` comment, indicating expected community customization and upstream improvements. |

| [`agent/utils/sandbox.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/utils/sandbox.py) | Defines the `SANDBOX_FACTORIES` mapping, which is designed to trivially accept new providers as the ecosystem grows. |
| `agent/middleware/*.py` | Files like [`open_pr.py`](https://github.com/langchain-ai/open-swe/blob/main/open_pr.py) and [`ensure_no_empty_msg.py`](https://github.com/langchain-ai/open-swe/blob/main/ensure_no_empty_msg.py) demonstrate a middleware architecture built for **deterministic safety nets**, with new layers (CI checks, policy enforcement) as natural next steps. |
| `agent/tools/*.py` | The curated tool set (commit, fetch URL, HTTP, Linear, Slack) serves as a starting point for **organization‑specific extensions**. |
| `tests/` | The comprehensive test suite indicates maintainers aim to keep the codebase stable as new sandboxes, tools, and middleware are added. |

## Inferred Open SWE Roadmap Themes

Based on the codebase structure and TODO markers, the **open swe roadmap** centers on five major themes:

### Broader Sandbox Ecosystem

The `SANDBOX_FACTORIES` registry in [`agent/utils/sandbox.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/utils/sandbox.py) is explicitly designed for expansion. Future work will likely populate this registry with community‑contributed providers beyond the current set (LangSmith, Daytona, Runloop, Modal, local). The TODO comment in [`agent/integrations/daytona.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/integrations/daytona.py) suggests that sandbox configuration improvements are an active area for contribution.

### Extensible Tooling

The current tool set in `agent/tools/` is intentionally concise. The roadmap implies that developers will add organization‑specific tools (e.g., Datadog search, internal APIs) using the existing patterns. The framework's architecture treats tools as pluggable modules, making it trivial to extend the agent's capabilities without modifying core logic.

### Advanced Middleware

The middleware stack in `agent/middleware/` currently handles deterministic safety nets like preventing empty messages and opening PRs. The roadmap points toward adding optional layers for **CI checks**, **policy enforcement**, and **human‑in‑the‑loop gates**. These would run as deterministic steps before or after LLM calls, maintaining the architecture's safety guarantees.

### Improved Configuration and Observability

Future releases will likely expand environment‑variable driven configuration patterns and deepen integration with **LangSmith observability**. The codebase already uses structured logging and tracing hooks, suggesting that enhanced debugging and monitoring capabilities are on the horizon.

### Documentation and Samples

The presence of [`CUSTOMIZATION.md`](https://github.com/langchain-ai/open-swe/blob/main/CUSTOMIZATION.md) indicates that the roadmap includes enriching documentation with real‑world examples. A formal roadmap page listing upcoming milestones may be added in a future release, but for now, the customization guide serves as the primary reference for future capabilities.

## How to Contribute to the Open SWE Roadmap

Because the roadmap is driven by the modular architecture, you can contribute by extending any of the pluggable components. Below are practical examples based on the source code.

### Adding a New Sandbox Provider

To add a provider like "MyCloud," create an integration module and register it in the factory mapping:

```python

# agent/integrations/mycloud.py

import os
from deepagents.backends.protocol import SandboxBackendProtocol
from mycloud_sdk import MyCloudClient

def create_mycloud_sandbox(sandbox_id: str | None = None) -> SandboxBackendProtocol:
    """Create or reconnect to a MyCloud sandbox."""
    client = MyCloudClient(api_key=os.getenv("MYCLOUD_API_KEY"))
    if sandbox_id:
        return client.get_sandbox(sandbox_id)
    else:
        return client.create_sandbox(image="myorg/my-sandbox:latest")

```

```python

# agent/utils/sandbox.py

from .integrations.mycloud import create_mycloud_sandbox

SANDBOX_FACTORIES = {
    "langsmith": create_langsmith_sandbox,
    "daytona": create_daytona_sandbox,
    "runloop": create_runloop_sandbox,
    "modal": create_modal_sandbox,
    "local": create_local_sandbox,
    "mycloud": create_mycloud_sandbox,   # ← new entry

}

```

### Creating a Custom Tool

To add a Datadog log search tool, implement the function and include it in the server configuration:

```python

# agent/tools/datadog_search.py

import os
import requests
from typing import Any

def datadog_search(query: str, time_range: str = "1h") -> dict[str, Any]:
    """Search Datadog logs for debugging context."""
    headers = {"DD-API-KEY": os.getenv("DATADOG_API_KEY")}
    resp = requests.get(
        f"https://api.datadoghq.com/api/v2/logs/events/search?q={query}&time={time_range}",
        headers=headers,
    )
    resp.raise_for_status()
    return resp.json()

```

```python

# agent/server.py

from .tools import (
    commit_and_open_pr,
    fetch_url,
    github_comment,
    http_request,
    linear_comment,
    slack_thread_reply,
    datadog_search,          # ← new tool

)

# later, when constructing the agent

create_deep_agent(
    tools=[http_request, fetch_url, commit_and_open_pr,
           linear_comment, slack_thread_reply, datadog_search],
    # ...

)

```

### Building Middleware Layers

To add CI checks as a deterministic safety net, create a middleware class and register it:

```python

# agent/middleware/ci_check.py

import logging
from deepagents import Middleware

logger = logging.getLogger(__name__)

class CICheckMiddleware(Middleware):
    async def __call__(self, state, next):
        # Run CI in the sandbox before proceeding

        sandbox = state["sandbox"]
        result = await sandbox.execute("npm test")
        if result.exit_code != 0:
            logger.error("CI failed: %s", result.output)
            raise RuntimeError("CI checks failed")
        return await next(state)

```

```python

# agent/server.py

from .middleware import (
    ToolErrorMiddleware,
    check_message_queue_before_model,
    ensure_no_empty_msg,
    open_pr_if_needed,
    CICheckMiddleware,          # ← new middleware

)

create_deep_agent(
    middleware=[
        ToolErrorMiddleware(),
        check_message_queue_before_model,
        ensure_no_empty_msg,
        CICheckMiddleware(),   # runs CI before each LLM call

        open_pr_if_needed,
    ],
    # ...

)

```

## Summary

- **Open‑SWE has no formal roadmap document**, but its future is clearly encoded in the modular architecture of the `langchain-ai/open-swe` repository.
- **Sandbox expansion** is prioritized through the `SANDBOX_FACTORIES` registry in [`agent/utils/sandbox.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/utils/sandbox.py) and TODO markers in integration files.
- **Tool extensibility** is built into the core design, allowing organizations to add custom capabilities like Datadog search or internal API tools.
- **Middleware evolution** will likely add deterministic CI checks, policy enforcement, and human‑in‑the‑loop gates to the existing safety nets.
- **Community contribution** drives the roadmap through the pluggable architecture documented in [`CUSTOMIZATION.md`](https://github.com/langchain-ai/open-swe/blob/main/CUSTOMIZATION.md).

## Frequently Asked Questions

### Is there a formal Open SWE roadmap document?

No, the `langchain-ai/open-swe` repository does not contain a dedicated roadmap file. Instead, the **open swe roadmap** is implicit in the codebase architecture, TODO comments like the one in [`agent/integrations/daytona.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/integrations/daytona.py), and the customization guides that demonstrate how to extend sandboxes, tools, and middleware.

### How can I contribute to the Open SWE roadmap?

You can contribute by extending the pluggable components already defined in the source code. Add new sandbox providers to the `SANDBOX_FACTORIES` mapping in [`agent/utils/sandbox.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/utils/sandbox.py), create custom tools following the patterns in `agent/tools/`, or build deterministic middleware layers in `agent/middleware/`. The [`CUSTOMIZATION.md`](https://github.com/langchain-ai/open-swe/blob/main/CUSTOMIZATION.md) file provides step‑by‑step recipes for each extension point.

### What sandbox providers are planned for Open SWE?

While no official list exists, the architecture in [`agent/utils/sandbox.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/utils/sandbox.py) is designed to accommodate additional providers beyond the current set (LangSmith, Daytona, Runloop, Modal, and local). The presence of integration templates and the TODO marker in [`agent/integrations/daytona.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/integrations/daytona.py) suggest that community contributions for providers like AWS Cloud9, GCP Cloud Shell, or internal corporate sandboxes are expected to populate the `SANDBOX_FACTORIES` registry.

### How does Open SWE handle new tool integrations?

Open‑SWE treats tools as pluggable modules that can be added without modifying core logic. You create a Python module in `agent/tools/` defining the function, then import and register it in [`agent/server.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/server.py) within the `tools` list passed to `create_deep_agent()`. This design allows organizations to integrate internal APIs, monitoring tools like Datadog, or proprietary services while maintaining the framework's stability.