Wity: The First System 1.5 Model, Built for Software Decisions

Software makes thousands of small decisions every day: which team should this ticket go to? Is this scan a receipt or an invoice? Has the page finished loading? Is the customer reporting an incident? These decisions don't need long essays—they need an answer that code can act on directly, along with how certain that answer is. Wity positions itself as a System 1.5 model, filling exactly the gap between the two existing types of models.

Two Types of Models, Two Dilemmas

Large language models (LLMs) "think" about every question, no matter how simple. They answer in paragraphs, and your code has to parse that natural language. For a well-defined question, you pay seconds of latency and token costs for reasoning you may not need at all—and you still don't know how confident the answer is.

The other category is fast decision models, which give an answer "at a glance." Simple questions return instantly, and hard questions also return instantly—but they may be confidently wrong, because the model has no mechanism to slow itself down.

According to Wity's official blog, neither type of model is designed for the high-frequency, fine-grained decision scenarios in software. Wity's solution is to introduce the concept of "System 1.5."

What Is System 1.5?

Psychologists divide thinking into two modes: System 1 is fast and intuitive; System 2 is slow and deliberate. Most of our everyday decisions are made by System 1, and we switch to System 2 only when something feels off.

Wity works similarly. For most questions, it completes a fast round of reasoning and returns an answer in about 0.1 seconds. When the answer is uncertain or unstable, it "thinks" before answering. Either way, it returns the same thing: a typed decision, along with a probability for each option. That's what "System 1.5" means—it sits between intuition and deliberation, and dynamically chooses a mode for each question.

The System 1 / System 2 distinction comes from the dual-system theory proposed by psychologist Daniel Kahneman in Thinking, Fast and Slow. System 1 handles fast, automatic, unconscious intuitive judgments, such as recognizing a familiar face or understanding a sentence in your native language; System 2 handles slow, effortful, conscious logical reasoning, such as calculating 17×24 or weighing two job offers. The vast majority of human daily decisions are made by System 1, and System 2 is invoked only in situations involving conflict, anomalies, or low confidence. The analogy in software is precisely to map this cognitive mechanism onto model inference: default to a low-cost fast path, and upgrade to a high-cost reasoning path only when necessary, thereby achieving a dynamic balance among latency, cost, and accuracy.

What a Decision Looks Like

You send the API a state (the content to be decided on: text, JSON, images, or a combination of the three) and one or more questions, and explicitly list the options for each question. For example, to determine the intent of a customer email:

curl https://api.wity.alphanimble.com/v1/systemone \
  -H "Authorization: Bearer $WITY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "Hi, I was charged twice for my subscription this month. Please refund the duplicate.",
    "questions": {
      "intent": {
        "type": "choice",
        "instructions": "What does the customer want?",
        "criteria": {
          "billing": "A charge, refund, invoice or payment problem",
          "technical_support": "Something in the product is broken",
          "account_access": "Cannot log in or is locked out",
          "cancellation": "Wants to cancel or downgrade"
        }
      }
    },
    "reasoning": "auto"
  }'

The returned result is keyed directly by the name you gave the question, and includes the selected option, the probabilities of all options, the overall confidence, and reasoning metadata. There's no prose to parse. choice is the option you can act on directly, and probabilities covers every option you provided. In this example, reasoning.thought is false, because the question is clear and Wity answered directly.

Four Primitives, Every Answer Has a Type

Every question belongs to one of the following four shapes, and you choose the shape while Wity fills it in:

• noul: A yes/no judgment. For example, "Is the insured driver at fault?"
• score: A position on a scale. For example, "Damage severity: cosmetic, repairable, or total loss?"
• choice: Pick one from a set of options. For example, "Which team should this ticket go to?"
• generate: Generate short text in a format you define, for some action to use. For example, "The policy number in the scan."

Because every decision carries probabilities, your code can decide for itself "how certain is certain enough." For example, auto-route only when the intent classification probability exceeds 0.85, and otherwise send it to manual triage. This confidence threshold can be set separately for each question.

In API design, a "primitive" refers to the smallest, indivisible building block from which more complex functionality is composed. Abstracting decisions into the four shapes noul, score, choice, and generate here means developers don't need to care about how the underlying model reasons—they only declare the output structure, and the model fills it in. This design borrows from the idea of type systems: by labeling every return value with an explicit type, the caller can perform static validation and branching at compile time or runtime, avoiding fragile string parsing of free text. The number of primitives is kept very small to reduce the learning curve and ensure interface stability, while complex business logic is implemented by composing multiple primitive calls.

Five Differentiating Features

1. Multimodal: Photos, screenshots, and scanned pages can be included in the same request as text.
2. 128K token context: An entire contract, a long email thread, or a stack of scanned pages can be processed as a single state without chunking.
3. The generate primitive: Provides a primitive for the places where software genuinely needs text, generated right after the decision from the same state.
4. Automatic thinking: Answers instantly on clear questions and deliberates on uncertain ones, deciding question by question.
5. On-premises deployment: Can run inside your own network, with the same API as the cloud.

Speed and Cost: Low Enough to Call Everywhere

For a decision model to actually get used, it must be cheap enough to call on every event and fast enough to sit in the request path. According to Wity's official blog, they tested Wity against eight fast, low-cost models on the same 200 real-world cases. A typical Wity call takes 109 milliseconds, while the second-fastest model took 943 milliseconds; 1,000 runs cost $3.29, while the second-cheapest cost $17.95. This is Wity's own benchmark, and the methodology has been published alongside the results.

Pricing is a single number: $0.042 per million tokens, and failed calls are free. The thinking process isn't billed, so "think, then answer" costs the same as answering directly.

Wity also candidly acknowledges that no model is perfect. It recommends using each decision's probability to decide when to act and when to escalate, and validating generated text as you would any input.

A benchmark is a standardized experiment for measuring model performance, and its credibility depends heavily on the representativeness of the test set, the choice of baselines, and the reproducibility of results. The 200 real-world cases, the eight fast, low-cost comparison models, and the fact that "the methodology has been published alongside the results" mentioned in the article are all key clues for evaluating benchmark quality. When interpreting vendor self-reported data, readers should distinguish whether latency is end-to-end or inference-only, whether cost includes retries and failed calls, and whether the case distribution skews toward simple problems. The effectiveness of confidence-threshold routing also depends on probability calibration—that is, whether the 0.85 the model gives really corresponds to 85% accuracy, which typically requires calibration validation on your own business data.

Who It's For, and What's Next

Wity is aimed at developers who need to embed a large number of lightweight decisions into software systems—ticket routing, document classification, form field extraction, intent recognition, and so on. It doesn't try to replace LLMs in open-ended generation tasks; instead, it solves the problems that "don't need an essay, just an option with a confidence level."

According to the official blog, this is the first post in a series. Future posts will go deeper into System 1 vs. System 2, why decisions shouldn't be returned as paragraphs, when a model should think, the details of each primitive, and real builds with code. New accounts currently come with $5 in free credit (to be used within 48 hours of sign-up), and the Playground lets you run real requests directly in the browser.

One-line Summary

Positioned as System 1.5, Wity fills the gap between LLMs and fast models with typed decisions that carry probabilities.

Paragraph Summary

The article introduces the System 1.5 model positioning proposed by Wity: for the high-frequency, fine-grained decision scenarios in software, it by default answers quickly in about 0.1 seconds and automatically switches to deliberate thinking when a question is uncertain. Its API accepts a state composed of text, JSON, or images plus questions with options, and returns a decision result in one of four primitives—noul, score, choice, or generate—along with the probability of each option and the overall confidence, so code can act directly without parsing natural language. The official benchmark claims a typical call takes 109 milliseconds and 1,000 calls cost $3.29, with pricing at $0.042 per million tokens and failed calls free, while also supporting multimodality, 128K context, and on-premises deployment. The article emphasizes using probabilities to set confidence thresholds for routing, and sending ambiguous decisions to humans.