{"slug": "classifier-dev-outperforms-jev-and-is-free", "title": "Classifier.dev: outperforms Jev and is free", "summary": "Classifier.dev launched a free, keyless zero-shot text classification API that it says outperforms the Jev model it runs on, scoring 90.0% on AG News versus 87.5% for Jev alone and 62.7% on emotion versus 61.8%, measured live on 2026-09-18 across 400 items per public test set. The service's smart tier re-asks only the items Jev was unsure about, gaining +2.5 points on AG News (+18.4 on the 49 unsure items) and +1.0 point on emotion (+4.9 on the 122 unsure items), with no API key or account required. Classifier.dev also ships an npm CLI, classifier-dev, and machine-readable descriptions at openapi.json and llms.txt.", "body_md": "# # classifier.dev\n\nzero-shot text classification over plain HTTP — no API key, no account\n\n## ## Give your agent this prompt\n\nPaste it into any coding agent. It installs the skill and teaches the agent to classify text through this API — no key, no setup.\n\n```\nSet up the classifier.dev skill: run `npx skills add https://classifier.dev`, then read https://classifier.dev/skill.md and follow it all the way through.\n```\n\nor open it in[\\[Claude Code\\]](claude-cli://open?q=Set%20up%20the%20classifier.dev%20skill%3A%20run%20%60npx%20skills%20add%20https%3A%2F%2Fclassifier.dev%60%2C%20then%20read%20https%3A%2F%2Fclassifier.dev%2Fskill.md%20and%20follow%20it%20all%20the%20way%20through.)[\\[Codex\\]](codex://threads/new?prompt=Set%20up%20the%20classifier.dev%20skill%3A%20run%20%60npx%20skills%20add%20https%3A%2F%2Fclassifier.dev%60%2C%20then%20read%20https%3A%2F%2Fclassifier.dev%2Fskill.md%20and%20follow%20it%20all%20the%20way%20through.)[\\[Cursor\\]](cursor://anysphere.cursor-deeplink/prompt?text=Set%20up%20the%20classifier.dev%20skill%3A%20run%20%60npx%20skills%20add%20https%3A%2F%2Fclassifier.dev%60%2C%20then%20read%20https%3A%2F%2Fclassifier.dev%2Fskill.md%20and%20follow%20it%20all%20the%20way%20through.)[\\[Grok\\]](https://grok.com/?q=Set%20up%20the%20classifier.dev%20skill%3A%20run%20%60npx%20skills%20add%20https%3A%2F%2Fclassifier.dev%60%2C%20then%20read%20https%3A%2F%2Fclassifier.dev%2Fskill.md%20and%20follow%20it%20all%20the%20way%20through.)\n\n## ## Better than calling its own model directly\n\nThe model behind this service is Jev. The smart tier re-asks only what Jev was unsure about, and comes out +2.5 points on AG News (+18.4 on the unsure items), +1.0 points on emotion (+4.9 on the unsure items). On 400 items a gap under about 5 points is noise; AG News clears it. Same public test sets, measured live over this API on 2026-09-18. No key, no cost.\n\n|  | AG News |  | emotion |  | \n|---|---|---|---|---|\n|  | all | unsure (49) | all | unsure (122) | \n| jev alone = classifier.dev fast | 87.5% | 65.3% | 61.8% | 36.9% | \n| classifier.dev smart | 90.0% | 83.7% | 62.7% | 41.8% | \n\n## ## Try it\n\n```\ncurl https://classifier.dev/spam,not+spam/Win+a+free+iPhone\nspam\n```\n\n## ## Install the CLI\n\n```\nnpm i -g classifier-dev\n```\n\nThen sort a file, one label ⇥ confidence ⇥ text line per input, in input order — a thousand lines a request, and rows appear as they land:\n\n```\nclassify bug,feature,praise < feedback.txt\nclassify relevant,\"not relevant\" --review 0.7 < snippets.txt   # only the unsure ones\n```\n\nZero-shot text classification over plain HTTP. You send text and a list of labels, you get back the label that fits and how sure the model is. There is no API key to obtain and no account to create, so the example below works if you paste it right now.\n\nIf you are an agent or a code generator, the machine-readable description of this API lives at [https://classifier.dev/openapi.json](https://classifier.dev/openapi.json) (OpenAPI 3.1), with a short index at [https://classifier.dev/llms.txt](https://classifier.dev/llms.txt)\n\n## ## Against the model it runs on\n\nThe model behind this service is Jev; the smart tier re-asks what Jev was unsure about. Same public test sets, 400 items each, measured live on 2026-09-18:\n\n```\n                                        AG News             emotion\n                                     all   unsure(49)    all  unsure(122)\n-------------------------------------------------------------------------\njev alone = classifier.dev fast    87.5%        65.3%  61.8%        36.9%\nclassifier.dev smart               90.0%        83.7%  62.7%        41.8%\n```\n\nThe fast tier is Jev, so one row serves both. Smart re-asked 43 / 126 of 400 items. Gaps under about 5 points are noise. The full table, with latency and cost, is at [https://classifier.dev/benchmark](https://classifier.dev/benchmark)\n\n## ## When this is worth a network call\n\nIf you are a language model, you can already classify any text you can see, for free. So the question is never \"can I classify this\" — it is whether you want the text in your context at all.\n\nThis is worth calling when reading the input is the expensive part:\n\nFiltering before reading. You have forty search results and want the six worth opening. Judging them yourself means pulling all forty into context first, which is the cost you were trying to avoid. One call returns forty labels and you read only the survivors.\n\nCascade pre-filtering. Drop the obvious no's cheaply, then spend real reasoning on what is left.\n\nStreams nobody reads line by line. Log lines, error buckets, inbound tickets, the changed files in a large diff.\n\nDeterministic routing. A pipeline branch that must take the same path for the same input on every run, instead of drifting with a model's reasoning.\n\nThe thread joining those: classify ten thousand things without reading them yourself. A thousand inputs go in one request and come back in about a second. Below about five items, skip it — you have already paid the context cost, so just decide.\n\n## ## CLI\n\nThe same API from the shell, one line per input, in input order:\n\n```\nnpm i -g classifier-dev\nclassify bug,feature,praise < feedback.txt\nclassify relevant,\"not relevant\" --review 0.7 < snippets.txt   # the unsure ones\nclassify db,web,ml --count < titles.txt                        # a histogram\n```\n\nPlain lines, JSON or NDJSON in; label, confidence and text out. Batches of a thousand per request, four at a time, and rows stream as they land, so piping to head returns at once on a large file. Retries rate limits and upstream failures on its own. classify --help has the rest. Source in cli/ at [https://github.com/mrmps/classifier-dev](https://github.com/mrmps/classifier-dev)\n\n## ## MCP\n\nThe same tools inside Claude, ChatGPT, Codex, Cursor or any MCP client, over Streamable HTTP with no key:\n\n```\nhttps://classifier.dev/mcp          classify_texts, classify_multi_label, count_labels, review_uncertain\nhttps://classifier.dev/mcp/docs     list_docs, read_doc, search_docs\nclaude mcp add --transport http classifier https://classifier.dev/mcp\ncodex mcp add classifier --url https://classifier.dev/mcp\n```\n\nListed in the official MCP registry as dev.classifier/classifier and dev.classifier/docs: [https://registry.modelcontextprotocol.io/v0/servers?search=dev.classifier](https://registry.modelcontextprotocol.io/v0/servers?search=dev.classifier)\n\nClaude.ai: Customize > Connectors > Add custom connector > paste the URL. ChatGPT: Settings > Security and login > Developer mode, then create an app with the URL and \"No Authentication\". Step by step for every client, plus what each tool does: [https://classifier.dev/mcp-setup](https://classifier.dev/mcp-setup)\n\n## ## Agent skill\n\nInstall this as a skill and your agent will remember to reach for it:\n\n```\nnpx skills add https://classifier.dev\n```\n\nIt is served straight from this domain over RFC 8615 well-known discovery, so there is no repository in the middle:\n\n```\n/.well-known/agent-skills/index.json   the discovery document\n/skill.md                              the skill itself, readable as-is\n```\n\nAgents without a skills runtime can simply fetch /skill.md and follow it.\n\n## ## Usage\n\n```\nGET  https://classifier.dev/{labels}/{text}\nGET  https://classifier.dev/?labels={a,b}&text={text}\nPOST https://classifier.dev  {\"input\":\"...\",\"labels\":[\"...\",\"...\"]}\nPOST https://classifier.dev  {\"inputs\":[\"...\", ...up to 1000],\"labels\":[...]}\n```\n\n## ## Examples\n\n```\ncurl https://classifier.dev/spam,not+spam/Win+a+free+iPhone+now\nspam\ncurl classifier.dev -d '{\"input\":\"the checkout button does nothing\",\"labels\":[\"bug\",\"feature\",\"praise\"]}'\n{\"label\":\"bug\",\"confidence\":1,\"scores\":{\"bug\":1,\"feature\":0,\"praise\":0},\"model\":\"jev-1.13.0\",\"ms\":260}\ncurl \"classifier.dev/entailment,neutral,contradiction/Only+12+of+40+sites+were+inspected.+Every+site+was+inspected.\"\ncontradiction\n```\n\nSpaces can be written as + or %20, and labels are separated by commas.\n\nThe same request as query parameters, for code that builds URLs:\n\n```\ncurl \"https://classifier.dev/?labels=spam,not+spam&text=Win+a+free+iPhone+now\";\nspam\n```\n\ninput, q, classes and categories are read as text and labels too, and the two forms mix: /spam,not+spam?text=... is the same call. Every option below works on both. A malformed GET answers with a URL that would have worked.\n\n## ## Parameters\n\n```\nlabels        Two to one hundred categories. Required.\ninput         The text to classify, up to 32,000 characters.\ninputs        Up to one thousand strings classified in a single call.\ntier          Either fast (the default) or smart. See TIERS.\ninstructions  Extra criteria, such as \"judge the reviewer's overall verdict\".\nverbose       On GET requests, ?verbose=1 returns JSON instead of a bare label.\nmulti         Return every category that applies instead of just one.\nmax_labels    Cap how many multi-label answers come back.\n```\n\nResults come back in input order. Each carries the label, a confidence from 0 to 1, a score for every label, and the model that answered.\n\nBatch responses also carry modelsUsed. The top-level model is \"mixed\" when different results were answered by different models, such as a smart-tier batch where only some inputs were escalated.\n\n## ## Confidence\n\nThe model behind this is not a language model prompted to classify. It is a decision model that returns a calibrated probability for every label, so the confidence is a real forecast of whether the label is right, measured:\n\n```\nsix-way emotion, 400 items      confidence >= 0.9   right 82% of the time\n                                confidence <  0.5   right 29% of the time\nfour-way news topic, 400 items  confidence >= 0.9   right 92% of the time\n                                confidence <  0.5   right 64% of the time\n```\n\nUse it. Act on high-confidence answers, and route the rest to a person, a reasoning model, or the smart tier, which does exactly that for you.\n\nTwo things confidence does not measure.\n\nIt is not out-of-distribution detection. It says which of your labels fits best, not whether any of them fit. \"The weather is nice today\" against bug / feature / praise is \"praise\" at 0.97. If none-of-the-above is a real outcome, add it as a label — the same text against those three plus \"none of these\" picks \"none of these\" at 0.78. That works; hoping for a low score does not.\n\nIt is withheld for input that is not language. A forced choice on \"asdkjfhaskdjfh\" still lands somewhere, so the label ships with confidence and scores null and an unscored field explaining why.\n\n## ## Multi-label\n\nOne article, fifty tags, the ones that fit:\n\n```\ncurl classifier.dev -d '{\"input\":\"...\",\"labels\":[\"ml\",\"databases\",...],\n                         \"multi\":true,\"max_labels\":10}'\n{\"results\":[{\"labels\":[\"databases\",\"serverless\",\"rust\",\"caching\", ...],\n             \"scores\":{\"databases\":0.98,\"serverless\":0.98,...,\"gaming\":0.01}}]}\n```\n\nOn GET, add ?multi=1 and the labels come back one per line.\n\nEvery label is judged independently as a yes/no probability, and the answer lists those at or above 0.7, most likely first. The full score map is returned so you can set your own threshold: on a seven-task set, 0.7 gave recall 0.99 and precision 0.81 (F1 0.887); 0.5 gave recall 1.00 and precision 0.74. max_labels keeps the top N. One request, about 200ms.\n\n## ## Tiers\n\n```\nfast     Every answer comes from the decision model, in one round trip.\n         Measured: four-way news topic 87.7%, six-way emotion 60.5%, which is\n         the same accuracy as a 3.4-second reasoning model on the news topics\n         at two milliseconds per item.\nsmart    Same first pass, then every single-label answer below 0.7 confidence\n         is re-asked of a fast reasoning model and replaced. Measured:\n         emotion 61.8% to 63.7%, news topics 87.5% to 90.0%, by re-asking\n         30% and 12% of the items. Those results carry escalated: true and\n         the reasoning model's name; the confidence and scores shown are\n         still the decision model's, since they are why it was escalated.\n         usage.escalated counts them. A few seconds per escalated item, so\n         a batch on smart is slower in proportion to how uncertain it is.\nMulti-label answers ignore the tier: the reasoning model was\nmeasured re-judging them and made them worse.\n```\n\nThe models are not fixed. They are benchmarked as candidates appear and swapped when a measurement, not a launch post, says to. If the decision model is unavailable, requests of up to twenty inputs fall back to a chain of language models on different providers; JSON responses always report which model actually answered.\n\n## ## Limits\n\nLimits are counted per IP address in classifications, not requests, so a batch of a thousand inputs spends a thousand of them. The fast tier allows 3,000 per minute and 20,000 per day; the smart tier 200 per minute and 2,000 per day.\n\nEach input is capped at 32,000 characters, and a request may carry up to a thousand inputs. Every response carries an X-RateLimit-Limit header and, where it can be determined, X-RateLimit-Remaining. Exceeding a limit returns 429 with a Retry-After header rather than a slow or silently dropped request.\n\nIf you need more than this, or you want a classifier tuned to your own data, the fastest path is a short call: [https://cal.com/michaelsf/coffee](https://cal.com/michaelsf/coffee)\n\n## ## Privacy\n\nThe text you send is never stored or logged here. It is forwarded to the model provider for the classification and nothing else. What gets recorded is the label names, which tier ran, which model answered, the latency, the response status and a coarse country, which is what makes the usage counts on this service possible.\n\nBuilt by @michael_chomsky — [https://x.com/michael_chomsky](https://x.com/michael_chomsky)", "url": "https://wpnews.pro/news/classifier-dev-outperforms-jev-and-is-free", "canonical_source": "https://classifier.dev/", "published_at": "2026-09-19 08:51:48+00:00", "updated_at": "2026-09-19 09:25:05.283656+00:00", "lang": "en", "topics": ["ai-tools", "natural-language-processing", "developer-tools", "ai-agents", "agent-protocols"], "entities": ["Classifier.dev", "Jev", "AG News", "Claude Code", "Codex", "Cursor", "Grok", "npm"], "alternates": {"html": "https://wpnews.pro/news/classifier-dev-outperforms-jev-and-is-free", "markdown": "https://wpnews.pro/news/classifier-dev-outperforms-jev-and-is-free.md", "text": "https://wpnews.pro/news/classifier-dev-outperforms-jev-and-is-free.txt", "jsonld": "https://wpnews.pro/news/classifier-dev-outperforms-jev-and-is-free.jsonld"}}