Best Free AI Coding Tools: Free Client, Paid Tokens

Every list of the best free ai coding tools puts three different deals under one heading: an open-source client, a freeware binary, and a vendor allowance. They fail in different ways and only one of them is free at the end of the month. We classified eleven tools by the licence their registries actually report, read the free allowances out of the projects' own repositories, and priced one real session this site already paid for. Eight are open source, two are source-available, one is freeware — and none of that changes a $1.96 bill. If you have not yet settled on which surface you work on, decide that first; this page is about what the price tag is attached to.

Key takeaways

• "Free" splits three ways: a free client with paid tokens, a source-available licence that reads as open and is not, and a vendor free tier metered in a different unit from every paid tier.
• Eight of eleven tools are OSI-licensed as of 2026-08-20; Crush is FSL-1.1-MIT, Copilot CLI carries a custom licence, and Claude Code publishes none.
• One 696,820-byte session cost $1.96 through the client that ran it and between $0.62 and $1.77 in input tokens across three vendor cards. A free client moves $0 of that.
• Only one of five open-source agents states a free model allowance in its README — Gemini CLI, at 60 requests a minute and 1,000 a day.
• The genuinely $0 route is local inference, and on a 15.9 GiB laptop four of seven coding models fit in usable RAM while none fit in VRAM.

The short answer

Use a free client with a key you already pay for, and treat "free tier" as a separate decision about a different unit. Cline, Continue, opencode and Aider all cost nothing to install and change nothing about the bill; the bill belongs to the model.

If your goal is zero spend rather than zero licence cost, there are exactly two routes: a vendor free tier capped in requests, or local weights capped by your hardware. Our free-tier survey covers what each vendor's plan caps, and the assistants pillar is where to start if you have not yet decided which surface you work on. This article is about what the word "free" is actually attached to in each case.

Three different deals, one word

scripts/check-free.mjs measures the first three columns against public data rather than against marketing pages:

npm run check:free

It classifies every tool's licence from the GitHub licence API and the package registry, reads each project's own README for a stated allowance, and prices one committed session fixture against the three published rate cards.

Which tools are actually open source

The classification is not a judgement call. GitHub's licence detector returns an SPDX identifier when it recognises the licence file and NOASSERTION when it does not, and for this shelf NOASSERTION means a source-available licence every time:

Eight open source, two source-available, one proprietary, read on 2026-08-20. The two in the middle are the ones worth knowing about, because they appear in "free and open source" roundups without qualification. FSL-1.1-MIT is the Functional Source License: the source is published and readable, competing use is restricted, and each release converts to MIT two years after it ships. That is a real deal and a reasonable one — it is simply not the deal MIT is, and the difference only matters on the day you need to fork.

Claude Code is the honest opposite: it publishes no open licence and does not claim to. A tool being proprietary is not a mark against it, and the open-source assistant survey covers when the licence genuinely decides the choice — vendor risk, air-gapped work, forking a dead project.

The free client does not move the bill

Here is the number that decides whether "free" means anything. One ordinary agentic read of this repository — a lockfile and two project documents, 696,820 bytes, 354,835 tokens — measured on 2026-08-18:

The CLI that actually ran it reported $1.9610, which is higher than every input-only figure above because a real session also pays cache-write premiums and output. Those figures are a floor and the script says so.

Swapping a paid client for a free one moves none of it. The licence is a property of the code on your machine; the bill is a property of the tokens crossing the wire, and the per-byte comparison shows that the vendor's tokeniser moves that bill by 20.6% before any rate is compared. A free client and an expensive key is a more expensive setup than a paid client and a cheap key, and roundups organised by licence never show that trade.

The free tier is capped in the wrong unit

Of five open-source agents whose repositories we read, exactly one states a free model allowance in its README. Gemini CLI, README.md line 19, on 2026-08-20:

Free tier: 60 requests/min and 1,000 requests/day with personal Google

That cap is in requests. Every paid card in this category is in tokens. The two units do not convert, and the consequence is concrete: the 354,835-token session priced above would consume one of a thousand daily requests. A cap on requests does not price the size of a request.

So a request-metered free tier rewards exactly the workflow people are told to avoid — a few large, context-heavy agent runs — and punishes the chat-shaped habit of many small questions. If you are working inside a free tier, batch the work into fewer, larger prompts. That is the opposite of the advice that applies when you pay per token, where the loop is where the tokens go.

The other four repositories state no allowance in the file we read, which is not the same as having none — vendors move these terms to a website, where they are harder to check and easier to change. The script records the absence as an absence rather than assuming a number.

The only $0 route has a hardware bill

Local weights are the one route where the token column is genuinely zero. The cost moves to the machine, and on ordinary hardware that cost is not small. From this site's local-model measurement on a Windows laptop with 15.9 GiB of RAM and an integrated GPU reporting 1.0 GiB of dedicated VRAM:

• Four of seven quantised coding models fit in the 11.88 GiB left after a 4 GiB safety refusal.
• Zero fit in VRAM. The smallest candidate weighs 1.04 GB against 1.00 GB of dedicated memory, so the GPU path was closed before the shortlist mattered.
• None of them ran. Three separate runtime attempts failed — an install error, a binary quarantined by Defender, and STATUS_DLL_NOT_FOUND.

The full local-model teardown ends with no throughput number on purpose, and that is the most useful thing it reports: the free route has a prerequisite most laptops do not meet, and the tools that make it easy do not make the hardware appear.

How to pick a free setup that stays free

• Decide which "free" you need first. Zero licence cost, zero spend, or zero vendor dependence are three different goals and they pull toward three different tools.
• Install the package, not the name. Free or paid, the friendly name is not the package: nine of ten obvious install commands fetch something other than the tool, and three of those fetch software that ships a colliding command.
• If you already pay for a model, take the free client. Cline, Continue, opencode and Aider are Apache-2.0 or MIT and cost nothing to try. The bill will not change, so the licence is a pure gain.
• If you need zero spend, use a request-metered tier and batch your work. One thousand requests a day is generous if each request carries a real session, and worthless if you spend it fifty tokens at a time.
• Check the SPDX field, not the README. A tool your registry reports as NOASSERTION is not one you can fork on the day it is archived — and two million installs of an archived extension say that day arrives.
• Treat local inference as a hardware project. Price the machine before the model. On a laptop with an integrated GPU, the honest answer to "which local model" is usually "none of them yet".

Common mistakes choosing free tools

• Reading "open source" from a README. Tempting because every project says it. The symptom is discovering a competing-use restriction on the day you want to build on the tool. The fix is one API call per repository, and it takes a second.
• Assuming a free client means a free setup. Tempting because installation is the visible step. The symptom is a $60 API bill in month one from a tool you chose for being free. The fix is to price one real session before committing.
• Spending a request-metered allowance on small prompts. Tempting because a cap of 1,000 sounds like a lot. The symptom is hitting a daily limit while having used a fraction of the tokens the same allowance could have carried.
• Believing an install count means a tool is alive. We checked, and the marketplace does not decay: an extension archived in May still carries nearly two million installs and a 4.72 rating, with the measured shelf showing several more like it.

What we are not claiming

No output quality is compared. This article classifies licences and prices tokens. Which free tool writes better code needs several installed tools and a grader, and only one of these is installed on the machine that produced these figures.

The allowance survey is one file per repository. We read each project's README.md on 2026-08-20 and quote the matched line with its line number. A tool with no match may still document a free tier elsewhere; the check records what the repository states, and fails if that line later changes.

The session prices are a floor. They price input tokens on published rates read 2026-08-19, with no cache modelling and no output. The CLI's own reported figure for the same session was $1.9610 — about 10% above the closest floor, which is the direction to expect.

Terms are not priced. Retention, training on your prompts, and support are real costs of a free tier and none of them is machine-readable from a repository, so nothing here scores them.

Conclusion

If you already pay for a model, take an Apache-2.0 or MIT client and stop thinking about it — the licence is free upside and the bill lives elsewhere. If you need actual zero spend, pick the request-metered tier and restructure your work into fewer, bigger sessions, because that is the unit the cap is written in. And run npm run check:free before trusting any of these classifications in six months: two of the eleven entries above are one licence-file edit away from being a different deal, and nothing in a store listing would tell you.

Frequently asked questions

Muhammad Kashif

Founder and editor of Devventa, covering AI coding assistants, Next.js and the modern AI development stack.