From Model Params to Full‑System 'Model+Harness': DeepSeek V4 Pro Agent Engineering Deep Dive

Core Findings

Agent competition has shifted from raw model parameters to a full "model + Harness" system race. DeepSeek V4 Pro (released 13 Aug 2026) and the open‑source DeepSeek Harness (DSH) place a domestic provider on the same infrastructure track as overseas leaders. In cache‑hit scenarios DeepSeek’s input cost is roughly 1/200 of Claude Opus 4.7, creating a 120× price advantage over comparable models.

Technical Details of DeepSeek V4 Pro

Model specifications – 1.6 T total parameters, 49 B active MoE parameters, 1 M context window, 384 K maximum output length. The final version launched silently on 13 Aug 2026 after 111 days of post‑training optimization.

Benchmark improvements after post‑training – DeepSWE rose from 12.8 pts to 62.7 pts, Cybergym from 52.7 pts to 83.3 pts, Terminal Bench from 72.1 pts to 87.9 pts, DSBench‑Hard from 33.6 pts to 67.2 pts (all reported by 36氪). These benchmarks stress long‑chain code modification, environment interaction and tool use.

Three‑layer Agent stack

Model layer : V4 Pro / V4 Flash – task understanding, inference, next‑step selection.

Protocol layer : Responses API – transports inputs/outputs and tool results between client and model; the npm package @deepseek-ai/dsh provides native integration.

Runtime layer : DeepSeek Harness (DSH) – scheduling, plugin loading, session recording, state persistence.

Harness design philosophy – "Agent = Model + Harness". All components (model, tools, Agent loop) are treated as interchangeable plugins. Two composability mechanisms:

Temporal composability – a reversible‑effect system automatically records and rolls back side‑effects when a component is unloaded.

Spatial composability – a responsive co‑effect system lets components declare dependencies that the runtime resolves dynamically.

Cost optimization

Permanent 75 % price cut announced 22 May 2026: cache‑hit input 0.025 CNY/M tokens, non‑hit input 3 CNY/M, output 6 CNY/M (CSDN).

Compared with Claude Opus 4.7 (input $5/M, output $25/M) and GPT‑5.5 (input $1.25/M, output $10/M), DeepSeek is 11.5–28.7× cheaper; in cache‑hit scenarios the gap reaches 120×.

Technical drivers: CSA/HCA hybrid attention compresses KV cache for disk storage, low‑precision FP4 storage with a reduced Top‑K selector, and disk‑cached KV reuse eliminates repeated prefills.

In a 1 M‑token workload V4 Pro uses ~27 % of the FLOPs and 10 % of the KV cache of V3.2; V4‑Flash further reduces to ~10 % FLOPs and 7 % KV cache (Alibaba Cloud Community).

Hybrid pipelines (Pro planning + Flash execution + Pro review) can cut API fees by >60 % for long‑context, multi‑round Agent workflows.

Strategic impact of open‑source Harness – unlike OpenAI and Anthropic, DeepSeek released a model‑agnostic, modular Harness under an open‑source license. Within 24 hours the GitHub repository earned >70 k stars, sparking community discussion about the "Agent black box".

Overseas Agent Engineering Architectures

Claude Code – public TypeScript source contains ~1,884 files and 512 k lines; only ~1.6 % is AI logic, the remaining 98.4 % implements infrastructure (VILA‑Lab). Architecture comprises 7 components across 5 layers, including a 7‑layer security stack, 5‑layer context compression pipeline, 54 built‑in tools, 27 hook events, 4 extension mechanisms and 7 permission modes. Revenue from Claude Code contributed to Anthropic’s ≈ $2.5 B annual income in early 2026.

Key upgrades (May 2026) added:

Dreaming – periodic memory integration that curates and reconstructs session history.

Outcomes – an independent grader validates Agent output against success criteria, preventing false completions.

Multi‑agent orchestration – parallel execution and delegation to sub‑Agents.

OpenAI Agents SDK – evolved from the Swarm framework; core primitives are Agent, Handoff, Guardrails, and Runner (AIWiki). The 15 Apr 2026 update introduced native sandbox execution (GA, Python), model‑native Harness, Subagents (beta), and a planned Code Mode. The SDK emphasizes Agent‑to‑Agent handoff as the primary multi‑Agent collaboration model.

Google ADK 2.0 – open‑source, code‑first framework supporting Python, Java, Kotlin, Go and TypeScript. Core concepts:

Agent – LLM‑driven or deterministic workflow controller.

Workflow Runtime – graph‑based engine with routing, fan‑in/out, loops, retries, state, dynamic nodes and human‑in‑the‑loop.

Task API – structured Agent‑to‑Agent delegation.

A2A protocol – native Agent‑to‑Agent communication.

Google’s cloud stack adds four layers: Intelligence (Gemini 3), Development Framework (ADK), Runtime (Agent Runtime with Sessions, Memory Bank, A2A), and Governance (API Registry + IAM). This enables cross‑vendor Agent ecosystems.

Microsoft Copilot Stack – tightly integrated with the 365 ecosystem. Provides declarative Agents (Copilot orchestrator + model) and custom engines (self‑hosted orchestrator + model). Skills are defined via Markdown files, mirroring the emerging standard used by Claude Code, GitHub Copilot and DeepSeek Harness.

Converging architecture – all three major overseas stacks adopt a three‑layer model + runtime + tool design, confirming that the core engineering problems (execution loop, tool calls, context management, security) are well defined while optimal implementations remain scenario‑specific.

Expert Insights

"Vibe coding raises the floor. Agentic engineering raises the ceiling." – Andrej Karpathy, May 2026 Sequoia AI Ascent talk

Karpathy identifies four Agentic Engineering skills: Spec Design (detailed specifications before prompting), Diff Review (scrutinizing Agent‑generated code), Eval Loops (automated quality verification), and Understanding (human comprehension of system behavior). LangChain’s 2026 State of Agent Engineering report notes that 57 % of teams run Agents in production.

"Building better Agents is about continuously improving the system around the model." – Harrison Chase, NVIDIA blog

Chase stresses that long‑running Agents succeed only when the Harness (planning tools, compression, file‑system integration, context engineering) matches the model’s capabilities. He also highlights that execution traces become the primary artifact for debugging and verification.

Swyx (Shawn Wang) introduced the "Loopcraft" concept, defining four stacked loops: Execution Loop, Task Loop, Evaluation Loop, and Feedback Loop. Mastery of these loops is presented as the core skill for AI engineers.

Lilian Weng’s 2023 article dissected Agent anatomy (planning, memory, tool use). Her 2026 follow‑up reframed the focus onto Harness engineering – managing workflow, context, permissions, evaluation, persistent state and self‑improvement.

Industry Trends (2026)

Consolidation – Between June and August 2026 ByteDance, Alibaba and Tencent merged their disparate Agent products into unified suites (豆包, 千问办公, WorkBuddy).

Shift to enterprise – Despite 200 M DAU for Doubao, daily revenue stayed < 1 M CNY while operating costs exceeded 1.3–2.4 B CNY, prompting a strategic pivot to B2B services.

Full‑system competition – The battle now centers on reliable Agent systems rather than raw model size; Google’s ADK + Runtime + A2A, Microsoft’s Copilot stack and DeepSeek’s open Harness exemplify the "model + Harness + tool ecosystem".

Coding agents as entry point – All major players first commercialized coding/IDE agents (Cursor, QoderWork, CodeBuddy, KroWork), validating the $40 B ARR success story of Cursor.

Commercial Models of Successful Agents

Cursor grew from $1 M ARR (Jan 2025) to $40 B ARR (Jun 2026), a ~8× YoY increase, with 75 % of revenue from enterprise customers. Pricing combines a token‑based subscription with a ~20 % markup on underlying model‑API costs. Introduction of the Composer model (Nov 2025) enabled positive gross margins.

Devin + Windsurf (Cognition)

Pricing tiers: Free (0 $/month), Pro ( $20/seat/month), Max ( $200/seat/month), Teams ( $80 base + $40 per development seat), Enterprise (custom).

One ACU ≈ 15 minutes of autonomous engineering work; the model‑agnostic "subscription + over‑age usage" approach captures both predictable revenue and heavy‑user value.

Replit Agent – three‑layer SaaS model (subscription, usage billing, marketplace). Subscription tiers: Starter (free), Core ($20‑25/month), Pro ($100/month), Enterprise (custom). Usage billing applies to Agent runs, deployments and compute. Parallel Agents and effort‑based pricing (Agent 4, Mar 2026) reduced simple bug‑fix costs to <$0.25.

Four typical profit paths

Tiered subscription + usage mix (Cursor, Devin).

Outcome‑based pricing – fees tied to business KPIs; AI startups using this model achieve 4.2× LTV versus traditional SaaS (CSDN).

Embedded Agent + transaction commission – Agents act as service entry points (e.g., Alibaba’s 千问 App).

Platform/marketplace – Provide an Agent runtime platform for third‑party developers (Replit Bounties, Google A2A ecosystem, DeepSeek plugin ecosystem).

Development Roadmap

Stage 1 (2023‑2024) – Technical breakthrough – ReAct paradigm, tool‑use, Code Interpreter. Benchmarks such as DeepSWE, Cybergym, Terminal Bench and DSBench‑Hard showed dramatic jumps after post‑training.

Stage 2 (2025‑2026) – Engineering deployment – Harness maturity, multi‑Agent collaboration, sandbox security. Key insights:

Agent performance is limited more by infrastructure than by model.

Standardized three‑layer memory (sensory, working, long‑term) reduces token waste.

Hook‑based validation prevents "false completion" where an Agent claims success but code fails.

Optimized multi‑Agent communication (structured JSON, shared memory) cuts token cost.

Minimal viable Harness construction steps:

File system + Git workspace for persistence.

Sandbox execution environment.

Memory injection & context management.

Stage 3 (2026‑2027) – Product validation – Focus on narrow high‑pain verticals, ROI quantification, and enterprise scaling. Recommended rollout:

Validate value in a single vertical scenario.

Add infrastructure (RAG, monitoring, permissions, cost tracking).

Scale across functions (customer service, ops, finance, R&D).

Key metrics: customer retention, net revenue retention (NRR), lifetime value (LTV), ROI multiples.

Stage 4 (2027+) – Commercial maturity – Agents become core infrastructure with ecosystem effects and standard protocols (Google A2A, OpenAI Responses API, DeepSeek plugin ecosystem). The value model evolves toward outcome‑economy, where customers pay for results rather than features, yielding LTV ≈ 4.2× baseline SaaS.

Conclusions

Agent competition now hinges on system engineering (Harness, Loop, tool ecosystem) rather than raw model size.

Domestic and overseas efforts converge on a "model + Harness + tool" stack; China gains a cost‑efficiency advantage through open‑source tooling.

Commercial breakthroughs occur in vertical, measurable use‑cases; generic assistants remain unproven.

Outcome‑based pricing offers the highest LTV but requires deep domain expertise and risk‑sharing capability.