what it wasThe fastest autocomplete ever shipped — and that was the whole point.
Supermaven's pitch was latency. Where most completions wait, hedge, then deliver a single token, Supermaven's Babble model returned multi-line suggestions before you finished typing — independent benchmarks put it near 89ms median on React/TypeScript against ~167ms for GitHub Copilot. Its 1M-token context window meant it could weigh your whole codebase, not just the open file, so the suggestions actually fit your patterns. As a typing accelerator it was, genuinely, best-in-class.
- Babble model: proprietary, code-specific inference tuned purely for speed.
- 1M-token context — far past the 'current file + a few neighbors' of most tools.
- Free tier plus a $10/mo Pro plan; Teams at $10/user/mo — cheaper than Copilot Business.
where it wentIt's not a product anymore — it's Cursor Tab.
In November 2024 Anysphere (the company behind Cursor) acquired Supermaven and put its inference pipeline behind Cursor's Tab completion. The standalone editor plugins were officially discontinued on November 30, 2025. If you searched for 'is Supermaven still worth it' the honest answer is: the technology is excellent and still alive, but you now get it inside Cursor's $20/mo product, not as a $10 standalone. For VS Code or JetBrains users who only wanted the autocomplete, that's the migration story — and the reason this review matters less for 'which plugin' and more for 'what was autocomplete ever solving'.
- Acquired by Anysphere/Cursor in November 2024.
- Standalone product discontinued November 30, 2025; tech lives on in Cursor Tab.
- Alternatives people land on: Cursor, GitHub Copilot, Continue.dev, Cline.
the real riskFaster typing, faster mess: the problem moved up a layer.
Autocomplete optimizes the keystroke — the cheapest part of building software. The expensive part is what happens after the code exists: reviewing it, trusting it, maintaining it. 'Vibe coding' — describing software to an AI and shipping what comes out — is exploding, and in a company it becomes a mess fast. Code nobody reads, dependencies nobody chose, a security hole nobody saw, a screen that's red and nobody knows why. A tool that helps you type that code faster doesn't help; it speeds up the part of the problem you didn't have. Supermaven made you faster at the keystroke. Nothing in it makes the result safe to ship.
- Completion answers 'what's the next token', never 'is this fit for production'.
- Faster generation with no verification just grows the unreviewed pile faster.
- In a team, AI-written code that no structure checks becomes debt and risk by default.
the methodThe Digital Native Method: describe intent, verify everything, then ship.
The way out isn't a faster autocomplete — it's structure. A Product Owner describes the intended outcome on the live product. A Tech Lead encodes the rules once: architecture, conventions, your company's standards, security. Agents implement inside those rules, and deterministic gates — lint, types, tests, security scan — run before anything reaches production, through your own GitHub. You stay in outcome-space; the structure guarantees the code underneath is governed, not freehand. That's the layer Supermaven, and every completion tool, leaves empty.
- Product Owner states the result on the live product, not a ticket full of specs.
- Tech Lead encodes the rules once; every agent boots inside them.
- Gates run before prod — green or it doesn't land — and ship through your GitHub.
the softwareAgentation is the software that makes the method real.
A method on a slide changes nothing — you need the tool that enforces it. Agentation is that tool: you point at your live product, describe what you want, and reviewed, verified code comes back live. Gates can't be skipped, the Tech Lead's rules can't be bypassed, and everything moves through your existing GitHub on your existing AI plan. Completion tools like Supermaven make one developer type faster. Agentation makes a whole team ship AI-built software that's actually safe to keep.
- Describe the outcome; receive a reviewed, verified result — not a diff to babysit.
- Encoded standards and unskippable gates between you and the model.
- Runs through your GitHub, on your AI plan — we never see your code.
cocoricoFrench team, EU stack, sovereignty where it's actually winnable.
Agentation is built by a French team. We're realistic: nobody is sovereign over the frontier models — Claude, GPT and the rest are American. But the orchestration layer on top of them, the part that decides how the model is used, what it's allowed to ship, where the data lives — that is winnable, and it's most of the value, because with just a raw model you don't actually build much. Our hosting is in the EU (Hetzner, Germany), data is in the EU (Supabase), your code stays in your GitHub, and the whole thing is GDPR-aligned by design. Speed was Supermaven's edge; trust and sovereignty are ours.
- French company, French team — orchestration built in Europe.
- EU hosting (Hetzner, Germany), EU data (Supabase), GDPR by design.
- Sovereign on the tool that orchestrates the model — the part that's actually winnable.
FAQIs Supermaven still available in 2026?
Not as a standalone product. Anysphere (Cursor) acquired Supermaven in November 2024 and discontinued the standalone plugins on November 30, 2025. The technology now powers Cursor's Tab completion, so you get it inside Cursor (around $20/mo) rather than the old $10/mo standalone. For VS Code or JetBrains, common alternatives are Cursor, GitHub Copilot, Continue.dev and Cline.
Was Supermaven actually faster than GitHub Copilot?
Yes — speed was its whole identity. Its Babble model returned multi-line completions with very low latency (independent benchmarks put it near 89ms median on React/TypeScript versus roughly 167ms for Copilot), and its 1M-token context window let it consider far more of your codebase than tools that only see the open file. As a typing accelerator it was best-in-class. What it didn't do is verify that the code it helped you write is safe to ship.
If I loved Supermaven's speed, what should I use now?
For pure inline completion, Cursor Tab is the direct successor (it runs Supermaven's pipeline); Copilot, Continue.dev and Cline are the usual alternatives. But if your real goal is shipping AI-generated code in a team without it turning into debt, that's a different layer than autocomplete: you want a Tech Lead encoding the rules and gates verifying every change before prod. That's what Agentation provides on top of the model.
Why does a 'review' of an autocomplete tool keep talking about shipping code?
Because autocomplete optimizes the cheapest part of building software — the keystroke. The expensive, risky part is everything after the code exists: review, trust, maintenance, security. Faster generation with nothing verifying the output just grows the unreviewed pile faster. So an honest review has to name the gap: completion never answered 'is this safe for production', and in a company that gap is where the real cost lives.
Is Agentation a code-completion tool like Supermaven?
No. Completion tools make one developer type a little faster. Agentation is the layer above: you describe the outcome on your live product, a Tech Lead's encoded rules constrain the agents, and deterministic gates (lint, types, tests, security) verify everything through your GitHub before it ships. Different problem — not typing speed, but trustworthy delivery of AI-built software across a team.
Where does Agentation run, and who sees my code?
Agentation is built by a French team with an EU stack: hosting on Hetzner in Germany, data in Supabase in the EU, GDPR-aligned by design. Your code stays in your own GitHub and runs on your existing AI plan — we never see it. We don't claim sovereignty over the models themselves (Claude, GPT are American), but the orchestration layer that governs how those models are used is European, and that's where most of the practical value sits.