Cheap AI Classification: Best Options for Production Workflows
Cheap AI classification compared: chat tiers, hosted decision APIs, fine-tuned classifiers and open-weights models on price, setup effort and confidence.
This is about cheap AI classification: the least expensive ways to classify text in a production workflow. "Cheap" has two meanings here, cheap per call and cheap to run well, and the options differ more on the second. This is a dated comparison; prices change often in this market, so treat every number as a snapshot and re-check before you commit.
The four cheap AI classification options
1. Cheap chat tier + structured outputs
A small hosted chat model constrained to your label enum.
- Price model: per token, prompt and generated output.
- Setup effort: lowest with an existing provider account.
- Multi-label: yes, via structured output fields (you define the schema).
- Confidence output: no per-option probability unless the provider exposes logprobs.
- The catch: the bill includes generated tokens, and without logprobs there's no probability to threshold on: "cheap" per call, but the safety machinery (validation, retries, sampling) is unbuilt and costs engineering time.
2. Hosted decision API
GPT-6 Luna Decisions (released 2026-10-06) is the current reference: per-option probabilities for yes/no, choice and score questions, up to 200 per request according to OpenAI's docs as of 2026-10-07; check the official pricing page for the current rate.
- Price model: per input token only. No output tokens to bill, because nothing is generated.
- Setup effort: low; an HTTP call from anything.
- Multi-label: no multi-label question type listed in OpenAI's docs as of 2026-10-07; check current docs. A yes/no per tag works in the meantime.
- Confidence output: per-option probabilities, the real thing.
- The catch: data egresses to the provider; versions are provider-managed.
3. Fine-tuned small classifier (self-hosted)
An encoder-sized model trained on your labels.
- Price model: your compute; tiny per inference.
- Setup effort: highest, with labeled data, training loop, serving, and retraining whenever labels change.
- Multi-label: per-task training.
- Confidence output: the model's own probabilities (whether they're calibrated needs measuring).
- The catch: the price is paid in ML labor and label-change friction, not dollars per call. Excellent with a frozen label set and volume; punishing otherwise.
4. Open-weights decision model, self-hosted (e.g., Saina Helm)
- Price model: fixed hosting. Helm is CPU-sized (~4 GB RAM; measured 0.9–2.7 s per request, local Docker test, 2026-10-06); a modest VM carries it.
- Setup effort: medium; you run a server (the
ghcr.io/run-saina/saina-server:0.1.2container, orpip install 'saina[local,server]') with TLS and auth in front. - Multi-label: native
multi_choicequestions with independent memberships, through the server's/v1/askAPI. Not available through the Ollama build, which serves a different endpoint. - Confidence output: per-option probabilities; decision mode with threshold, margin, and per-answer reasons.
- The catch: the ops commitment. "No per-token fee" is not "free"; the cost pillar covers when hosted comes out cheaper.
The comparison
| Cheap chat tier | Hosted decision API | Fine-tuned classifier | Self-hosted decision model | |
|---|---|---|---|---|
| Price model | Per token in+out | Per input token | Your compute + ML labor | Fixed hosting |
| Setup effort | Lowest | Low | Highest | Medium |
| Multi-label | Via schema | Not listed (check docs) | Per-task training | Native (not via Ollama) |
| Confidence output | Logprobs if exposed | Probabilities | Probabilities (measure) | Probabilities + reasons |
| Data location | Provider | Provider | Yours | Yours |
| Labels change often | Fine | Fine (data per request) | Painful retrain | Fine (data per request) |
Also consider
- Embeddings + a lightweight classifier: embed each text with an embedding model, train logistic regression or similar on your labels. Cheap per call and quick to retrain, but it still needs labeled data.
- Zero-shot NLI models: open models that score "this text is about X" for arbitrary labels without training. Easy to try; check accuracy on your own data before relying on it.
- Other hosted decision APIs: OpenRouter Decisions and TypeSafe System One are other hosted options; check each one's docs for pricing, question types and output format.
- Other open-weights decision models on Ollama: pull and run them locally, and compare on your own labeled set (50–100 examples for a first check).
Choosing
- Already paying a provider, low volume, tolerant of parsing: cheap chat tier, priced as cheap-per-call.
- Want real confidence without infrastructure: hosted decision API; usually the best "cheap to run well".
- Frozen labels, high volume, ML capacity: fine-tuned classifier.
- Data in-house, or flat cost at volume, or n8n self-hosters: open-weights decision model.
The meta-advice: compute your total cost per thousand decisions including the safety machinery (validation, review handling, monitoring), not just the inference line. The options with real probabilities can spend less on safety; that's where "cheap" actually lives.