rw-book-cover

Metadata

Highlights

  • Much of what a language model does inside a product is not open-ended writing. It is deciding: which queue a ticket belongs in, whether a request is safe, whether a tool should be called, how a response rates on a scale of 1 to 5. A decision has a known set of possible answers. What the application needs back is a choice and a trustworthy probability for each option, delivered fast and every time. (View Highlight)
  • Today we’re releasing GLiDE as a family of five open-weight decision models: GLiDE 0.4B, 0.8B, 2B and 9B, and GLiDE at 27B. All five share one interface (the System One schema), so you can change size without changing your questions or how you parse the answers. (View Highlight)
  • On Decision Index 0.4.1 we expect all five to sit on the size–quality frontier: no model on the board with as few parameters scores higher. We expect four of the five to beat every similarly sized model outright, and GLiDE to be the strongest decision model at any size. We expect the fifth, the 0.4B, to land within about a point of a slightly larger peer. (View Highlight)
  • 9B. We expect it to lead its class at 61.8 against elephant-1’s 60.26. Its interval is the widest in the family, though, so treat that lead as roughly a two-in-three chance rather than a certainty. (View Highlight)
  • A chat model reaches an answer by writing, and a reasoning model writes a great deal before it answers. For a decision, most of that writing is overhead, because the possible answers are known before the model starts. A decision model can read the context, the question and every option together and score all the options at once. (View Highlight)
  • GLiDE does exactly this: one forward pass per question, a probability for every option, and no generated tokens. Two useful properties follow.
    1. Latency is predictable, with no long tail from unusually long generations.
    2. The output is a probability distribution you can set thresholds on, not a string you have to parse.
      On the Artificial Analysis Decision Index, GLiDE v1.2 had the lowest calibration error of any decision model on the board. In other words, its stated confidence most closely matched how often it was right. (View Highlight)
  • The trade-off is that explicit reasoning really does help on hard decisions. The question behind this release is how much of that benefit can be moved inside the network. With GLiDE v1.2, we distilled reasoning teachers’ answer distributions into a model that writes nothing, and it reached #1 on both the Hugging Face and Artificial Analysis decision model leaderboards. This release adds a second lever. (View Highlight)
  • A transformer’s depth is fixed: each input gets the same number of layers of computation. Reasoning models get around this by writing, since every generated token buys another full pass through the network. Recurrent depth gets more computation without writing anything. This is the idea behind recurrent looped transformers, which have become one of the most discussed directions in AI since reports that OpenAI’s GPT-6 Astra uses them. In GLiDE 27B and GLiDE 9B, a band of middle layers runs twice, using the same weights both times, before the model reads out its answer. The second pass refines a representation the network has already built. It adds no parameters and produces no text, and its cost is fixed and known in advance. (View Highlight)
  • (View Highlight)
  • At 27B it clearly pays. Compared with the same 27B run with a single pass, the public-suite score rises from 72.1 to 72.5 and our expected Full score from 72.1 to 73.3, for a median latency of 112 ms instead of 83 ms. (View Highlight)
  • At 9B the gain is smaller but statistically reliable on our held-out evaluations, so the 9B ships with it. (View Highlight)
  • At 2B recurrent depth added about one point on our held-out evaluations but raised latency from 18 ms to 28 ms. For a model whose job is to be fast, we didn’t think one point justified 55% more latency, so the 2B ships without it. (View Highlight)
  • One reading is that a second pass can only refine what a representation already contains, so it is worth more to models that have more to refine. We think this is the right axis to keep pushing. Reasoning in tokens spends compute in the output; recurrent depth spends it in the representation, which is where a decision model does its work. (View Highlight)
  • The Full score combines hidden same-skill tests (60%) with hidden new-domain tasks (40%). We can run the public suite but not the hidden sets. The two are correlated, but they are not interchangeable. On the current leaderboard, models with similar public scores can sit far apart on Full. The gap is widest for small models and for the new-domain tasks, which is why every small model in our table scores much lower on Full than on the public suite. (View Highlight)
  • GLiDE can pick from a list of options, return a yes/no probability, or give a rating on a scale you define. You can combine these question types in one request to make several decisions about the same input; each question is evaluated independently. Recurrent Looped GLiDE also accepts requests that include images. (View Highlight)
  • GLiDE 0.4B is for very high-volume filtering and routing, where 7 ms and under 1 GB of memory matter more than the last few points of accuracy. (View Highlight)
  • GLiDE 2B is the default for most classification and routing. At this scale, latency is dominated by fixed overhead rather than model size, so the 2B is as fast as the 0.8B and noticeably stronger. Choose the 0.8B when memory is the binding constraint. (View Highlight)
  • GLiDE 9B is for decisions that depend on judgment rather than surface patterns, such as policy, escalation and grading. It fits on a single 24 GB GPU. (View Highlight)
  • GLiDE 27B is for the hardest decisions and for requests with images, when a tenth of a second is affordable. (View Highlight)
  • A support system, for example, can ask GLiDE to identify a ticket’s intent, assess whether it needs escalation and assign a priority, and then use those structured answers to route the ticket and flag cases for review. Because the same questions work across the family, the most reliable way to choose a size is to run your own traffic through two adjacent sizes. Look at which tickets each one misroutes or fails to escalate, and weigh that against latency and memory. (View Highlight)