Milliseconds.ai

Milliseconds.ai is an API that turns text and images into decisions. You send text or an image, and the platform returns labels, fields, scores, or yes/no answers as structured data. The product is built around a small model the team calls decision-machine-1, and it is designed specifically for the parts of an application that need an answer rather than a conversation. The company describes the service as delivering "AI decisions, classification and extraction via a simple API." It is available through REST endpoints, SDKs, and a CLI, so developers can call it from TypeScript, Python, or the terminal and receive typed responses. Typical jobs described on the site include routing emails, reading invoice fields, and checking returns against a policy, as well as more playful applications such as building a hot-dog identification empire. The landing page frames the product with the line "Small model. Big decisions." and the supporting idea "Enough words. Try it, stat!" — the emphasis being on delivering the decision itself rather than a long piece of generated prose. The problem Milliseconds.ai addresses is the gap between general language models and the small, concrete decisions applications need to make on every request. The website contrasts a typical verbose model reply — "Certainly! Let's delve into a comprehensive overview of this invoice and its many fascinating details…" — with what a system actually needs: just the fields, invoice number, vendor, total, and currency, ready for the next step. The product exists for "the parts of your app that need an answer," where the goal is not open-ended conversation but a label, a score, a boolean, or a set of validated fields. The framing "Less blah. More done." captures this directly: instead of parsing free-form text after the fact, an application can receive structured data it can immediately act on. This matters because routing, prioritization, validation, and record writing all depend on machine-readable outputs rather than paragraphs of explanation. The site summarizes this as "Very small decisions. Very real work." The platform exposes a set of purpose-built decision endpoints. The yes/no endpoint answers a boolean question about a piece of text — for example, flagging messages that need a faster response — and returns both the boolean answer and a probability of urgency, so an application can raise a ticket's priority. The classify endpoint assigns a label from a set of choices: given support queues, it can return a label such as "billing" along with a probability (0.74 in the recorded example) and a confidence value, plus scores for the other candidate labels such as shipping, technical, and other. The rate endpoint turns subjective input like customer frustration into a sortable score on a defined scale; the example returns a reported score of 1.998 on a 0–3 scale, a level, a confidence figure, and per-level scores across calm, annoyed, angry, and furious. The answer endpoint locates a specific span of text in response to a question — for example, finding the shipment destination in a status update — and returns the answer text together with a probability and start and end source offsets, so an application can show where the answer came from. Extraction and entity recognition form a second group of capabilities. The extract endpoint maps unstructured text to the fields in your records. In the recorded invoice example, it returns a structured object with invoice_number, vendor, total, and currency — four fields described as ready for validation before writing a record. The entities endpoint identifies people, organizations, and references in a document; the claim-note example returns four typed entities (a person name, an organization, a claim id, and a date), each with a type, the matched text, and a probability score, described on the site as "typed values for search and record matching." Together these endpoints cover two of the most common document-intake needs: pulling out defined fields, and recognizing the named things inside free text. A third capability is verification. The verify endpoint checks a proposed value against source text. In the documented example it compares a proposed deductible against policy text and returns matches: false with a probability of 0.00, because the source says $500 while the proposed value is $1,000, and it returns the found value ["$500"]. This lets a workflow confirm that a value is actually supported by the source document before it is accepted — the kind of check required in insurance or finance processes where an extracted number must be traceable back to the text it came from. Overall, the product follows a simple INPUT → DECISION → ACTION model. Text or an image goes in; the model produces a decision in the form of a label, a score, a boolean, a text span, a set of fields, or a list of entities; the application then acts on that structured output. Every response is designed to be consumed by code: boolean answers with probabilities, labels with probability and confidence, scores with per-level breakdowns, answers with source offsets, extracted fields as key-value data, and entities with type, text, and probability. The site notes that uncertainty is surfaced rather than hidden — for instance, "nearly tied levels signal uncertainty," so a queue-ranking system can keep that ambiguity visible. Developers integrate through REST endpoints, TypeScript or Python SDKs, or the CLI and receive typed responses. There is also a path for coding agents: installing skills that teach an agent which API to call and how to evaluate results. The benefits described on the site centre on speed, structure, and cost. Because the model is small and purpose-built, responses arrive as data rather than prose, removing the parsing step between a model call and an application action. Because outputs are structured and include probabilities and confidence, applications can make ranking, routing, and validation decisions with a stated level of certainty. Cost is a headline benefit: production usage is priced at $0.04 per million input tokens, with no charge for output tokens, and free test keys include 125M free input tokens per month with no card required. The website frames the economics as "Big ideas. Small bill." and repeats the free allowance as "Free free free — yours to build with." The site presents several concrete scenarios. Support triage combines the pieces: "A label selects the queue. A score sets priority. A boolean flags urgency." Document intake works as a pipeline: "Extract fields, check values against the source, then validate before writing a record." In the Invoice Desk demo, invoice text is turned into a vendor, invoice number, and total, which are then compared with the purchase order so a team can see what needs attention — the example record matches PO-208. In the Sales Intake demo, an inbound message is separated from support tickets and vendor pitches, given a suggested destination of Sales because it is a demo request with budget stated and a near-term start, and the budget, timing, and need are surfaced for follow-up. In the Private Share demo, names and emails are found in a transcript so personal details can be redacted while the bug report stays useful — detected details are reviewed before sharing, with a toggle between the original and the redacted version. Other stated examples include checking returns against a policy, routing emails, and identifying hot dogs. Milliseconds.ai is aimed at developers and teams building applications that need classification, extraction, and decisions at the point of request — the people who would otherwise wire a general-purpose model into a workflow and then parse its output. The website addresses them directly: "You bring the idea. Build something fast." Integration options explicitly named are the REST API, the TypeScript SDK, the Python SDK, the CLI, and skills for coding agents. Pricing is split between a free tier of 125M free input tokens per month on test keys with no card required, and production at $0.04 per million input tokens with output tokens free. Demos let visitors try working apps and inspect their results, token usage, and inference cost, and visitors can try requests on the site without an API key. In summary, Milliseconds.ai takes the small, repetitive decisions that applications make — is this urgent, which queue does this belong to, how frustrated is this customer, where is the shipment going, what are the invoice fields, who and what are mentioned here, does this value match the source — and returns them as structured, probability-bearing data through one fast API. The combination of a small purpose-built model, typed structured outputs, built-in verification, coding-agent skills, and a free tier with inexpensive production pricing is what the product offers to teams that need answers rather than conversation.