Free AI coding assistant: what is actually free in 2026

Search this and you get lists that conflate three different things: tools that are free, tools with a free trial, and tools that are free because you are the product. This separates them, and covers the part the lists skip -- what "free" costs you, and how to make it hold up under real use.

The distinction that organises everything

An AI coding assistant is two products bolted together:

The agent -- the thing that reads your repo, plans, edits files, runs commands. This runs on your machine and is genuinely free in several good implementations.

The model -- the thing that answers. This costs money to serve, and nobody gives it away without a limit somewhere.

Almost every confusing "is it free?" question dissolves once you ask which half is being discussed. Cline is free; the model you point it at is not. Cursor bundles an amount of model usage into what you pay for the editor.

So the real question is never "which free tool" -- it is "which free agent, and where does its model come from".

Agents that are genuinely free

Free as in no cost, no trial, no card.

Cline. VS Code extension, open source. Full agent: reads the repo, runs commands, edits files. Bring your own model.

Kilo Code. Open source, in VS Code, JetBrains or a terminal. It sells model access at provider rates, and you can point it at your own backend instead.

Continue. Open source, VS Code and JetBrains, strong at inline completion. Bring your own model.

Aider. Terminal-first, git-native, commits as it works. Bring your own model.

OpenCode. Open-source terminal agent. Its makers also run a small, rotating set of free models, which is the closest this list gets to both halves being free.

None of these charge you anything. All of them need a backend.

Two names are missing on purpose. Gemini CLI used to be the one entry where both halves were free out of the box, but on June 18, 2026 Google stopped serving it to free personal accounts and pointed users to Antigravity CLI instead (what still works). And Roo Code, the Cline fork, was archived by its team in May 2026; installed copies still run, but nothing new ships.

Where free model access actually comes from

Five routes, in rough order of how much capacity they give you.

A subscription you already pay for. If you already pay for GitHub Copilot, Claude or ChatGPT, that plan includes model access you may not be using. Copilot's has changed shape, though: since June 1, 2026, chat and agent use draws on monthly AI Credits at each model's API rate ($10 of credits a month on Copilot Pro), while code completions stay free. Within what your plan includes, more use costs nothing extra; past it, you pay or stop.

Provider free tiers.

• Kiro: its free plan is 50 credits a month, covering Claude Sonnet 4.5 and open-weight models such as Qwen3 Coder Next and DeepSeek 3.2.
• Antigravity: Google's free Individual plan comes with weekly rate limits. kRouter lists Gemini 3.1 Pro, Gemini 3.5 Flash, Claude Sonnet 4.6, Claude Opus 4.6 and GPT-OSS 120B for it.
• The Gemini API: an AI Studio key still has a free tier on Gemini 2.5 Pro, Gemini 2.5 Flash and Gemini 3 Flash Preview. Your exact limits are shown in AI Studio.
• OpenRouter: its free models carry daily caps; the OpenRouter free tier post has the numbers.

These are real, and they are free.

Free channels that need no account. kRouter ships two providers with no sign-in at all. OpenCode Free (oc) passes requests to OpenCode's free models, a list that rotates and in which some models only answer from inside OpenCode itself (Big Pickle refused outside requests when this was updated). MiMo Code Free (mmf) serves a single model, mimo-auto. Both are limited to one request at a time per connection.

A local model. Ollama or LM Studio on your own hardware. No limits, no network, no bill -- and a real quality and speed ceiling.

A cheap metered API. Not free, but the numbers are not comparable to a subscription. DeepSeek's pricing page lists deepseek-flash at $0.15 per million input tokens off-peak and $0.30 at peak, with output at $0.60 and $1.20 (October 2026).

What "free" actually costs you

The part the listicles omit. All of these are real and none are dealbreakers if you plan for them.

Request caps, not token caps. Several free tiers count requests. An agent burns requests fast even on small edits, because a single "fix the failing tests" instruction can be dozens of calls.

Tighter rate limits. Free tiers are sized for interactive use. An agent sends far more requests per minute than a person chatting, so hitting a 429 within seconds of starting an autonomous run is expected rather than a fault.

Weekly and monthly windows. Antigravity's free plan resets weekly and Kiro's monthly, so a heavy few days can leave you dry for the rest of the period. When Kiro reports its monthly limit, kRouter locks that account for about 30 days instead of retrying it.

Your prompts. Free often means your data helps train something. Google's pricing page marks Gemini API free-tier content as used to improve its products, and several of OpenCode's free models collect data during their free period. Keep client code and secrets off them.

Your account. Copilot, Claude Code, Codex, Antigravity and Kiro logins are subscription or OAuth sessions that are not licensed for use through a proxy or router. kRouter shows a risk notice before you connect one, because the provider can restrict or ban the account.

Shifting availability. Which models a free channel exposes changes without notice, and whole free tiers end: Gemini CLI's did in June. A setup pinned to one model on one provider is fragile.

No SLA. For development work this is fine. For anything customer-facing it is not, and you should pay for the direct API.

Why one free tier is not enough

This is the thing that determines whether a free setup is usable or merely technically true.

A single free tier will run out mid-task. That is not a flaw in the tier, it is what a limit is. The experience of "free AI coding" being unusable comes almost entirely from people trying exactly one free tier, hitting its ceiling during real work, and concluding the category does not work.

Three tiers in sequence behave completely differently, because each has its own independent allowance. When one is exhausted the next takes over and your session continues. Add a cheap metered path at the end and there is no hard stop at all -- just a little overflow spend on the days you exceed everything else.

That is a stronger position than one paid subscription, because the failure mode is "slightly different backend" rather than "blocked until reset".

Putting it together

The obstacle is that each of these speaks its own protocol. Kiro talks to AWS's CodeWhisperer API. Copilot and Antigravity need their own OAuth token handling. Your editor cannot use those sign-ins directly, which is why the capacity goes unused.

A local router presents one standard endpoint and translates behind it:

npm install -g @sifxprime/krouter
krouter -t

Connect what you have on the dashboard's Providers page, then point the agent at it. The CLI Tools page writes the settings for Claude Code, Cline, Kilo Code and OpenCode, and shows the values to paste into Continue. Aider takes two environment variables:

export OPENAI_API_BASE=http://localhost:20128/v1
export OPENAI_API_KEY=<your-krouter-key>
aider --model openai/free-chain

For Claude Code by hand, add this env block to ~/.claude/settings.json:

{
  "env": {
    "ANTHROPIC_BASE_URL": "http://localhost:20128/v1",
    "ANTHROPIC_AUTH_TOKEN": "<your-krouter-key>"
  }
}

From the machine kRouter runs on, no key is needed unless you set REQUIRE_API_KEY=true; from another machine, create one on the Endpoint page.

Then build a combo, named free-chain here so the Aider line above uses it. A chain worth starting from:

1. kr/claude-sonnet-4.5     # Kiro free plan
2. ag/claude-sonnet-4-6     # Antigravity free plan
3. oc/space-bunny-free      # OpenCode Free, no account
4. mmf/mimo-auto            # MiMo Code Free, no account
5. ds/deepseek-v4-flash     # cheap metered, last resort

If you pay for Copilot, put a gh/ model first: its credits are already paid for. kRouter treats the order as a preference rather than a fixed sequence: entries whose provider reports remaining quota (Kiro and Antigravity both do) move ahead, the one with the most left first.

One caveat specific to Cursor: it routes through its own servers, so localhost is unreachable and it needs a tunnel or cloud endpoint (why, and the fix). The open-source agents above run entirely on your machine and have no such restriction -- which is itself a reason to prefer them for this.

Spending less by routing, not by downgrading

The largest saving is not choosing a worse model. It is not spending your best model on trivial work.

Many of the requests an agent makes are routine: naming things, summarising a file, writing a commit message, deciding which file to read next. That traffic is a large share of the volume and little of the value. Sending it to a free or cheap backend, and reserving the expensive path for work that genuinely needs it, stretches every allowance further without changing the quality of anything you would notice.

What to avoid

Sites offering "free API keys". They are either proxying your prompts through someone else's infrastructure or reselling stolen credentials. Your conversations are the product.

Bulk accounts on one provider. Providers detect it and the result is a verification gate or a ban across all of them. Stacking different providers works; stacking accounts on one does not.

Assuming free means unlimited. Every route has a ceiling. Knowing where it is beats discovering it mid-task.

Common questions

Is there a completely free AI coding assistant?

Not out of the box, since Google stopped serving Gemini CLI to free accounts in June 2026. OpenCode with its own free models comes closest, with the catch that those models rotate and many collect data. Otherwise the pattern is a free open-source agent plus free model backends, which takes about half an hour to set up and then costs nothing.

What is the best free alternative to Cursor or Copilot?

Cline or Continue for the agent, pointed at whichever free backend you can reach. The editor experience is less polished; the model is the same model.

Can I use AI coding assistants offline?

Yes, with a local model through Ollama or LM Studio and an agent that can reach localhost. Expect a real quality and speed drop against frontier models, and note that Cursor cannot do this because it routes through its own servers.

Why do free tiers rate limit me so quickly?

Because agents send many more requests per minute than the interactive use those tiers were sized for. It is expected behaviour rather than a misconfiguration, and it is the main reason a single free tier feels unusable.

Is free good enough for professional work?

For development, generally yes -- the models on free tiers are often the same models sold on paid ones. Watch the data terms, though: several free tiers may use what you send to improve their models. For anything customer-facing or under an SLA, pay for the direct API.

Do I need a credit card?

Not for the free routes described here. Kiro and Antigravity are sign-ins, a Gemini API key needs only a Google account, OpenCode Free and MiMo Code Free need nothing at all, and the agents are just software. Only the metered API at the end of the chain needs credit on the account.

Related

• Gemini CLI's free tier is gone: what still works
• Claude Code without a subscription: 6 backends
• Free Claude API access: what is real
• Cursor alternatives that are actually free
• Using your Copilot subscription as a model backend
• Free Antigravity coding setups
• Cheapest LLM APIs in 2026
• Ollama with automatic cloud fallback