CodeMender vs Qoder Cantus: The Security Fixer vs the Coding Engine

In 2023, a single heap buffer overflow in libwebp — the image-decoding library used across a large slice of the web — became CVE-2023-4863 and, in the hands of NSO Group, a zero-click iPhone compromise. Two years later, Google DeepMind ran its code-security agent CodeMender over that library and applied Clang's -fbounds-safety annotations across it, arguing the whole bug class is now "unexploitable forever." That is the kind of job CodeMender was built for. The model it gets compared against here, Qoder Cantus, is the opposite shape of AI-on-code: Alibaba's Qoder IDE quietly made it the "top-tier" model in its selector on July 19, 2026, with exactly one sentence of public documentation and a 3.2x credit multiplier. One of these two ships receipts for what it does to your code. The other ships a billing coefficient.

They are both "an AI agent working on a real codebase," and both landed inside a two-week window this summer — but that's nearly where the similarity ends. CodeMender is a managed security product that finds, verifies, and patches vulnerabilities with a human approving every change. Qoder Cantus is an in-IDE coding engine aimed at long, autonomous tasks, with no API, no weights, and no published benchmarks. This piece walks through what each one actually is, what evidence each side has published, what they cost, and who should pick which.

Two agents, two different jobs

CodeMender began as Google DeepMind research, previewed on October 6, 2025, built on Gemini Deep Think reasoning wrapped in program-analysis tooling: static and dynamic analysis, differential testing, fuzzing, and SMT solvers, plus a multi-agent system where an LLM-based judge diffs original vs. modified code and flags functional regressions. On July 22, 2026, Google Cloud turned it into a managed enterprise product in public preview, available through the Gemini Enterprise Agent Platform and as a core component of Google AI Threat Defense. It runs in three stages: scan (top vulnerability classes across C/C++, Go, Java, Python, Ruby, Rust, and TypeScript), verify (it builds and runs a proof-of-concept exploit in a customer-managed sandbox to prove the bug is real and cut false positives), and remediate (it generates a tested patch as a diff, checked by an LLM judge, then a human approves it before anything is committed).

Qoder Cantus shipped on July 19, 2026, inside Alibaba's Qoder ecosystem — Desktop, JetBrains plugin, CLI, Cloud Agents, and Web/Mobile. There was no launch post, no technical report, no benchmark table. The entire official description is one line: "Qoder's built-in top-tier intelligent model, excelling at extended autonomous task execution." In practice that means long-horizon, multi-step coding jobs where the model keeps working with limited hand-holding. It is reachable only through Qoder — no public API, no downloadable weights, no way to call it from any other tool.

So the first thing to say about this matchup is that you don't choose between these two in a dropdown. CodeMender is a security product you adopt; Qoder Cantus is a model you encounter inside an IDE you already subscribe to. What they compete for is the same thing: a team's willingness to let an AI agent operate on production code. That's the budget line both of them are really attacking.

The evidence gap is the whole story

The cleanest way to separate these two is to ask what each has actually published about its own behavior.

CodeMender comes with receipts — all Google-reported, and worth labeling as such since none of it has been independently reproduced. During its first six months as a research project, DeepMind says it upstreamed 72 security fixes to open-source projects, some in codebases as large as 4.5 million lines, with every patch reviewed by human researchers before submission. The libwebp -fbounds-safety work is the flagship example. For the security-tuned model that now runs inside it, Gemini 3.5 Flash Cyber, Google reports 55 unique confirmed vulnerabilities found in Chrome's V8 JavaScript engine, versus 47 for mainline Gemini 3.5 Flash and 36 for Anthropic's Claude Opus 4.6 — including 10 issues that no other model in the test caught. Google also reports competitive results on CyberGym, its Big Sleep team's benchmark of real-world vulnerabilities, and results stronger than mainline models on Big Sleep evaluations over the Chrome and Safari codebases. All of this is vendor-reported; treat the specific numbers as Google's claims until someone runs them independently — and note that Gemini 3.5 Flash Cyber is gated to governments and trusted partners, so independent reproduction isn't going to happen soon.

Qoder Cantus has published nothing. No parameter count, no context window, no architecture, no training details, no benchmark scores, no independent reviews, and no entry on Artificial Analysis, LMArena, Hugging Face, or arXiv. And this isn't a documentation gap — it's structural. Cantus has no API and no weights; it's a dropdown entry inside a desktop IDE. You can't benchmark a model you can't call. That's a permanent property of how Qoder chose to ship it, and it means every capability claim about Cantus is Qoder's unverified word.

One honest way to frame it: CodeMender's risk is that its numbers are flattering. Qoder Cantus's risk is that there are no numbers at all.

What it costs, converted into one currency

The two pricing models aren't even the same shape of money.

CodeMender has no published GA price. In preview, it's available to Gemini Enterprise Agent Platform customers, and Google says that once it exits preview it will be consumption-based on token usage, with model choice as the cost lever — run it on Gemini 3.5 Flash for cheaper scans, a larger model for deeper ones. So today, CodeMender is priced as an enterprise conversation, and the honest line is "ask Google."

Qoder Cantus is billed on Qoder's credit system, and the conversion is something Qoder never shows you. On the Pro plan, $20 buys 2,000 credits, so one credit is worth about $0.01 (on Ultra the ratio is the same; overflow top-ups are worse at $0.0133). Qoder publishes per-task credit estimates at its ~1.0x Auto baseline and then a per-model multiplier on top — and never multiplies them together in a worked example. Cantus's multiplier is 3.2x, the most expensive in Qoder's selector, and the 50%-off launch promo that briefly made it 1.6x expired July 31, 2026. So as of August 1, a typical Editor agent-mode turn (~12 baseline credits) costs about $0.38, a Quest task (~50 baseline credits) runs about $1.60, and a Quest in Experts mode (~75 baseline credits) about $2.40.

So the honest comparison on price is: one side is "no public price yet, token-based when it launches," the other is "a per-task meter where a single autonomous run is a buck or two and the meter is calibrated by a multiplier you have to read the docs to decode." Neither is per-token, and neither gives you a unit price you can set against a normal model API. If per-token price is what you need to make a decision, neither of these is the comparison you're looking for.

Who gets to touch your code

The second big divergence is what each product is allowed to do to a repository.

CodeMender is built around restraint. Verification runs in a sandbox the customer manages, patches are generated as diffs and must be reviewed and approved by a developer before any commit, and Google's security posture for the service is explicit: traffic routed through the customer's VPC, data isolation and encryption, and zero retention of source code data. Google's early customers — Salesforce, Robinhood, and Palo Alto Networks among them — describe it as a tool that accelerates the path from validated vulnerability to tested fix, not one that replaces the security team. The dual-use tension is real and visible: the verification stage builds working proof-of-concept exploits, which is exactly why the Gemini 3.5 Flash Cyber variant is gated rather than sold to everyone.

Qoder Cantus sits at the other end of the autonomy spectrum. It's an agentic coding model whose entire selling point is extended autonomous execution — long runs where the model keeps working through a task. That's a different posture toward your code: not "show me a patch and I'll approve it," but "go do the task." Qoder's product documentation covers data handling, but Cantus itself has no published statement analogous to CodeMender's zero-retention, sandboxed-verification, human-approval guarantees. The trade is autonomy for opacity, and teams with sensitive codebases should notice the asymmetry — it's the difference between an agent that proves a bug and shows you a diff, and an agent that just does the work.

The one-way door

There's one more structural fact about Qoder Cantus that matters more than any benchmark: it's the only model in Qoder's own selector that cannot exist outside Qoder.

Open Qoder's model picker and you'll find engines like Qwen3.7-Max (0.5x), DeepSeek V4 Pro (0.5x), GLM-5.2 (0.6x), Kimi-K2.7-Code (0.3x), and MiniMax-M3 (0.2x) — every one of those is a normal API model that lives elsewhere, callable directly, benchmarkable, portable. Cantus is the one-way door: no API, no weights, no exit. Whatever you learn while using it, and whatever work you shape around it, stays in Qoder. If Qoder's pricing changes (as it just did when the promo lapsed), or the model's quality disappoints, there is no path to take it anywhere else — and no way to even compare it head-to-head against an alternative.

CodeMender runs in the opposite direction on the portability axis: you don't get a model you can take anywhere either, because it's a managed service where Google runs the models. But that's the point of it — it's a product, not a model endpoint, and the choice you're making is "adopt a vendor-run security agent," not "pick an engine."

Neither of these, in other words, is a callable model — and that's where a routing platform enters the picture, not as a way to reach these two, but as the way to think about the engines around them. If the reason you're in Qoder is the models, the non-Cantus engines in that same dropdown are available as ordinary API models — and on a router you get them at list price (we pass provider pricing through at 0% markup, so a vendor price cut is live the same day), with automatic failover between providers and a routing DSL to split traffic. You can benchmark them against each other, switch by config change instead of migration, and never pay a credit multiplier to touch a model that's priced per token everywhere else. The subscription is for the IDE; the models don't have to live inside it. And if what you actually need is security remediation, that's a managed-product decision — CodeMender or a comparable service — not a model-routing decision at all.

Wie moet welke kiezen

Pick CodeMender if you're a security or AppSec team with a vulnerability backlog and a need to show work: scans that find real bugs, proof-of-concept verification that kills false positives, tested patches a developer approves before they land, and an enterprise security posture (VPC routing, zero retention) your compliance team can point at. The costs right now are the ones this piece keeps flagging: it's a preview, there's no public price, and the most powerful model variant is gated. But for the "make my codebase measurably safer" job, it is the only side of this comparison that has actually shown receipts.

Pick Qoder Cantus if you're a developer or team already living in Qoder who wants the strongest agentic engine in the IDE for long, autonomous coding tasks and is comfortable with three things: a black-box model you can't benchmark, a 3.2x credit multiplier that just lost its discount, and no way to take the model anywhere else. For "write me a lot of code, keep working on it, and don't make me babysit" inside an IDE you already pay for, it may well be the right tool — just know that every claim about it is Qoder's word, and there's no way to verify.

And if neither fits — if you need a coding model you can call, evaluate, and switch — that's the middle ground neither of these occupies. The engines that sit beside Cantus in Qoder's own picker are ordinary API models, and the reason to have them behind one router endpoint is precisely the choice this comparison can't offer: run more than one, measure them on your own workload, and change your mind without changing your code.