Sherlock Alpha and Sherlock Think Alpha just appeared on OpenRouter with almost no announcement. They look like xAI models, likely Grok 4.20 builds, and from early testing they sit in a familiar spot: noticeably better than Grok 4 and Grok 4 Fast, but not a new tier of capability.
So the real question is not whether Sherlock is good. It is. The real question is where it fits in a stack that is about to include Gemini 3 and the next round of GPT and open source models, and how much weight you should give to whatever benchmark charts start circulating.
The biggest upgrade is that it’s got a 1.8 million token context window, which isn’t quite as big as Grok 4 Fast, though it might be when it’s released. However, it is much larger than all competing models, even Gemini at 1 million.
What Sherlock Probably Is: Grok 4.20, Not A New Species
xAI has a pattern: drop new models on OpenRouter quietly, label them with Alpha, and let the community figure out what they actually are. We saw that with Quasar Alpha and Optimus Alpha. Sherlock Alpha and Sherlock Think Alpha follow the same playbook.
The working assumption right now:
- Developer: xAI
- Underlying family: Grok 4.20
- Release style: Stealth models on OpenRouter, no big public launch yet
That lines up with previous xAI drops on OpenRouter, which is one of the reasons I track that ecosystem so closely. I already use OpenRouter heavily in my own projects and wrote about building around it in AI Dashboard Update: A Central Hub for Artificial Analysis, OpenRouter, fal and More.
The rough model story looks like this: Grok 4 laid the base, Grok 4 Fast focused on speed, Grok 4.20 tightens the internals, and Sherlock is the public surface for that internal round of tuning. No new modality, no wild new feature — just a more refined Grok.
How Much Better Than Grok 4 Are They Really
From the testing I have done so far, plus what I have seen in community reports, Sherlock Alpha and Sherlock Think Alpha look like solid Grok 4.20 refinements.
Roughly where they land relative to previous xAI models:
My rough capability scores, based on early hands-on use and vibes. Higher is better.
Where you are likely to feel the upgrades:
- Reasoning and consistency: Sherlock feels a bit steadier on multi step prompts than Grok 4, with fewer wild tangents and fewer outright misses on simple constraints.
- Coding: Tests so far suggest modest gains in code quality and adherence to instructions compared to Grok 4 Fast, especially for small to medium size tasks where you care about following the spec more than raw speed.
- Long prompts and messy instructions: It holds context slightly better, which is what you would expect from an internal architecture bump like 4.20.
Where you probably will not notice much difference:
- New skills: It does not suddenly gain strong new modalities or agent style autonomy on its own. If you care about agents, you are still building that layer yourself, which I wrote about in When Does a Chatbot Become an Agent? Chat Interface vs AI Autonomy.
- Massive context or exotic features: This is not a 2 million token context shock on top of a reasoning breakthrough. It is a tighter Grok.
- Human feel: It still reads like a Grok family model. If you did not like Grok 4’s tone and style, Sherlock will not suddenly turn into a different personality.
So if you already like Grok 4, Sherlock is the safe new default to try. If you were hoping for something that suddenly competes with the absolute top end on every task, that is not what this is.
Sherlock DashAlpha vs Sherlock Think Alpha: How I Would Slot Them
The nice part of the split is that OpenRouter users get two slightly different knobs to turn without having to learn a whole new system.
- Sherlock Dash Alpha: Treat this as the general Grok 4.20 default. Use it for chat-style queries, light coding, content drafting, and anything where you want Grok’s style but with sharper reasoning than Grok 4.
- Sherlock Think Alpha: This is the slower, more patient version. Reach for it when you care about multi step reasoning, planning, or more structured outputs and when extra latency is acceptable.
This mirrors a pattern across other stacks. OpenAI has Instant vs Thinking in the GPT-5.1 family. I wrote about how I split those roles in GPT-5.1 Instant and Thinking: What’s Actually New and What I’m Watching. Sherlock Alpha and Sherlock Think Alpha fit neatly into that same mental model.
In practice, I expect most people to wire Sherlock Alpha into their general router and reserve Sherlock Think Alpha for the small percentage of calls where extra depth actually moves the needle.
Will Sherlock Count As A Frontier Model
There is a separate question that has nothing to do with raw technical quality: does the community treat Sherlock as a frontier model at all.
That label is social, not formal. And timing matters a lot.
Gemini 3 is expected to arrive very soon. I have already covered some odd behavior that suggests Google has been running Gemini 3 style checkpoints behind the scenes in Is Gemini 3 Secretly Live? Canvas Mode Discrepancies Fuel Speculation and Examples from Pre-Release A-B Testing of Gemini 3 Checkpoints.
If Gemini 3 hits public APIs before Sherlock gets a proper launch, Sherlock will be an incremental Grok update that happens to score well, not the new bar everyone optimizes for. Even if benchmarks have Sherlock near the top on a few leaderboards, the attention will be on Gemini 3 and the next GPT and Claude rounds.
That is the reality of how people pick models now. The model that feels obviously new in daily use gets the “frontier” slot in everyone’s head, and everything else gets compared to it, even when another model quietly matches or beats it on charts.
Benchmarks Are Helpful, But They Lie By Omission
I like benchmarks for one thing: rough sorting. They can tell you if a model is completely off the pace or broadly in the right cluster.
Beyond that, they are easy to game and often out of sync with real workloads. Labs can train directly on the patterns benchmarks expect. Papers can cherry pick which tests to highlight. Entire research projects still treat single benchmark scores as the whole story. I wrote about this problem around GPT 4 in 16,800 Papers Are Still Using GPT-4 In 2025. That’s A Problem.
Sherlock is a good example of why you should be skeptical. It could rank very high on a reasoning board and still feel like a slightly better Grok 4 in normal use. That is not bad. That is just not the kind of jump people imagine when they see a new bar on a chart.
So if you see Sherlock posting impressive numbers, treat them as a signal that it belongs in your test rotation, not as proof that you must rewrite your stack around it.
A simple way to keep benchmarks in their place:
- Use public leaderboards to build a short list.
- Run that short list on your own prompts, agents, and automations.
- Pick based on cost, latency, and error profile, not just a single score.
Sherlock will likely clear that first filter easily. The second step is where you find out whether it stays in your router long term.
Where Sherlock Fits In An OpenRouter Stack
OpenRouter is turning into the place where model routing actually matters. You pick from GPT, Gemini, Claude, xAI, open source, and you decide which model gets which job. I wrote about that dynamic in GPT-5.1 Family on OpenRouter: API Access, Pricing, and Which Model To Use and again when looking at multi model pipelines.
In that context, Sherlock looks like this:
- For Grok users: Treat Sherlock Alpha as the new default general Grok, and Sherlock Think Alpha as the more reasoning heavy version you call when you need better planning at higher latency and cost.
- For router setups: Add Sherlock next to your GPT 5.1 and Gemini routes as an extra option for reasoning heavy calls, then watch which model wins on your actual tasks.
- For experimentation: If you are running A or B tests across several closed models, Sherlock deserves a slot simply because it is better than Grok 4 without changing your integration story.
You do not need to rebuild your stack for Sherlock. You simply give it a lane in your router and let traffic tell you whether it deserves more load.
How To Sanity Check Sherlock In Your Own Workflows
If you want to see quickly whether Sherlock is worth keeping, you do not need a giant evaluation harness. A small, focused test set is enough.
- Take 10 to 20 prompts that currently go to Grok 4 or Grok 4 Fast.
- Send them to Sherlock Alpha and compare outputs side by side, with a simple 1 to 5 score for usefulness.
- Repeat the same set on Sherlock Think Alpha for the prompts that require more reasoning.
- Compare to your current top model on the same tasks, whether that is GPT 5.1, Gemini, or Claude.
If Sherlock reliably scores higher than Grok 4 on that small set, move more traffic over. If it only matches Grok 4, you still might keep it around as a backup lane inside OpenRouter, but there is no reason to chase it as a primary model.
This is the same pattern I use when new GPT-5.1 variants appear on OpenRouter. The model that matters is the one that wins on my prompts at a price and latency I can live with, not the one that dominates a benchmark screenshot.
Practical Advice: Who Should Try Sherlock Now
If you are trying to decide whether to wire Sherlock into your system right now, here is how I would think about it.
- Already using Grok 4 or Grok 4 Fast: Switch some traffic to Sherlock Alpha. It should be a strict upgrade for most general tasks.
- Heavy on OpenRouter experimentation: Add Sherlock Alpha and Sherlock Think Alpha into your evaluator flows and compare them against your current top picks.
- Waiting on Gemini 3 or the next GPT update: You can safely treat Sherlock as a side grade to test while you wait. It may win some tasks, but it is not the strategic anchor model that decides your whole architecture.
The pattern here matches what I have seen across recent model waves, including GPT 5.1 Instant and Thinking, which I broke down in GPT-5.1 Instant and Thinking: What’s Actually New and What I’m Watching. Most releases are incremental. The rare big jumps are obvious when you use them.
Sherlock fits the incremental bucket: a solid Grok upgrade, worth testing, not a reset of the field. Benchmarks will probably flatter it. Real workloads will tell you how much it actually matters.
