# What Programming Languages Are Used in Open-SWE? A Complete Technical Breakdown

> Discover the programming languages powering Open-SWE discover Python for agent logic and supporting infrastructure with Dockerfile, YAML, JSON, Makefile, and Markdown.

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

---

**Open-SWE is primarily a Python project, with all executable agent logic, utilities, and tests implemented in Python, while supporting infrastructure uses Dockerfile, YAML, JSON, Makefile, and Markdown.**

The `langchain-ai/open-swe` repository is an open-source software engineering agent framework designed to automate coding tasks. Understanding the programming languages used in Open-SWE is essential for contributors who want to extend its capabilities or integrate it into existing development workflows.

## Primary Programming Language: Python

**Python** is the sole programming language used for executable logic in Open-SWE. The codebase follows modern Python patterns, utilizing type hints and async/await syntax throughout the agent implementation, utility modules, and test suite.

### Core Agent Implementation

The entry point for the agent web service resides in [`agent/webapp.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/webapp.py), which creates a FastAPI application using the `create_app()` function. This module wires together middleware, tools, and routes to expose the agent capabilities as a web service.

```python

# File: agent/webapp.py

from fastapi import FastAPI
from agent.server import create_app

app: FastAPI = create_app()

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

```

### Utility Modules and Tool Integrations

Helper functions for external service integrations are organized under `agent/utils/`. For example, [`agent/utils/slack.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/utils/slack.py) provides the `post_message()` async function for Slack notifications, while [`agent/tools/github_comment.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/tools/github_comment.py) implements the `github_comment()` tool that agents invoke to respond to GitHub issues.

```python

# File: agent/utils/slack.py

from .auth import get_slack_token

async def post_message(channel: str, text: str) -> bool:
    token = await get_slack_token()
    # The actual HTTP call is performed by the Slack client library.

    return await slack_client.chat_postMessage(token=token, channel=channel, text=text)

```

```python

# File: agent/tools/github_comment.py

from ..utils.github import comment_on_issue

async def github_comment(issue_id: str, comment: str) -> None:
    await comment_on_issue(issue_id, comment)

```

### Testing Framework

The `tests/` directory contains a comprehensive pytest suite covering Slack integrations, GitHub tools, sandbox utilities, and multimodal processing. All test files use the `.py` extension and import from the main `agent` package, ensuring consistent Python usage across the entire test surface.

## Supporting Configuration and Infrastructure Languages

While Python handles all executable logic, Open-SWE employs several domain-specific languages and formats for deployment, automation, and configuration.

### Containerization with Dockerfile

The repository includes a `Dockerfile` that defines the container image for reproducible deployments and CI pipeline execution. This ensures consistent Python environment setup across development and production without requiring additional programming languages.

### CI/CD Automation with YAML

GitHub Actions workflows reside in `.github/workflows/` and use YAML syntax. The [`ci.yml`](https://github.com/langchain-ai/open-swe/blob/main/ci.yml) file orchestrates linting, testing, and type checking pipelines that validate Python code quality on every pull request.

### Build Automation with Makefile

A `Makefile` provides convenient shortcuts for common development tasks such as running tests, building Docker images, and executing linting commands without memorizing complex CLI arguments.

### Configuration Files: JSON

JSON files including [`langgraph.json`](https://github.com/langchain-ai/open-swe/blob/main/langgraph.json) and [`opencode.json`](https://github.com/langchain-ai/open-swe/blob/main/opencode.json) store structured configuration data consumed by the agent framework. These define graph structures and tool registries that the Python code loads at runtime.

### Documentation with Markdown

Human-readable documentation uses Markdown (`.md`) files including [`README.md`](https://github.com/langchain-ai/open-swe/blob/main/README.md), [`INSTALLATION.md`](https://github.com/langchain-ai/open-swe/blob/main/INSTALLATION.md), [`SECURITY.md`](https://github.com/langchain-ai/open-swe/blob/main/SECURITY.md), and [`CUSTOMIZATION.md`](https://github.com/langchain-ai/open-swe/blob/main/CUSTOMIZATION.md). While not executable code, these are essential for project onboarding and contributor guidelines.

## Key Source Files by Language

The following table maps critical file paths to their respective languages in the Open-SWE codebase:

| File Path | Language | Purpose |
|-----------|----------|---------|
| [`agent/webapp.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/webapp.py) | Python | FastAPI application entry point |
| [`agent/utils/slack.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/utils/slack.py) | Python | Slack integration utilities |
| [`agent/tools/github_comment.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/tools/github_comment.py) | Python | GitHub commenting tool implementation |
| [`agent/middleware/ensure_no_empty_msg.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/middleware/ensure_no_empty_msg.py) | Python | Message filtering middleware |
| `tests/*.py` | Python | pytest test suite |
| `Dockerfile` | Dockerfile | Container image definition |
| [`.github/workflows/ci.yml`](https://github.com/langchain-ai/open-swe/blob/main/.github/workflows/ci.yml) | YAML | Continuous integration pipeline |
| `Makefile` | Makefile | Build automation commands |
| [`langgraph.json`](https://github.com/langchain-ai/open-swe/blob/main/langgraph.json) | JSON | Agent graph configuration |
| [`README.md`](https://github.com/langchain-ai/open-swe/blob/main/README.md) | Markdown | Project documentation |

## Summary

- **Python** is the sole programming language used for executable logic in Open-SWE, powering the agent framework, utilities, tools, and tests.
- **Dockerfile**, **YAML**, **Makefile**, **JSON**, and **Markdown** provide supporting infrastructure for containerization, CI/CD, build automation, configuration, and documentation.
- Core implementation files include [`agent/webapp.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/webapp.py) for the web server, [`agent/utils/slack.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/utils/slack.py) for integrations, and [`agent/tools/github_comment.py`](https://github.com/langchain-ai/open-swe/blob/main/agent/tools/github_comment.py) for GitHub automation.
- All testing is implemented in Python using pytest within the `tests/` directory.

## Frequently Asked Questions

### Is Open-SWE written entirely in Python?

Yes, all executable logic in Open-SWE is implemented in Python. While the repository includes configuration files in YAML and JSON, build scripts using Makefile syntax, and documentation in Markdown, the core agent functionality, utilities, and tools are exclusively Python modules.

### What Python version does Open-SWE require?

The repository uses modern Python patterns including type hints and async/await syntax throughout the codebase. While the specific minimum version isn't explicitly stated in the source files, the use of contemporary Python features suggests compatibility with Python 3.9 or later, which is standard for FastAPI and modern async libraries.

### Does Open-SWE use any domain-specific languages for configuration?

Yes, Open-SWE employs JSON for agent graph configuration via [`langgraph.json`](https://github.com/langchain-ai/open-swe/blob/main/langgraph.json) and [`opencode.json`](https://github.com/langchain-ai/open-swe/blob/main/opencode.json), which define the structure and tool registries consumed by the Python runtime. Additionally, YAML is used for GitHub Actions CI/CD workflows, and Makefile syntax handles build automation commands.

### Are there any compiled languages or extensions in the repository?

No, the repository does not contain any compiled languages such as C, C++, Rust, or Go. Open-SWE is a pure Python project with no native extensions or compiled dependencies within the source tree itself, relying instead on containerization via Dockerfile for environment management.