mini-swe-agent is an MIT-licensed, roughly 100-line Python AI agent from the Princeton and Stanford team behind SWE-bench and SWE-agent that solves GitHub issues and assists in the command line, built for developers, researchers and platform teams who want a capable coding agent without a large configuration surface or giant monorepo.

What it is

mini-swe-agent is a minimal software engineering agent written in Python and published under the MIT licence. It sits in the AI & Machine Learning category as an AI development platform, and its centre of gravity is a single agent class of about 100 lines, supported by small environment, model and run-script modules. The project is version two, so the v1 branch remains available and a migration guide exists for users moving forward. Documentation lives at mini-swe-agent.com, and the package is distributed on PyPI as mini-swe-agent.

The concrete problem it addresses is weight. The earlier SWE-agent generation placed heavy emphasis on special tools and bespoke interfaces; mini-swe-agent replaces that harness pattern with an agent that has no tools other than bash and does not even require the tool-calling interface of the language model. The result is an agent that can run against virtually any model, that needs nothing installed inside a sandbox beyond bash, and that keeps a completely linear history in which every step simply appends to the messages. That linearity means the trajectory and the message list passed to the model are the same object, which matters for debugging and fine-tuning, and execution through subprocess.run keeps each action independent rather than depending on a stateful shell session.

Key capabilities

• Minimal core: agent class in src/minisweagent/agents/default.py, with environment support in src/minisweagent/environments/local.py, model access in src/minisweagent/models/litellm_model.py, and a run script at src/minisweagent/run/hello_world.py.
• Benchmark performance: scores above 74% on the SWE-bench verified benchmark and starts much faster than Claude Code.
• Bash-only operation: no tools beyond bash, and no requirement for the model's tool-calling interface, so it runs with literally any model.
• Linear trajectory: every step appends to the messages, so the recorded trajectory equals the messages handed to the model.
• Independent actions: each action runs through subprocess.run with no persistent shell, which makes swapping in docker exec for sandboxing trivial and scaling straightforward.
• Deployment targets: local environments, docker/podman, singularity/apptainer, bubblewrap, and contree.
• Model access: litellm, openrouter and portkey integrations, support for /completion and /response endpoints, and interleaved thinking.

Who uses it and how

• Adopted by Meta, NVIDIA, Essential AI, IBM, Nebius, Anyscale, Princeton University and Stanford University, among others, which indicates both industrial and academic deployment.
• Powers Ramp SWE-Bench, so it serves as production infrastructure for an external benchmarking effort rather than only as a research artifact.
• Runs on ProgramBench, the project's own challenging benchmark, giving evaluation teams a target for agent testing.
• Used as an evaluation harness: it beats Claude Code and Codex on DeepSWE, making it a reference point in head-to-head agent comparisons.
• Suits command-line work and batch sandbox execution, where independent, stateless actions and fast startup matter more than rich interactive tooling.

Getting started

Install the mini-swe-agent package from PyPI and follow the documentation at mini-swe-agent.com/latest, using the run script src/minisweagent/run/hello_world.py as the entry point. Users upgrading from the previous release should read the v2 migration guide first.

How it compares

Among the similar tools named in the facts, mini-swe-agent positions itself directly against Claude Code and Codex: it starts much faster than Claude Code and, per DataCurve's evaluation harness, beats both Claude Code and Codex on DeepSWE. It also differs in kind from its own predecessor, SWE-agent, by discarding the tool-and-interface-heavy design in favour of bash plus a linear message history.

When to use it — and when not to

A self-hoster must supply model access through litellm, openrouter or portkey, and must provide a sandbox runtime such as docker/podman, singularity/apptainer, bubblewrap or contree if isolation is required. Teams that depend on persistent shell sessions, rich tool interfaces, or workflows carrying state across commands should look elsewhere, because every action here is independent by design. Users on the previous release must also account for the v2 migration before adopting the current code.

agent = DefaultAgent(
    LitellmModel(model_name=...),
    LocalEnvironment(),
)
agent.run("Write a sudoku game")

pip install uv && uvx mini-swe-agent
# or
pip install pipx && pipx ensurepath && pipx run mini-swe-agent

pip install mini-swe-agent
mini  # run the CLI

git clone https://github.com/SWE-agent/mini-swe-agent.git
cd mini-swe-agent && pip install -e .
mini  # run the CLI