How it works
The four levels, the condition that moves you from one to the next, how a verdict is reached and how footprint is estimated.
Why a scale
Every task admits several solutions, and they do not weigh the same. Masking a phone number in a message can be done with three regular expressions, or with a general-purpose model call on every inbound message. Both work. One costs nothing and is done before the next line of code runs; the other costs on every call, takes about a second, and sends the message to a third party.
The reflex, today, is to take the most powerful one. It will surely work, it asks for less thinking up front, and it is what everyone shows. The price turns up later — on the invoice, in an audit, or the day the provider deprecates the model.
The scale exists to make that choice visible instead of flattening it. It is fixed and identical on every entry, and it does not measure how good a solution is: it measures its weight, that is, what you have to start up, keep running, watch and pay for to get the result.
The four levels
Every entry presents these four levels, always in the same order, from lightest to heaviest. Between two levels, the condition that moves you from one to the next: not “when it is better”, but what makes the level below insufficient.
N0
Rule and classic algorithm
A regular expression, a query, a state machine, a sort. The code does exactly what it says, every time, and you can read all of it.
- What it costs
- Nothing. The marginal cost is zero, for good, and it depends on no price list.
- What it guarantees
- The same result every time, a test that proves it, and nothing leaving your side.
- What makes it give way
- An input the rule did not foresee: a spelling, a format, an intent. The rule does not get it wrong, it walks past it.
An entry that recommends itAutocomplete a search barNo AI needed
From N0 to N1
When the list of exceptions stops closing. As long as you can write the missed cases one by one, the rule wins: it is readable, free and testable. As soon as the list grows with every new case, you have to learn instead of enumerate — and that means labelled examples, which N0 never asked for.
N1
Lightweight classic model
A logistic regression, a TF-IDF, a gradient boosting, nearest neighbours. A model trained on your examples, small enough to be versioned next to the code that uses it.
- What it costs
- The time to label examples, then almost nothing: training fits on a laptop and prediction on an ordinary processor.
- What it guarantees
- A reproducible result, measurable on a sample, and data that stays with you.
- What makes it give way
- A case whose distinguishing feature is not in its words. The model counts shapes; it does not know that two sentences with no word in common ask for the same thing.
An entry that recommends itSpot spam in a contact formNo generative AI needed
From N1 to N2
When what tells cases apart is no longer in the words but in the meaning. A light model counts words and characters; it does not bring “cancel my subscription” and “I would like to stop” together. The price of the jump is a machine to keep running, and it only pays off if your cases resemble each other without repeating.
N2
Small self-hosted specialised model
A distilled encoder, an embedding model, an optical recognition engine. It weighs hundreds of megabytes, it runs on your machines, and it does one thing.
- What it costs
- A machine to keep running, memory, and someone who knows how to restart it. No subscription.
- What it guarantees
- Data that never leaves your infrastructure, and a model that will not be deprecated under your feet.
- What makes it give way
- A task that asks you to produce rather than recognise, or an instruction that changes every month.
An entry that recommends itFind the people and organisations named in an articleAI, but a small model on your own machines
From N2 to N3
When the task asks you to produce, not to recognise. A small specialised model classifies, extracts, transcribes. Writing a sentence nobody has written, following an instruction phrased in language, handling a case never seen: that is where the generalist wins, and the price is double — your data leaves, and two runs no longer match.
N3
General-purpose LLM API
A call to an outside provider. The model does everything roughly and nothing exactly, and it is not yours.
- What it costs
- A recurring cost that grows with use, and changes when the provider decides it does.
- What it guarantees
- A roughly right answer on almost anything, with nothing to install or train.
- What makes it give way
- Nothing makes it give way as a last resort — and that is the problem: you cannot tell when it is wrong, because it always answers.
An entry that recommends itSummarise a long documentYes, a general-purpose model earns its place
Not every level is present on every entry. A missing level is marked missing, with a short and real reason. It is never left blank: a blank cell reads as an oversight, not a decision.
The heaviest level is not the wrong choice. It is the wrong default.
The method, for those who dig
What follows explains how verdicts are reached, how the figures are expressed, and what this site refuses to do. None of it is needed to read an entry.
How a verdict is reached
The verdict is the lightest level that does the job properly, for the most common shape of the need.
Three questions, in this order:
- Does this level actually do the job? Not “roughly”, not “in most cases if you do not look too closely”. Each level’s breaking point is written on the entry, and it is demonstrated by a test that fails on purpose.
- Does the next level give you something this one cannot? If not, the next level is weight added for nothing.
- Is what it costs in return acceptable? Data leaving, determinism lost, a provider to depend on, a regulatory scope you did not choose.
The “recommended” badge can sit on any level, N3 included. Some entries recommend a general-purpose model without hedging, because that is the right answer. Those are the ones that make the entries recommending the opposite worth believing.
Where a verdict depends on a condition, the entry says so in its reasoning. A verdict is not a universal prescription, it is an argued starting point.
How the code is verified
No entry is published unless its code has been run. It is the most important rule in the project.
Every snippet lives in a real file in the repository, with a test beside it. The entry imports the file, it does not contain code retyped by hand. If a test fails, the site does not build.
Two levels of proof are possible, and each snippet declares its own, in the bar of the code block:
Tested as shown. The snippet runs with its real dependencies, and its test runs on every build of the site. This is the case for every N0 and N1 level.
Tested, service simulated. The snippet runs, but its test replaces the external service with a local double. This is the case for N2 and N3: downloading a model of several hundred megabytes on every build, or calling a paid API, is not sustainable. What the test then verifies: the request built, the response decoded, the error paths. What it does not verify: how good the model’s answer is. That is stated on the page, next to every snippet concerned.
We prefer partial proof shown as partial to complete proof claimed without being it.
Why there are no prices
Provider pricing changes every quarter, and not always in the direction you would guess. An absolute figure written today would be wrong in six months, and a wrong entry casts doubt on all the others.
Costs are therefore given as orders of magnitude, with a fixed vocabulary:
| Term | What it means |
|---|---|
| none | no marginal cost |
| negligible | under one euro per million operations |
| low | on the order of one euro per million operations |
| moderate | on the order of ten euros per million operations |
| high | on the order of a hundred euros per million operations, or more |
Latency follows the same principle, in five classes: <1 ms, ~10 ms, ~100 ms, ~1 s,
>1 s.
What the stated latency measures, said once and for all: the time of one decision on one input, on an ordinary machine. Not training, which happens once. Not the first load of a model into memory. When training or loading weighs on the decision to adopt a level — and on N1 and N2 it often does — the entry says so in its text, not in its latency class.
This vocabulary is deliberately coarse. It is enough to decide with, and it does not go stale.
How footprint is estimated
These are estimates, and an exact measurement is impossible from the client side of an API.
When you call a model at a provider, you know neither the hardware used, nor how full the server was, nor what share of training to amortise onto your request, nor the electricity mix of that data centre at that moment. The provider knows all of it, and does not publish it. Anyone quoting you grams of CO₂ per API call is giving you the output of an estimation model, not a measurement.
Overkill therefore publishes no footprint figure. Entries use relative orders of magnitude: negligible, low, moderate, high. They compare levels against each other on the same task, which is the only comparison we can make honestly.
Those orders of magnitude rest on the following published work, cited by name:
- Green Algorithms, Lannelongue, Grealey and Inouye, Advanced Science, 2021 — a methodology and a calculator for estimating the footprint of a computation from hardware, runtime and location. green-algorithms.org
- Estimating the Carbon Footprint of BLOOM, a 176B Parameter Language Model, Luccioni, Viguier and Ligozat, 2022 — one of the few published studies that separates training, hardware manufacturing and inference for a large language model. arxiv.org/abs/2211.02001
- Software Carbon Intensity, Green Software Foundation — a specification for computing the carbon intensity of a piece of software, now ISO/IEC 21031. sci.greensoftware.foundation
- AFNOR SPEC 2314, Référentiel général pour l’IA frugale, 2024 — a French framework for assessing and reducing the environmental impact of an AI system. normalisation.afnor.org
- Boavizta — open data and tooling on the environmental impact of digital systems, hardware included. boavizta.org
If you find that an order of magnitude on an entry contradicts one of these sources, that is a mistake on our part and we want to hear about it.
Why level colour carries no judgement
The level scale is a ramp of warm neutrals, light to dark. It is not a green-to-red gradient, and it never will be.
A green-to-red gradient would say “N0 good, N3 bad”. That is false, and it would be the opposite of what this site is for. A general-purpose model called on the right task is good engineering. A regular expression used where it cannot hold is a bad choice, however light it is.
The ramp measures weight, which is a quantity, not a value. The only colour that carries a judgement on this site is the green of the “recommended” badge, and that badge sits on whichever level fits the need.
What we do not do
We do not write legal advice. The regulatory block on each level describes, factually and with a date, what the approach brings you into the scope of, and what it does not excuse you from. No entry tells anyone they are compliant or not. This is general information; have a professional review your situation.
We do not compare vendors. The site has no advertising, no partnerships and no affiliate programme, and it will not have any. Where an entry names a tool, it is because the code needs it to run, not because we recommend it.
We do not follow you. No cookies, no trackers, no third-party resources. The only measurement is a page-view counter, anonymous, cookieless and served from this domain: the privacy page says exactly what it counts and what it does not do. The weight of each page is shown in the footer, computed at build time.
We call no model API from the site. The site contains no AI. That is not a technical constraint, it is an argument.
How to report a mistake
A wrong entry does more harm than a missing one. If you find one:
- open an issue on the repository, naming the entry and the point you dispute
- or write directly, if you would rather not go through the repository
A correction on substance is handled before any new content. If you are right, the entry changes, and its review date with it.
General information, kept up to date as best we can. It is not legal advice. Have a professional review your situation.
Reviewed on