mini-SWE-agent cost: the free agent and the real API bill

mini-SWE-agent costs $0. It is MIT-licensed software with no plan, no seat, no hosted tier and no account to buy, so "mini-SWE-agent cost" in practice means the model API bill of whatever endpoint you point it at. The number worth budgeting is tokens per run, and mini ships exactly one default guard on it: cost_limit: 3. in the configuration the mini command loads. That guard has a failure mode on a custom endpoint, covered below, and it is the single most expensive thing to get wrong here.

Three disambiguations first, because the search results mix them and each one puts wrong numbers on the page. SWE-agent, the original, is a different product with its own repository, its own documentation site and its own config schema; its README states that "Most of our current development effort is on mini-swe-agent, which has superseded SWE-agent" and recommends mini going forward, but it is not archived (20,382 stars, last push September 21, 2026), so treat it as maintained-but-superseded and never quote its defaults as mini's. "SWE-bench Verified Mini" is a dataset, not this agent, and has no price: its Hugging Face card describes it as a 50-instance subset of SWE-bench Verified chosen to cut storage and evaluation cost. And "mini" inside a model name is not this agent either: GPT 5 mini appears on mini's own leaderboard rows, and MiniMax is a vendor whose name simply starts the same way — so a sentence like "mini costs $0.047 per instance" is only true of one model run under mini-SWE-agent, and has to name both.

One thing to check for yourself if a third-party summary tells you otherwise: mini's licence is MIT. The GitHub licence API returns MIT, PyPI carries the License :: OSI Approved :: MIT License classifier, and the licence text bundled with the package reads "Copyright (c) 2025 Kilian A. Lieret and Carlos E. Jimenez".

What mini charges, and what actually bills you

The project is alive, which matters before you standardise on it: the repository is not archived and not disabled, 7,843 stars, created June 28, 2025, last push September 14, 2026, 70 open issues and pull requests together (the GitHub API's open_issues_count, September 21, 2026), and release v2.4.6 was published July 23, 2026.

mini's own spend controls, and the one that quietly stops working

mini is unusual among coding agents in shipping a dollar limit at all. There are four numbers, and they are not the same number.

Read from the files on the main branch on September 21, 2026. Two properties change how you should treat the $3. First, it is a stop rule, not a cap: default.py checks 0 < cost_limit <= self.cost before a call, and the field's own docstring says "Stop agent after exceeding (!) this cost" — so the run halts once accumulated spend has already passed the ceiling, not before. Second, in the interactive CLI hitting it does not end anything: interactive.py prints the limits and the current spend, then prompts for a new step limit and a new cost limit. Unattended runs raise LimitsExceeded instead.

Across runs there are two environment variables, and both ship off: MSWEA_GLOBAL_CALL_LIMIT and MSWEA_GLOBAL_COST_LIMIT are documented on the global configuration page as "(0 = no limit) (default: 0)". They bound one mini process, not an account. Two more settings quietly add tokens: retries default to 10 attempts (MSWEA_MODEL_RETRY_STOP_AFTER_ATTEMPT), and the agent aborts after 3 consecutive format errors. Whether a failed attempt is billed is your provider's decision, not mini's, and was not verified here.

Now the failure mode. mini's dollar figure is computed locally, by LiteLLM's price table — so a model id LiteLLM does not know makes the run raise on cost calculation, and the $3 ceiling has nothing to enforce. If you point the LiteLLM classes at a gateway, supply the rates yourself rather than reaching for MSWEA_COST_TRACKING="ignore_errors", which mini annotates "CAREFUL: This can lead to unmanaged spending!". The registry file is keyed on the model name without its provider prefix, in dollars per token, with litellm_provider matching your custom_llm_provider:

{
  "claude-sonnet-5": {
    "input_cost_per_token": 0.0000020000,
    "output_cost_per_token": 0.0000100000,
    "litellm_provider": "openai",
    "mode": "chat"
  }
}

mini's own bill lands in the trajectory file: its output-files page documents info.model_stats with instance_cost ("total cost of API calls for this run") and api_calls, plus a cost on each assistant message. That is arithmetic over a price file you typed, not your provider's ledger — the one exception is mini's OpenRouter class, which asks that API to include usage accounting and then reads the charged cost out of the response. The full endpoint configuration is in the mini-SWE-agent setup page.

Cost per SWE-bench issue: the only published per-run figures

swebench.com offers a "Bash Only" entry into its Verified leaderboard, described on the site as "The default Verified view: every model in the same mini-SWE-agent environment" over 500 instances. In the site's own leaderboard code it is a preset rather than a separate board — the Agent filter narrowed to mini-SWE-agent with nothing else selected — and the rows it leaves standing are submissions whose trajectories are filed under bash-only. Each row carries an average cost per instance and an average number of model calls per instance. The last column below is derived here, not published: cost per instance divided by the resolved fraction, which assumes one attempt with the cost of failures counted in.

Scope, and it is the whole story: these are bash-only submission records read September 21, 2026 — SWE-bench Verified, 500 instances, each row tagged one attempt and mini v2.0.0, dated February 17 to 26, 2026, with cost as reported with each submission. The site does not document whether that figure is list price, a negotiated rate or mini's own LiteLLM estimate, so do not read it as a quote; nor does it record which environment class or step limit each submitter ran with, so neither is claimed here. A benchmark instance is not a developer's task: these are curated GitHub issues with a known fix, scored headless against a test patch.

Two readings survive that caveat. First, the ordering flips between the two cost columns three times. Claude 4.5 Haiku (high) is cheaper per instance than Gemini 3 Flash (high) and dearer per solved issue; DeepSeek V3.2 (high) undercuts GPT 5.2 Codex per instance and loses to it per fix; GLM 5 (high) undercuts Claude 4.6 Opus per instance and loses per fix. The per-instance figure hides two things at once: how often a model lands the fix, and how many model calls it burns getting there — 88.5 and 76.2 in those last two rows, against 28.1 and 28.9 for the models that beat them. Only GPT 5 mini leads on both columns. Second, the rows stop: February 26, 2026 is the newest mini submission on any of swebench.com's boards, so no model from the 2026 mid-year generation has a per-instance cost published there. Do not interpolate one. mini's own headline claim is separately worded — its documentation index says it "Scores >74% on the SWE-bench verified benchmark", which is a statement about a model under mini on 500 curated issues.

A worked estimate on live catalog rates

This is illustrative token arithmetic, not a measured task cost and not a bill ceiling. mini "has a completely linear history — every step of the agent just appends to the messages", so the whole conversation is re-sent every step and input dominates. Assume one run of 40 model calls (inside the roughly 20-to-89 band the leaderboard rows show), a conversation that reaches 40,000 tokens by the last call so the average request carries about half that, giving 800,000 input tokens across the run, and 400 output tokens per call, 16,000 in total. Every token is priced as fresh input: no cache discount is assumed, because whether a chat-completions gateway acts on the cache_control markers mini attaches was not tested for this page. Rates are live Kunavo catalog prices per million tokens.

Read it as a ratio. Under these assumptions the spread between GPT-5.6 Luna and Claude Opus 5 is about 28×, which is a bigger lever than anything in mini's configuration — and every row fits inside the default $3 stop rule, so that ceiling is a runaway guard rather than a budget. One detail the price tables miss: the long-context tiers the catalog declares for the GPT shelf and for Gemini 3.1 Pro are per request, not per run, so what matters is how large a single mini prompt grows, not the run total. mini's shipped observation template helps here, capping each observation at 10,000 characters and sending the first 5,000 and last 5,000 plus an elided count above that.

One scope note while you budget a pipeline around mini: Kunavo serves no embedding model, no text-to-speech model and no speech-to-text model, so a script that indexes a repository or transcribes audio alongside your runs keeps its own provider key for that step. mini itself only ever asks a model to produce text with one bash tool attached — chat completions on its default litellm class, or the Responses API on its *_response classes.

Kunavo's catalog amount is a billing floor rather than a cap: when the upstream reports its charge, the bill is the greater of catalog cost and upstream cost times the applicable markup. Cache charges and external tools sit outside this example. The minimum top-up is $10 in prepaid credit — a funding minimum, not a task fee or a subscription. See billing details and how cached tokens are priced.

Best API for mini-SWE-agent: which route wins when

The choice is narrower than it looks, because mini's model classes are not equally open. It ships gateway classes for three companies — OpenRouter, Requesty and Portkey, each with protocol variants — and none of them exposes an api_base field. The OpenRouter and Requesty classes go further and hardcode that vendor's URL in the class itself, beside a fixed key variable (OPENROUTER_API_KEY, REQUESTY_API_KEY); the Portkey classes name no URL at all and hand the request to the portkey-ai client with a PORTKEY_API_KEY, so the destination is whatever that SDK resolves. Either way, picking one of them picks that company's terms too. The LiteLLM family is the one you repoint from a config file.

Two boundaries worth knowing before you plan around them. mini's documented examples use vendor-native LiteLLM ids with provider prefixes, and a gateway's own ids are different strings that will not resolve at a vendor endpoint — mini's shipped SWE-bench benchmark config, for instance, sets model_name: "anthropic/claude-sonnet-4-5-20250929", which is an Anthropic-native id — copy that file unchanged and you are pointing at Anthropic, so swap the id for whatever your own endpoint publishes. And mini has three protocol paths: the default litellm class calls chat completions with native tool calling, litellm_textbased reaches the same endpoint with the older text-parsed actions, and litellm_response calls the OpenAI Responses API with a different tool schema, which a chat-completions-only endpoint cannot serve. mini-SWE-agent vs Claude Code covers that configuration in full, and OpenAI-compatible API and LLM gateway cover the generic pattern.

Cheapest API for mini-SWE-agent: two different questions

The table above already separates them. Cheapest listed price ranks by dollars per million tokens; lowest cost to finish the task ranks by what it takes to land a working change. mini makes the gap wider than usual, for a structural reason: its linear history means an extra step does not add one message, it adds one more full re-send of everything before it. A model that needs 88 calls where another needs 29 pays that surcharge on every one of them — which is exactly what the derived column shows, with two rows at similar per-instance cost separated by their call counts. Pick the least expensive model that finishes your work with review effort you accept, run one bounded task, and read the charge your own account recorded for it rather than the client's readout. AI cost optimization covers that method, and cheapest Claude API if Claude is the family you have settled on.

Setting it up and checking the first bill

Kunavo publishes a configuration reference for mini-SWE-agent. That is a published setup page, not a compatibility test: mini has not been runtime-tested here against Kunavo's endpoint — no session, no streamed turn, no tool round-trip — and everything above was read from mini's own source and documentation. Specifically unverified: whether LiteLLM's openai/ path negotiates mini's v2 default of native tool calling against a chat-completions surface, and whether cache_control markers are acted on. Keep a working route available while you try it, write the registry file first so the cost limit is live, run one bounded task, then reconcile. Start at the mini-SWE-agent integration guide and create a Kunavo account when you are ready to fund a key.

Comparing clients rather than providers? Aider pricing and OpenCode pricing cover two more agents with the same split between a free harness and a metered model bill.

FAQ

Checked September 21, 2026 by fetching each source directly: mini-SWE-agent's PyPI metadata; its GitHub repository metadata and latest release; config/mini.yaml, config/default.yaml, config/benchmarks/swebench.yaml, agents/default.py, agents/interactive.py, models/__init__.py and models/openrouter_model.py on the main branch; its documentation index and its global-configuration, local-models, SWE-bench usage and output-files pages; swebench.com's homepage submission records, its Verified leaderboard and its leaderboard-filter source, plus the sb-cli get-quotas page and the Hugging Face card for SWE-bench Verified Mini; the SWE-agent repository metadata and README; and the OpenRouter FAQ plus the Requesty and Portkey pricing pages. Gateway fee figures are each scoped to the plan named beside them. Not checked here and therefore not claimed: any vendor list price, any discount against one, and anything about how a failed or retried call is billed. No mini run was executed against Kunavo and no benchmark result was reproduced; Kunavo token rates come from the live catalog, and every dollar example here is illustrative token arithmetic.