跪拜 Guibai
← Back to the summary

DeepSeek's 36 New Roles Show Agent Engineering Is Now a Baseline Skill, Not a Specialty

Hello everyone, I'm Brother Er.

For the first time, I've seen DeepSeek officially and actively recruiting!

And I noticed a very important piece of information: as technology evolves, the scale of all departments will at least double.

All departments, at least double.

In this current AI era, this is an absolute anomaly.

There are 36 official job openings, and 121 positions listed on Boss Zhipin. From server-side to frontend/client, from testing to operations, from product to deep learning researcher, it's almost a complete lineup.

I researched it deeply.

The most direct finding is that 80% of the job descriptions mention Agent-related requirements.

So this article will break down these JDs position by position, providing a complete job-seeking preparation guide for us worker bees (including me) in the AI era. Of course, it's also perfectly fine to use it for career planning.

At the very least, you can figure out which direction you should strive for next and which essential tech stacks you need to master.

Fasten your seatbelt, let's gooo~ It's time to get twice the results with half the effort.

01. What are the 36 positions?

First, the background. In June 2026, DeepSeek's parent company, High-Flyer Quant, completed or nearly completed a Series A funding round of 51 billion RMB.

This is likely the direct reason for this major expansion.

To develop well, you still need people.

This recruitment covers 8 major categories: Full-stack Development/Algorithms (8 positions), AI Core System R&D (4), Operations (4), Product (2), Model Data Strategy (5), Deep Learning Researcher (4), Functional Departments (6), and Agent Harness.

Work locations are concentrated in Hangzhou and Beijing. Internships and full-time positions are available. I made a statistical summary of the high-frequency technical keywords.

02. New Responsibilities for Backend Development

First, designing large model applications and API service architectures for tens of millions of daily active users. The core difference between large model APIs and traditional REST APIs lies in the request pattern.

Traditional interfaces are "request comes in → process → return JSON," completed in milliseconds. A single large model inference might last over ten seconds, two or three minutes, or even longer, returning streaming data token by token.

More complex is that an Agent, when executing a task, will call external tools like search, code execution, or file operations mid-process. Each tool call is a nested request-response loop.

The traditional backend model of "receive → process → return" has become "receive → start inference → stream return → mid-process tool call → continue inference → return."

The architectural complexity is higher.

Second, building data and execution environment infrastructure for Agents. Inside every large model company is a cloud platform tailored for Agents, hosting thousands of sandbox environments.

When a user asks an Agent to run a piece of code, this code needs a securely isolated execution environment: containers must start in milliseconds, file systems must be temporary and destroyable, and networks must be strictly isolated. These are all within the scope of a backend engineer, except the service object has shifted from "user requests" to "Agent tasks."

How should backend developers prepare in the AI era?

The basic requirements haven't changed; a solid foundation in computer science and proficiency in data structures and algorithms are necessary.

But three areas need to be supplemented.

Streaming service architecture is the first. SSE, WebSocket, gRPC streaming—frontend and backend communication for large model applications is almost entirely streaming.

All developers should directly interface with the DeepSeek API to build an Agent backend service supporting Function Calling, running through the entire process from request to streaming response to tool calls.

Containerization and sandbox technology is the second. Docker and Kubernetes are the basics; the advanced direction is lightweight virtualization solutions like gVisor and Firecracker. Agent sandboxes have much higher startup speed requirements than traditional containers.

The ReAct loop is the third. Receive instruction → decompose task → select tool → execute → observe result → decide next step. You don't need to know how to train a model, but the backend infrastructure involved in each step of this loop (task queues, tool registries, execution state management, result storage) needs someone to build it.

03. New Responsibilities for Frontend/Client

The frontend direction's responsibility description is "responsible for the iterative development of DeepSeek's web version, open platform, and other services; explore and pre-research new interaction paradigms for concepts like Agent; seek human-computer interaction methods for the AGI era."

"New interaction paradigms" is the core of the entire JD.

Current mainstream AI product interfaces are still stuck in the chat dialog mode—user types, model answers, back and forth. But the way an Agent works is far more complex than a conversation.

When an Agent executes a task, it might be doing several things simultaneously: analyzing requirements, searching for information, generating code, running tests, fixing bugs. At critical nodes, it might pause to request user confirmation.

How do you present this multi-step, multi-branch, interruptible execution process to the user?

Hmm, this is a design problem with no standard answer (not really).

The client-side direction requires "experience in native iOS/Android development, familiar with Swift/Objective-C or Kotlin/Java." The DeepSeek App already has tens of millions of DAU on mobile. Native development performance tuning (startup speed, memory management, rendering smoothness) directly impacts user experience and retention.

How should frontend/client developers prepare?

Basic skills include proficiency in JavaScript/TypeScript, mastery of at least one mainstream frontend framework, and a solid foundation in HTML/CSS/HTTP.

On top of this, three directions need to be supplemented.

① Streaming rendering. Large model output is returned token by token. The frontend needs to start rendering when the user sees the first character, not wait for the entire paragraph to be generated before displaying it. Technical details like SSE parsing, incremental DOM updates, and virtual scrolling (to prevent page lag when outputting large code blocks) must all be mastered.

② Agent state visualization. When an Agent executes a multi-step task, the frontend needs to display the status of each step in real-time, such as thinking, calling a tool, waiting for user confirmation, or task completion. This is a complex state machine design problem involving frontend state management, transition animations, and exception handling (how to prompt the user if the Agent gets stuck, how to restore a session if the network disconnects).

③ Cross-platform capability. The JD explicitly states that iOS/Android native experience is preferred. If a pure web frontend developer wants to supplement this, React Native or Flutter are entry points for cross-platform solutions. In the long run, mobile products at the tens-of-millions DAU level have extremely high performance requirements, and native development remains the solution with the highest ceiling.

04. New Responsibilities for Test Development

The JD for Test Development Engineer mentions two key pieces of information: quality assurance for DeepSeek's business and systems, and a preference for Go/Rust.

First, let's talk about what "quality assurance" means in an AI system.

The core of traditional software testing is deterministic verification: given input A, expected output B, if the actual output is B, it passes. The output of a large model is probabilistic—input the same prompt twice, and you might get different answers; both answers might be correct, or both might be wrong.

What replaces traditional testing methods is an evaluation system.

DeepSeek's Code Agent Data Engineer position JD lists evaluation dimensions, including usability, code standards, engineering quality, task completion, planning ability, tool call accuracy, multi-turn interaction coherence, and instruction following. Each dimension requires an independent evaluation plan, including constructing test datasets, formulating scoring rules, running benchmarks, doing statistical analysis, and comparing against baselines.

Now, "Go/Rust preferred." The common tech stack for traditional testing roles is Java+Selenium or Python+pytest. DeepSeek wants Go/Rust, indicating that the testing infrastructure itself is performance-sensitive.

Large model evaluation requires running hundreds or thousands of test cases concurrently, each potentially containing a complete inference request. The entire evaluation process might last several hours.

How should test developers prepare?

Traditional testing fundamentals are still important—test case design, automation frameworks, CI/CD integration—all are still needed in AI system testing.

HumanEval assesses code generation, MMLU assesses knowledge reserves, and SWE-bench assesses real-world engineering task completion. It is recommended to read model evaluation reports and technical blogs published by DeepSeek, OpenAI, and Anthropic to understand the design thinking behind these benchmarks.

"Using Agents to test Agents" is worth paying attention to.

Let one Agent execute a task, and another Agent evaluate the execution quality, forming an automated evaluation loop.

DeepSeek's data strategy position mentions "building an Agent reinforcement learning environment," which is essentially an automated Agent evaluation system. Test engineers who can build such systems are scarce talents in the entire industry.

05. Two New AI-Native Positions

Server-side, frontend, and testing are the AI evolutions of traditional positions.

But Agent Harness and Agent Infra are new AI-native positions that didn't exist two years ago.

What is Agent Harness?

Model + Harness = Agent.

The model provides reasoning capability. The Harness is responsible for all the work outside the model—context management, long-term memory, tool call orchestration, sub-Agent coordination, task planning, and self-evolution mechanisms.

Current representative products in the Harness field include Claude Code, Codex, and others. Domestic manufacturers are also actively following up in this field.

Three sub-directions—Research, R&D/Engineering, and Product.

The research direction explores cutting-edge topics in the Harness field: how to optimize context management strategies, what architecture to use for long-term memory, how multiple Agents can collaborate, and how Agents can achieve self-evolution.

The R&D/Engineering direction requires the ability to research and program in areas with no direct experience, with the assistance of AI.

Put another way, DeepSeek doesn't want an expert in a specific language or framework; it wants someone who can use AI tools to quickly enter any technical field.

Whether you know Rust is not important; whether you can use AI to write a usable prototype in Rust within a day is. The JD also lists the Agent products they are paying attention to: Claude Code, Cowork, Codex, OpenCode, GitHub Copilot, Manus, OpenClaw, Hermes.

The product direction requires "Vibe Coding ability." Product managers need to be able to use AI tools to write code for prototype verification, not just draw up PRDs and wait for development scheduling.

The density of technical keywords in the JD is extremely high: LLM API, KV Cache, Agent Loop, Tool Use, Reasoning, Planning, Skills, MCP, Memory, Subagent, Multi-Agent, Prompt Engineering, Context Engineering, Harness Engineering.

These keywords cover all the core concepts of the Agent technology stack.

What does Agent Infra do?

Agent Infra R&D engineers are responsible for building DSec—a cloud platform tailored for Agents, hosting thousands of sandbox environments. Imagine the scenario: tens of millions of users are using DeepSeek's Agent simultaneously, and each Agent might execute code, read/write files, and access the network. These operations require isolated sandboxes to ensure security. Tens of millions of concurrent sandboxes, each needing millisecond-level startup, strict resource isolation, and secure network policies—this is the problem Agent Infra needs to solve.

06. The Capability Evolution Map in the AI Era

The bottom layer is computer science fundamentals.

Data structures, algorithms, operating systems, computer networks—every technical position's JD explicitly requires them, no exceptions.

Think about it, an Agent's execution environment involves containers, virtualization, network isolation, and distributed storage. Which one doesn't require a solid systems foundation?

The middle layer is engineering capability. Containerization, CI/CD, distributed systems, high-performance programming, streaming architecture—these were already hard requirements in traditional backend roles, and their weight is even higher in the AI Infra era.

The top layer is AI-native capability. Two years ago, this layer barely existed in any traditional position's JD. Now it's an explicit requirement for most technical positions, not just at DeepSeek:

Everyone can save this capability evolution map. In the next few years, perhaps five to ten years, programmers in the AI era will all go through this capability evolution process.

Charge ahead, brothers.

In the future, there will definitely be more companies like DeepSeek that need talents like you. 😄