classifier.dev
mrmps
Zero-shot text classification over plain HTTP, no key or signup, built for agent context-filtering rather than final answers.
What is classifier.dev?
A single Cloudflare Worker that takes text and labels and returns a label with a calibrated confidence, no account or API key needed, up to 1,000 texts per request. Classification is answered by TypeSafe's Jev, a dedicated decision model, with an LLM fallback chain and a 'smart' tier that re-asks low-confidence cases. The same logic ships as a CLI, an MCP tool, and an agent skill served straight from the domain, with Durable-Object rate limiting and privacy-preserving analytics.
| Fact | Value |
|---|---|
| Maintainer | mrmps |
| GitHub stars | 412 (as of 2026-09-23) |
| Forks | 32 |
| License | MIT |
| License type | OSI-open |
| Category | Coding agents and context efficiency |
| Status | Rising |
| Edition | 2026-09 |
| Last verified | 2026-09-23 |
classifier.dev in depth
Feeding an LLM forty search results so it can pick the six relevant ones burns tokens on the other thirty-four. classifier.dev, built by Michael Ryaboy and released in August 2026, targets exactly that gap: a zero-shot text classification API you can call with no signup and no key, curl https://classifier.dev/spam,not+spam/Win+a+free+iPhone returns 'spam' in about 150ms. It is pitched not as a replacement for an LLM's judgment but as a cheap first pass agents can use to filter what deserves a model's attention at all, context economy over raw capability.
Under the hood it is a single Cloudflare Worker, no database beyond Durable Objects for rate limiting and KV for reports. Requests get answered by TypeSafe's Jev, a dedicated decision model (not a language model) that takes typed questions and returns a calibrated probability per label in roughly 150ms; an LLM fallback chain (via OpenRouter or Vercel's AI Gateway) takes over if Jev is unavailable, and a 'smart' tier re-asks low-confidence single-label answers of a reasoning model. Batches of up to 1,000 texts pack into one upstream call, and the same logic ships as a CLI, an MCP tool, and an agent skill served straight from the domain via RFC 8615 discovery.
It fits agent and pipeline builders who need to cheaply triage volume before an expensive model gets involved: filtering search results, tagging support tickets, routing feedback by team or urgency (multi-dimension classification is a first-class feature, up to 20 dimensions per request). The project also documents its own operational discipline in unusual detail for a solo project, a Durable-Object rate limiter chosen after two other approaches silently failed, credential-safe alerting, and a deploy pipeline that runs a live classification against production before calling a deploy successful, which suggests an operator who has actually run this in anger.
The MIT license covers the Worker, CLI and routing code, not the model doing the actual classifying: TypeSafe's Jev is a closed, proprietary third-party API, so self-hosting still means paying and trusting a backend you cannot open-source-audit. It is effectively solo-maintained (162 of roughly 169 commits from one author) and only six weeks old, with just two GitHub issues logged so far, too little history to judge real-world failure modes. And every accuracy and speed figure quoted (confidence calibration, F1 against LLM cascades) is the project's own /benchmark page, not an independent evaluation, however specific the methodology looks.
classifier.dev is a reasonable pick if you want a free, no-signup way to cheaply pre-filter text for an agent and are comfortable depending on a closed third-party model underneath an open client. The engineering discipline around a Cloudflare Worker (rate limiting, privacy-preserving analytics, deploy-time smoke tests) is more careful than most projects this size bother with. But it is young, effectively single-maintainer, and its 'open source' label describes the plumbing rather than the intelligence doing the classifying; know that distinction before building a dependency on it.
Pros & Cons
Pros
- No account or API key needed for the free tier - curl https://classifier.dev/spam,not+spam/... just works, a real barrier removed for agent tool-use
- Substantial original engineering beyond a thin wrapper: Durable-Object-based per-IP rate limiting (with two rejected approaches documented, including a Cloudflare native binding that silently failed to decrement), keyed-pseudonym privacy for analytics, and a CI pipeline that runs a live classification against the deployed Worker before a deploy is considered successful
- Self-hostable on your own Cloudflare account with your own provider keys, not only usable as the hosted classifier.dev service
Cons
- The core classification model (TypeSafe's Jev) is a closed, proprietary third-party API - the MIT license covers the Worker/CLI/routing code, not the model doing the classifying
- Solo-maintained in practice (162 of roughly 169 commits from one author) and only six weeks old (created 2026-08-13), with just two total GitHub issues logged so far
- Accuracy and speed numbers (confidence calibration, F1 comparisons against LLM cascades) are the project's own /benchmark page, not independently reproduced
License
MIT (OSI-open)
MIT covers the Worker, CLI and MCP server. Classification itself is answered by TypeSafe's proprietary Jev API, with an OpenRouter/AI-Gateway LLM fallback chain: no open classification model ships with this repo, and self-hosting still means depending on that closed backend.
When it is interesting
Coding agents or pipelines that need to cheaply triage or filter large batches of text (search results, feedback, tickets) before spending tokens on a full model.
When it is too early
If you need the classification model itself to be open and self-hostable, not just the routing layer around a closed one.
This repo featured in the 2026-09 edition of the Open-Source AI Radar.
RTK
rtk-ai
CLI proxy that compresses shell command output before your AI coding assistant sees it, cutting tokens 60-90%.
TOON
toon-format
Token-Oriented Object Notation - a compact serialization format that uses ~40% fewer tokens than JSON.
planning-with-files
OthmanAdi
Crash-proof markdown planning for AI coding agents - persists task state across context loss and /clear.