DeepSeek V3.2

With an overall score of 72.65%, DeepSeek V3.2 presents itself as a cloud Open Weights model with two clear instincts: it reasons tidily, writes usable code, and comes across as more disciplined overall than its low API costs might suggest. The Speed Profile badge reads Real-Time Tool Expert, at 39.14 tokens per second via DeepSeek Cloud — fast enough for interactive work, but not in the absurd high-speed league of some specialized cloud infrastructures. As a generalist Frontier model with a Coder focus and MoE architecture, that’s the right blend of breadth and technical sharpness, just without the final authority of a true top-tier model. Sovereign Risk: HIGH — DeepSeek is based in China, subject to Chinese jurisdiction including the National Security Law, and for European enterprises that’s not a footnote but a procurement problem.

Header Grades: Stability and Reliability

The first good news is mundane but important: DeepSeek V3.2 did not fail once during the benchmark. For a cloud Open Weights model, that’s not a given — it’s a genuine practical value. Zero timeouts here doesn’t mean the model is theoretically elegant; it means the API operation concretely appeared reliable. Anyone looking to deploy it in agent chains or automated workflows gets a usable tool, not a dice roll.

The second piece of news is less flattering, but still in the green. In five percent of all requests, response time reached 53.97 seconds. That’s still interactive, but no longer nimble. The Real-Time Tool Expert badge still fits: DeepSeek V3.2 is suited for tasks where users can wait for a usable result without losing their train of thought. The measured 39.14 tokens per second should be read explicitly as a performance figure for the DeepSeek Cloud, not as an abstract property of the model itself. With cloud Open Weights, speed is always infrastructure policy expressed in numbers.

Architecture and Classification

The metadata says a lot about this model’s character, and this time it aligns remarkably well with observed behavior. DeepSeek V3.2 is classified as General and Coder, primary use case Generalist, size class Frontier, architecture Mixture of Experts. In plain terms: it’s a broad general-purpose model that has been noticeably trained for technical execution and programming tasks. And because it’s an MoE system, the relevant number isn’t the 671 billion total parameters but the 37 billion active parameters per token. That’s the figure against which its performance should be measured.

This is the critical calibration point. DeepSeek V3.2 is not a monolithic giant moving its full mass with every step. It works selectively, efficiently, and often with considerable focus. This produces a characteristic profile: good technical specialization, solid reasoning, decent linguistic breadth — but not the same depth everywhere. Anyone who automatically expects universal excellence from a Frontier label is confusing a marketing category with actual active capacity.

Code Quality and Security: Technically Strong, but Not Infallible

In the code and security domain, DeepSeek V3.2 shows its real comfort zone. The Code Quality Audit score of 70.84 is not a standout, but it’s a clear indicator of substance. Particularly strong: in a security audit, the model identified all 19 vulnerabilities that the reference standard also found. That’s not a minor hit — it’s a reliable signal that DeepSeek V3.2 scans attack surfaces systematically rather than just listing a few usual suspects.

The weakness lies not in detection but in classification. A particularly telling case is the mischaracterization of a profile update vulnerability: what is fundamentally an IDOR — an authorization flaw through insecure object reference — was framed by the model as a kind of “secondary SQL injection” and additionally underestimated in severity. This is precisely where solid audit craft diverges from genuine security maturity. The model sees the open door, but doesn’t always correctly name why it’s open or how serious it can become in combination with other vulnerabilities.

Countermeasures also lack precision in places. For the path traversal fix, a basename()-style reflex isn’t enough; the more robust mitigation through path validation remains underexplored. For mail header injection, the model identifies the problem but delivers only part of the necessary fix. These gaps aren’t catastrophic. But they’re exactly the kind of detail by which a security team recognizes whether it has a clever assistant or a reliable audit engineer in front of it.

On the positive side: formal discipline. The required Markdown table was delivered cleanly, without preamble and without ornamentally inflated follow-up. This fits the Coder classification. DeepSeek V3.2 works here like a developer who understands that formatting requirements aren’t decoration — they’re part of the job.

CLI and Tool Proximity: Solid, but Not Dominant

The CLI score of 82.67 and the Tool Use score of 60.0 paint a somewhat asymmetric picture. In clearly defined command-line and DevOps-adjacent tasks, DeepSeek V3.2 is well usable. The Real-Time Tool Expert Speed Profile badge didn’t come from nowhere. The model is fast enough, structured enough, and precise enough not to be a nuisance in technical workflows.

What shouldn’t be made of this is a heroic narrative. Tool proximity here is more operational competence than strategic excellence. DeepSeek V3.2 comes across in this area like a good technician with a neatly organized toolbox. Not like the architect who rethinks the entire construction site.

Reasoning and Logic: Correct, but Rarely Majestic

In reasoning, DeepSeek V3.2 reaches 73.93. That’s a solid result, especially given that it must manage without a dedicated thinking mode. The model carries the tags General, Coder — not Thinking. Accordingly, one should not expect sprawling chains of thought or philosophical deep dives. What to expect instead is sober, correct, functional inference. That’s exactly what it delivers.

A good example is the classic guard logic problem. DeepSeek V3.2 solves it correctly, explains the mechanism accurately, and even cleanly dismisses a weaker alternative approach. That’s more than mere answer production. At the same time, the presentation remains noticeably more concise and less didactic than the best reasoning models. What’s missing is the additional structure, the visual decomposition, and the conceptual compression that turn a correct answer into an excellent one.

This isn’t a takedown — it’s a clean classification. DeepSeek V3.2 thinks reliably enough for everyday logic, technical analysis, and structured problem-solving. But it doesn’t think with the intellectual generosity that also takes care of the last quiet intermediate steps for the user. Ask it for reasons and you get answers. Expect a small masterclass and you get a solid working note instead.

UX Writing: Useful, but Not Senior-Level

With 70.51 in UX Writing, DeepSeek V3.2 shows the classic ceiling of many coder-adjacent generalists. The responses are structured, practical, and substantively usable. In an onboarding optimization case, the model delivered a clean analysis and concrete improvement suggestions. What was missing was psychological depth: no meaningful theoretical grounding, no robust validation logic, barely any reference to named mechanisms or research.

The result is therefore not bad, but incomplete. DeepSeek V3.2 writes here like someone who has seen many good products, but not like someone who can systematically dissect user behavior. For teams that want better microcopy quickly, that’s often enough. For roles with senior expectations, research proximity, or strategic UX responsibility, it visibly falls short.

Content Transformation: Good Production, Frustrating Language Discipline

In the Content Transformation module, DeepSeek V3.2 lands at 73.12. Substantively, the result is respectable. The model can restructure scripts, set timing markers, insert visual cues, and place production cues such that the output actually looks like workable material. Particularly with video-style formats, the output feels usable rather than sterile.

Then it makes a mistake that costs money immediately in practice: in a task explicitly requiring German, DeepSeek V3.2 wrote the main body in English. This is not a matter of taste and not a minor slip. It’s a clear violation of an explicit language instruction — an instruction-following failure.

In a task within the Content Transformation module, the model ignored the explicit language instruction and responded in English instead of German. The system applied an automatic rule-based penalty for this. The substantive quality of the response becomes secondary at that point, because the penalty applies regardless of the response’s other utility.

This language error is not a minor side note, because it occurs precisely in a module that is frequently used in production-adjacent environments: marketing, training, video, internal communications. There, the target language is not a nice extra — it’s a contractual element of the task. DeepSeek V3.2 can do the craft, but under combined constraints of language, format, and style, it apparently loses language consistency first. Not the end of the world, but exactly the kind of mistake that becomes embarrassing without human final review.

Documentation Quality: Usable, but Missing the Last Layer

The documentation score of 70.81 fits well into the overall picture. DeepSeek V3.2 can explain technical content, structure it, and bring it into a format that is usable for developers or product-adjacent teams. What it more frequently lacks is the additional layer of context, reasoning, and validation that separates very good documentation from merely decent documentation.

It doesn’t write confusingly, erratically, or artificially inflated. But it often writes with the impulse to complete the task rather than to refine it. For internal wikis, initial documentation, and pragmatic handoffs, that’s perfectly fine. For public-facing, particularly well-connected, or heavily curated documentation, you’d want to sharpen things further.

Cultural Intelligence: Functionally Sound, Stylistically with Minor Losses

At 71.72, Cultural Intelligence is not a standout subject, but not a problem area either. DeepSeek V3.2 reliably removes toxic or inappropriate phrasing, works in a more gender-inclusive manner, and adheres cleanly to language requirements. In the reformulation of a problematic job posting, the model handled the core task correctly: aggressive combat language removed, bias reduced, tone defused.

What’s missing is nuance. The reference standard was warmer, more inviting, and rhetorically smoother. DeepSeek V3.2 solves the task functionally, but without particular charm. This is typical of a model whose strength lies more in technical execution than in linguistic persuasion. For HR-adjacent rough drafts, that’s fine. For communication that needs to be both inclusive and inspiring, there’s room to grow.

Token Economy and Cost Profile

Here DeepSeek V3.2 earns explicit praise. Across all measured modules, the model behaves token-economically. No module exceeds the expected verbosity range. On the contrary: CLI, Code Quality, Content Transformation, Cultural Intelligence, Documentation, and UX Writing all come in below the fleet median. The model doesn’t talk to simulate compute time. It generally produces roughly as much text as is needed to solve the task.

Especially for a cloud Open Weights model priced at $0.14 per million input tokens and $0.28 per million output tokens, this matters. Those low costs would be worth little if the model ate up every advantage with unnecessarily long responses. It doesn’t. Benchmark costs of $0.014 for the complete run speak clearly: DeepSeek V3.2 is not only cheap, but disciplined enough to make the price advantage practically effective.

Data Privacy and Data Sovereignty

On data privacy, DeepSeek V3.2 is not a neutral infrastructure component — it’s a geopolitical topic. The calculated Sovereign Risk is HIGH. Rationale: the model comes from DeepSeek in China; the provider is subject to Chinese law, including PIPL, CSL, DSL, and the National Security Law. For users in Germany and the EU, this represents a relevant third-country transfer risk without an adequacy decision.

The data location is listed as China plus EU/US cloud partners. That doesn’t simplify things — it makes them more diffuse. Even if parts of the processing run through partner infrastructure, the legal frame remains Chinese. A publicly disclosed GDPR DPA is not available. For organizations with genuine GDPR compliance requirements, that’s not a cosmetic flaw but a concrete procurement obstacle. The data retention period is listed as -1 days — effectively unclear. That too is insufficient for regulated environments.

There is also a separate Weights Provenance Risk: HIGH. This is relevant here because the deployment situation and model origin point in the same direction. The provider host and the model’s origin carry the same sovereignty problem. In short: for private or experimental use, this may be calculable. For organizations with compliance, confidentiality, or customer data obligations, it’s a very real red line.

Conclusion

DeepSeek V3.2 is an interesting model, precisely because it doesn’t play the role of a wonder child. It reaches 72.65%, operates stably via the DeepSeek Cloud, responds at 39.14 tokens per second — briskly enough for productive interaction — and combines low costs with solid technical capability. As a generalist Frontier model with clear Coder DNA and MoE architecture with 37 billion active parameters, it delivers the most where structured analysis, code comprehension, and operational tool proximity are required.

Its weaknesses are not mysterious — they’re cleanly visible. Security detection is good, but not always precise enough in categorization and remediation. Reasoning is correct, but rarely elegantly articulated. UX and language tasks often turn out usably, but don’t reach the depth or stylistic warmth of the better specialists. And the English slip in a task explicitly requiring German is exactly the kind of compliance failure that in real workflows hurts not theoretically, but immediately and practically.

The recommendation is therefore differentiated: well suited for technical assistance, code reviews, preliminary security analysis, documentation drafts, and tool-adjacent automation with human final review. Less suited for highly sensitive enterprise environments, strictly language-bound publishing workflows, and anything that needs to be regulatorily clean. Across all tests, no notable hallucinations. DeepSeek V3.2 is therefore not a bluffer, but an affordable, serious worker with clear strengths and equally clear limits.

This evaluation was generated automatically based on the benchmark data. Model used: GPT 4.5 by OpenAI. The raw data and full methodology are documented in the GitHub project.