Introducing Wity, the First System 1.5 Model

Software makes thousands of small decisions a day. Which team owns this ticket? Is this scan a receipt or an invoice? Has the page finished loading? Is the customer reporting an accident? Today those calls usually go to one of two kinds of model, and neither is built for the job.

Large language models think through every question, even the easy ones, and answer in paragraphs your code then has to parse. Fast decision models answer in a single glance: easy calls come back instantly, and hard ones come back confidently wrong. Wity sits between the two. We call it a System 1.5 model.

What System 1.5 means#

Psychologists describe two modes of thought. System 1 is fast and intuitive. System 2 is slow and deliberate. Most of what we decide in a day is System 1, and we switch to System 2 only when something feels off.

Wity works the same way. It answers most questions in one fast pass, in about a tenth of a second. When an answer is uncertain or unstable, it thinks first and then answers. Either way you get the same thing back: a typed decision with a probability for every option.

Four primitives, every answer typed#

Every question you ask Wity takes one of four shapes. You pick the shape, Wity fills it.

• noul: a yes-or-no call. "Was the insured driver at fault?"
• score: where on a scale something sits. "How bad is the damage: cosmetic, repairable or total loss?"
• choice: one option from a set. "Which team owns this?"
• generate: the short text an action needs, in a shape you define. "The policy number from the scan."

You send a state (text, JSON, an image, or all three) and as many questions as you like. Each answer comes back under the name you gave it:

{
  "state": {
    "ticket": "I was charged twice for order #4471.",
    "customer": { "plan": "Pro monthly", "open_orders": 2 }
  },
  "questions": {
    "team": {
      "type": "choice",
      "instructions": "Which team owns this ticket?",
      "criteria": {
        "billing": "Charges, refunds, invoices",
        "shipping": "Where an order is, delivery problems",
        "tech": "Bugs, log-in problems",
        "other": "Anything else"
      }
    },
    "urgent": { "type": "noul", "instructions": "Is the customer losing money right now?" }
  },
  "reasoning": "auto"
}

{
  "answers": {
    "team": {
      "type": "choice", "choice": "billing", "confidence": 0.94,
      "probabilities": { "billing": 0.96, "shipping": 0.02, "tech": 0.01, "other": 0.01 }
    },
    "urgent": { "type": "noul", "noul": 0.81 }
  }
}

Because every answer carries its probabilities, your code can decide how sure is sure enough. Act on clear calls, hand close ones to a person, and set that line per question:

team = answers["team"]
if team["probabilities"][team["choice"]] >= 0.85:
    assign(ticket, team["choice"])        # sure enough: act on its own
else:
    send_to_triage(ticket)                # close call: a person decides

Five things that set it apart#

• Multimodal. Photos, screenshots and scanned pages go in the same request as your text, and every question is answered against all of it.
• 128K-token context. A whole contract, a long email thread or a stack of scans fits in one state. No chunking, no hoping the part that matters survives.
• generate. A new primitive for the few places software genuinely needs words, written from the same state, right after the decision. More in Decide, Then Generate.
• Auto-thinking. Instant on clear-cut questions, deliberate on shaky ones, decided per question. More in Knowing When To Think.
• On-prem. We can deploy Wity inside your own network, with the same API as the cloud, so sensitive data never leaves.

Fast and cheap enough to put everywhere#

A decision model earns its place by being cheap enough to call on every event and fast enough to sit inside a request. We ran Wity and eight fast, low-cost models through the same 200 real-world cases. Wity's typical call took 109 ms, against 943 ms for the next fastest, and 1,000 runs cost $3.29, against $17.95 for the next cheapest. On Benchmark Heaven's independent JevBench, Wity-1 has the highest Capability Score of the Jev-class APIs. The full numbers, and how they were measured, are on the benchmarks.

Pricing is one number: $0.042 per million input tokens. Thinking is free, so a thought answer costs the same as a direct one. Every account starts with $5 of credit; see Pricing.

Start building#

The quickstart gets you to your first decision in about a minute, and the evaluator lets you run Wity against your own cases before you write any code. For on-prem deployments, write to us at wity@alphanimble.com.