Think-Reason-Learn
Research · Think-Reason-Learn · 9 November 2026

How Think-Reason-Learn works: plain-language checks and a trained scorer

A Think-Reason-Learn model asks yes-or-no questions about an input, has a fast language model answer them, and weighs the answers with a trained scorer.

Browse the models

A Think-Reason-Learn model is a list of plain-language yes-or-no questions about an input, answered by a fast language model and combined by a small scorer trained on real outcomes. The scorer learns which answers matter and how much, so every prediction comes with its reasons: the checks that pulled the score up and the ones that pulled it down.

This post explains how a model is built, what it returns, and how we test it before it goes on the model catalog.

Why not just ask a language model?

You can ask a large language model "will this Show HN post reach 100 points?" and it will give you a number. The number moves when you rephrase the question, and nobody has checked it against what happened to posts like yours. It writes its explanation after the fact, so the explanation may have nothing to do with the number.

A classifier fine-tuned on outcomes fixes the first problem but not the second. It gives you a score and nothing you can act on.

We wanted a score checked against real outcomes, with reasons that are the actual inputs to that score.

Three steps: think, reason, learn

We'll use the Show HN Launch Predictor as the example. It predicts whether a Show HN post reaches 100 points.

Think: write the questions. A reasoning model reads a sample of past posts that did well and posts that didn't, and proposes questions that might tell them apart. "Does the title say concretely what the project does?" "Does the post read like marketing copy?" "Is the project self-hostable?" It proposed 371. We kept the 77 that helped predict the outcome on the training posts.

Reason: answer them. For every post, a fast, cheap language model answers all 77 questions in one call. Each answer is a probability of yes, so "the post reads like marketing copy" might come back as 0.85 for a post full of slogans and 0.05 for one written by a developer explaining what they built.

Learn: weigh the answers. A logistic regression learns from 4,885 posts and their outcomes how much each answer moves the chance of reaching 100 points. "Shows deep technical skill" gets a large positive weight. "Uses buzzwords" gets a negative one. You can read every weight. A post's score is each answer times its weight, added up and turned into a probability.

So nobody writes the reasons after the fact. They are the parts of the sum. When a post scores low, the response lists the checks that pulled it down most, and by how much.

What you get back

Here's a real prediction from the Show HN model for a draft post about a Postgres tool, trimmed to the top reasons:

{
  "model": "think-reason-learn/show-hn-launch-predictor",
  "release": "show-hn-launch-predictor-v1-2026-10-28",
  "output": {
    "outlook": "front-page contender",
    "level_hit_rate": 0.0923,
    "hit_probability": 0.0863,
    "base_rate": 0.016,
    "pulled_up": [
      { "check": "The project demonstrates deep technical skill", "label": "Shows deep technical skill", "answer": 0.68, "effect": 0.396 },
      { "check": "The project is self-hostable", "label": "Can be self-hosted", "answer": 0.8, "effect": 0.329 },
      { "check": "The link goes straight to the thing, not a landing page", "label": "Links straight to the project", "answer": 0.97, "effect": 0.265 }
    ],
    "pulled_down": [
      { "check": "Title length", "label": "Long title", "answer": null, "effect": -0.18 },
      { "check": "The title uses an unexplained, obscure acronym", "label": "Obscure acronym in title", "answer": 0.51, "effect": -0.153 }
    ]
  },
  "common": { "level": "front-page contender", "chance": 0.0923, "base_chance": 0.016, "outcome": "hit" },
  "usage": { "cost_usd": 0.01 }
}

answer is how strongly the answering model said yes. effect is how far that answer moved the score compared with an average post, so a check can pull a score down even when the answer leans yes, if most posts score higher on it. "Title length" has no answer because it's measured, not asked.

Two numbers do most of the work. level_hit_rate is how often past posts at this level reached 100 points: 9.2% for "front-page contender". base_rate is how often any post does: 1.6%. "9.2% against 1.6%" tells you more than a bare score like 0.83, because it compares your post with an average one. It also keeps expectations honest: even at the top level, most posts miss.

The reasons point at what to fix. This draft would likely do better with a shorter title that spells out "CDC".

Every model returns the same common block, so code that reads one model's answer can read any of them.

Cheap and fast enough for a loop

A prediction is one call to the answering model plus a few hundred multiplications. It takes a few seconds and costs about $0.01. That's cheap enough to score every draft an agent writes: twenty versions of a post cost twenty cents. We wrote up how to do that in Give your coding agent a judge.

How we test a model before publishing it

We test each model on cases it never saw, held out the way it will meet new ones in use:

ModelTrained onTested onOur AUCBaseline AUC
Show HN Launch Predictor4,885 posts before June 20261,570 later posts0.820.77 (word matching)
GitHub PR Merge Predictor2,091 PRs to 107 repos36 repos it never saw0.7440.721 (word matching)
GitHub Contributor Rating1,903 PRs to 71 repos903 authors it never saw0.780.77 (track-record numbers)

AUC is the chance that the model ranks a random success above a random failure. 0.5 is a coin flip; 1.0 is perfect.

Every model has to beat a plain baseline on the same data: TF-IDF word matching for text, or simple numbers like an author's past merge rate. If the checks can't beat that, there's no point paying for them.

Look closely at the last row. For contributor ratings, the track-record numbers alone get 0.77, and the checks add very little accuracy. What they add is the explanation: you can see why someone is rated "solid" instead of just seeing a number. We say this on the model's page too.

Each release also ships with golden cases: fixed sets of answers and the score and level they must produce. The runtime replays them before it switches to a new release, and refuses the release if any case comes out different.

What it isn't

  • It finds correlations, not causes. A post that shows deep technical skill reaches 100 points more often. Adding technical words to a post that doesn't show any won't do the same.
  • It sees only what it's given. The Show HN model reads the title, the link's site and the text. It never opens the link, so a great project behind a weak post still scores low.
  • The answers themselves aren't explained. The answering model says "0.85 yes, this reads like marketing" without saying why. What you can inspect is the question and its weight.
  • Taste drifts. In 2024 a GitHub link helped a Show HN post; by mid-2026 it didn't. Models are retrained, and every response names the release that answered, so you can tell which one you got.

Where it comes from

Think-Reason-Learn is built by Vela Research with the University of Oxford. The method grew out of research on predicting startup success from founder profiles, where explanations matter as much as accuracy. The core library is open source: think-reason-learn on GitHub.

Try it

The model catalog lists every model with its inputs, outputs, test results and limits. You can try any model in the browser, or call it with an API key:

curl https://api.thinkreasonlearn.com/v1/predict \
  -H "Authorization: Bearer $TRL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "think-reason-learn/show-hn-launch-predictor",
       "input": {"title": "Show HN: Pgline – a single-binary Postgres CDC tool in Rust",
                 "url": "https://github.com/danadev/pgline"}}'

The Show HN Launch Predictor and the LinkedIn Viral Post Predictor also work through OpenRouter under the same ids. /llms.txt describes the API for coding agents.