In-House Inference
The AI that maps your code
just built its own engine.
Windsurf's Codemaps, which reads a codebase and turns it into a map, just revealed a number it had never published before: processing speed. With the in-house model SWE-1.6, paid-tier generation now hits up to 950 tokens/sec. For engineers reading monorepos or legacy code every day, that changes the actual quality of the wait.
The one number Windsurf
never talked about
Codemaps has AI read an entire codebase and visualize it as a hierarchical map. But the number that matters most in practice — processing speed — was never written down anywhere, until now.
Windsurf's Codemaps has AI automatically trace a repository's call graph, cross-file dependencies, and execution order, presenting it as a "map" of code that's easy to get lost in at scale. Per Cognition's official blog, generation offers a choice between a speed-first Fast mode and an accuracy-first Smart mode.
For a chat assistant, a slightly slow response to one question isn't fatal. But what Codemaps does is scan an entire repository, and in monorepos with thousands to tens of thousands of files, latency compounds directly. The fact that the vendor never disclosed a speed number was itself a weakness of the feature.
Even an AI that reads code
lives or dies on not making you wait.
Codemaps now picks between
two brains, every run
Speed gets you the in-house SWE-1.6; accuracy gets you Claude Sonnet 4.5. The design switches based on what you need.
Open the repository
Pick a target repository in Windsurf, and Codemaps starts scanning file structure and dependencies.
Choose Fast or Smart
Speed-first means the in-house SWE-1.6; accuracy-first means Claude Sonnet 4.5. You can switch per task.
Get the hierarchy map
Call graphs, cross-file dependencies, and execution order come out as a visualized map you can jump into code from at key points.
Faster isn't the whole story —
it also loops less
Per Cognition's own announcement, SWE-1.6 doesn't just get faster — it cuts the number of back-and-forth turns needed to finish a task.
Cognition officially announced SWE-1.6 in two tiers: a free tier at 200 tokens/sec and a fast tier at 950 tokens/sec. What's more interesting than the raw speed bump is the company's claim that SWE-1.6 matches its previous Preview model's SWE-Bench Pro score while needing roughly 40% fewer assistant turns to get there. The technical detail behind that: a length penalty added during training discourages needlessly long trajectories, cutting down on the looping and overthinking that used to pad out those extra turns.
Calling out to a general-purpose frontier model on every request makes this kind of speed hard to reach in principle. Only by owning dedicated hardware paired with a dedicated model can a vendor hit inference speeds tuned for code analysis's real workload — continuously processing large volumes of tokens. That structural fact is why agentic coding tools are increasingly investing in their own in-house models.
Who this actually helps
Same feature, wildly different payoff depending on your daily workload.
Monorepo engineers
Anyone who routinely parses monorepos with thousands to tens of thousands of files. Faster regeneration compounds directly into real time saved.
Legacy code maintainers
Investigating old codebases with lost documentation means lots of back-and-forth between exploring and regenerating maps. A faster model shortens that cycle.
Solo / lightweight developers
For a personal project with a few hundred files, generation already finishes in seconds. This is the group least likely to feel SWE-1.6's benefit.
Speed or accuracy — which do you pick?
| Fast (SWE-1.6) | Smart (Claude Sonnet 4.5) |
|---|---|
| In-house model, up to 950 tokens/sec | Anthropic's frontier model |
| Built for routine full-monorepo scans | Built for complex architecture analysis where accuracy comes first |
| For repeated Codemap regeneration | For first-pass orientation and untangling intricate dependencies |
What happens next,
and what not to overlook
Coding agents and IDE-integrated tools building their own fast in-house models won't stop with Windsurf. In use cases where latency directly shapes the experience — in-editor code analysis, real-time completion — a dedicated hardware-plus-model pairing tends to beat calling out to a general-purpose frontier model on every request. If you run monorepo or legacy-code analysis daily, the sensible move is to measure Fast mode's generation time on your own repository first, then judge whether the accuracy gap versus Smart mode is acceptable. For small personal repositories, wait times were already short, so there's little urgency to switch.
It isn't all upside, though. SWE-1.6 is, first and foremost, a model optimized for speed, and the fact that Codemaps still keeps Claude Sonnet 4.5 alive as its Smart mode is itself evidence that complex design decisions and intricate dependency tracing still need a general-purpose frontier model's accuracy. Don't take a map generated by the fast model at face value — running a Smart-mode check before an important decision is the more realistic workflow. It's also worth noting that Codemaps is a single-vendor feature: the more you lean on the in-house model, the less certain it is that an equivalent speed could be reproduced on another tool if you ever left Windsurf.