The Agent Handbook

Appearance

Module Guide and the Job Landscape

At a glance Breaking down the five job types of the 2025-2026 Agent wave (Agent Engineer, AI Application Engineer, Platform Engineer, AI Infra, Agent-track Product Manager), with verified salary bands at home and abroad, hiring-demand data, and three transition routes from backend/ML/frontend.

This page contains time-sensitive content; data is current as of 2026-08. Job listings, pricing, and product features may have changed — verify against the original sources before citing.

Module Guide and the Job Landscape ​

This module solves one problem: once you've learned Agent technology, how do you turn it into a job and a competitive resume. This page is the map for the whole module—first see clearly which roles actually exist in the market, what each requires, and what each pays; then decide which path to enter by.

First, an easily-missed observation: in the 2026 hiring market, "Agent Engineer" is not a single job but a spectrum. From the business-side "build workflows with Coze/Dify" to the low-level "write sandboxes and schedulers for Agents," the salary and bar differ severalfold. Before sending your resume, figure out which segment of the spectrum the JD is actually describing.

Data currency note

All salary and hiring-demand data on this page comes from public hiring reports and live job snapshots from late 2025 through August 2026 (Maimai Gaopin, Liepin, LinkedIn, and others), marked dataAsOf: 2026-08. Survey data with small samples is flagged as such. Salary numbers fluctuate with the market; before negotiating, defer to the current season's live JDs.

1. Which Jobs the Agent Wave Created ​

1.1 The five roles at a glance ​

RoleOne-line positioningCore outputTypical salary band (tier-1 Chinese cities, monthly)
AI Agent EngineerDesigns and implements the Agent's decision loopAgent Loop, planning, tool orchestration, multi-Agent collaboration25K–60K (higher for senior)
AI Application EngineerTurns LLM capability into business featuresRAG pipelines, dialogue systems, prompt engineering, evals20K–45K
Agent Platform EngineerBuilds the platform others use to develop AgentsAgent runtime, orchestration engine, sandboxes, permissions30K–60K
AI Infra EngineerRuns the infrastructure behind model inference and trainingInference acceleration, GPU scheduling, vector stores, gateways35K–70K
AI Product Manager (Agent track)Defines what the Agent product does and how it's measuredScenario definition, eval standards, human-machine collaboration flows~20% above a regular PM

A few boundary notes:

  • Messy job titles are the norm. The same job is called "AI Agent Development Engineer" at company A, "LLM Application Engineer" at company B, and "AI Full-Stack Engineer" at company C. Don't filter by title—filter by keywords in the JD: LangGraph/tool calling/MCP/eval means it's basically an Agent Engineer role; mostly RAG/knowledge base/chatbot means application engineer; k8s/vLLM/inference optimization means Infra.
  • AI Infra is the closest of the five to traditional backend/systems engineering, the one with the least transition friction and the highest salary ceiling—but it demands the least "Agent semantics." That's a trade-off.
  • "Agent Platform Engineer" is a role that only clearly separated out in 2025: once a company has three or more teams building Agents, someone gets pulled out to build a unified platform (similar to the middle-platform logic of years past). ByteDance (the Coze team), Alibaba (Bailian), Tencent (Yuanqi), and a batch of Agent startups are all hiring for this.

1.2 The AI Agent Engineer: the "orthodox" role ​

This is the handbook's default target role. The job condenses to one sentence: be accountable for the Agent's behavioral quality—whether it plans correctly, calls tools accurately, recovers from failures, and stays within cost.

Typical responsibilities (aggregated from multiple 2026 live JDs):

  1. Design the Agent Loop: task decomposition, planning strategies (ReAct / Plan-and-Execute), reflection and retry mechanisms;
  2. Tool ecosystem: define tool schemas, integrate MCP servers, handle tool failures and timeouts;
  3. Context engineering: design memory structures, context compaction, multi-turn state management;
  4. Evaluation systems: set up trace collection, write eval sets, define success metrics and keep regressing them;
  5. Launch and operations: observability and alerting, cost monitoring, human-fallback (human-in-the-loop) flows.

Skill requirements, ordered by frequency in JDs (hard skills detailed in the skills matrix below): LLM APIs & prompt engineering > RAG > at least one Agent framework > evals > tool/MCP development. Notably, "eval experience" appears noticeably more often in 2026 JDs—the industry has moved past the "it runs" stage; the pain now is "how do you prove it's reliable." That's exactly why this site dedicates a chapter to Evaluation.

A counterintuitive observation

In an Agent engineer's daily work, writing prompts and tuning frameworks is about a third; the other two-thirds is "dirty work": garbage data from tool returns, unstable model output formats, fallback logic for edge cases. In interviews, the person who lectures on the ReAct paper usually loses to the one who can say "my Agent went down three times last week—here's why each time and how I fixed it." The latter skill is uncertainty management, and it's the real moat of this role.

1.3 The AI Application Engineer: the highest-demand track ​

If the Agent Engineer is "the person building the engine," the application engineer is "the person building the car"—using LLM capability to solve concrete business problems: intelligent customer service, knowledge-base Q&A, moderation assistance, marketing copy generation, office automation.

Responsibilities overlap heavily with the Agent Engineer (RAG, prompts, evals are all required); the differences:

  • Business delivery speed matters more: low-code platforms (Coze, Dify) are legitimate tools in these roles, not toys. Many JDs explicitly require "familiar with Dify/Coze secondary development";
  • Shallower requirements at the model layer: usually no complex Agent planning; mostly single-turn/few-turn RAG and fixed workflows;
  • Higher full-stack demands: often one person covers the frontend UI, backend API, and LLM calls together.

For career changers, this is the lowest-barrier, highest-volume entry point. But stay clear-eyed: pure "call API + assemble LangChain" application roles are commoditizing fast; in 2026, the people still commanding a premium are those who genuinely understand RAG tuning, understand evals, and can grind accuracy from 70% to 95%.

1.4 Agent Platform Engineer and AI Infra: the systems people's opening ​

These two roles are grouped together because both are essentially a lateral move of traditional backend/distributed-systems skills into the Agent era.

Typical Agent Platform Engineer work:

  • Agent runtime: session state persistence, checkpoint-and-resume for long tasks, multi-tenant isolation;
  • Orchestration engine: the DAG executor behind visual workflow builders (reference the architectures of Dify and Coze);
  • Tool & permission middle platform: unified tool registry, MCP gateway, auth and auditing;
  • Sandboxes: safe execution environments for Agent-generated code (see this site's Security chapter).

AI Infra goes lower still: inference serving (vLLM/SGLang), GPU scheduling, KV cache optimization, model gateways and rate limiting, vector database operations. Demand here was extremely hot across 2025-2026—Maimai's report put "high-performance computing engineer" on its talent-shortage list, and senior inference-optimization roles commonly pay 50K+ per month.

If you've spent five years on distributed systems and don't want to learn a pile of "Agent jargon" from scratch, these are the smoothest entry routes: your existing skills already cover 70% of the job; the remaining 30% is LLM APIs and basic Agent concepts.

1.5 AI Product Manager (Agent track) ​

Maimai's 2025 Annual Talent Migration Report shows AI Product Manager was one of the top 3 roles by growth in new job postings from January to October 2025 (the other two: LLM algorithms and robotics algorithms), with AI PM average monthly pay about 20% higher than regular PMs.

An Agent-track PM differs from a traditional PM in three fundamental ways:

  1. Requirements are non-deterministic: traditional features "click the button, get the result"; Agents can "give different-quality output for the same input." The PM must learn to define requirements with "success rates" and "eval sets" rather than "feature lists";
  2. Must understand technical boundaries: a PM who doesn't know what a context window is, or that tool calls can fail, will design Agent products that can't be built;
  3. The design object includes human-machine collaboration: when should the Agent run autonomously, and when must it stop and ask a human (human-in-the-loop)—that's a product decision, not a technical one.

This role suits people with PM experience willing to take on the technical coursework, and engineers who want to move into product—for the latter, technical judgment is actually the scarce advantage.

2. Skills Matrix ​

2.1 Hard skills: five puzzle pieces ​

                    ┌─────────────────────────────┐
                    │  Evals & Observability       │  ← highest premium in 2026
                    ├─────────────────────────────┤
                    │  One Agent framework (mastery of one is enough) │
                    ├──────────────┬──────────────┤
                    │ Tool/MCP dev │  RAG pipeline │
                    ├──────────────┴──────────────┤
                    │  LLM API + Prompt engineering │  ← the foundation; everyone must know it
                    └─────────────────────────────┘
  • LLM API + Prompt engineering: not just "can call chat completions." You need to understand the real effects of sampling parameters like temperature, structured output, the protocol details of function calling, token billing, and context window constraints. See this site's Prompt Engineering chapter.
  • RAG: index chunking, embedding selection, hybrid retrieval, reranking, query rewriting—every link has interview depth an interviewer can drill three levels into.
  • Tool & MCP development: tool schema design principles, error handling, idempotency; MCP has been the de facto standard for tool integration since 2025—not knowing MCP in 2026 is roughly equivalent to not knowing REST a decade ago.
  • One framework, mastery of one is enough: pick one of LangGraph, OpenAI Agents SDK, Claude Agent SDK, CrewAI and go deep. The ideas transfer across frameworks; greed gets you nowhere. Selection logic in the Framework Overview.
  • Evals: write eval sets, use LLM-as-judge, read traces to locate failures. The scarcest skill in the current market; see Evaluation and Observability.

2.2 Soft skills: the part that sets your ceiling ​

  • Product sense: the biggest failure mode of Agent projects isn't weak technology but "this scenario should never have used an Agent." The person who can judge "which tasks fit Agents, which fit fixed workflows, and which plain code handles" decides the project's life or death.
  • Uncertainty management: a traditional engineer's instinct is to eliminate uncertainty; an Agent engineer must learn to coexist with it—quantify it with evals, fence it with fallback logic, catch it with human review. That's a mindset shift, not a technical point.
  • Breaking fuzzy problems into verifiable steps: the boss says "build an Agent that handles customer complaints automatically," and you can decompose it into: intent classification (measurable) → knowledge-base retrieval (measurable) → reply generation (measurable) → escalation-to-human trigger conditions (definable).
  • Writing ability: in the Agent era, design docs, prompts, eval cases, AGENTS.md are all writing. Engineers who write clearly naturally command a larger sphere of influence.

3. Market Demand Today (2025–2026) ​

3.1 China: after the explosion, "precision scarcity" ​

Key numbers (all from Maimai Gaopin's 2025 Annual Talent Migration Report, published December 2025):

  • January–October 2025: new AI job postings climbed 543% year over year, with September alone up more than 11×;
  • Top 3 roles by growth in new postings: AI Product Manager, LLM Algorithms, Robotics Algorithms; algorithm engineers and LLM algorithms had the largest absolute posting counts;
  • The top 20 highest-paying roles all averaged above 60K RMB/month, with AI R&D roles taking the majority; AI Scientists averaged 127K RMB/month;
  • Salary premiums: AIGC algorithm engineers averaged about 18% more than regular algorithm engineers; AI PMs about 20% more than regular PMs;
  • Employer side: ByteDance led both overall hiring volume and AI talent hiring by a wide margin.

But a bucket of cold water is required: the same report shows that in 2025, the AI talent supply-demand ratio exceeded 1 for the first time, entering oversupply. There's no contradiction—what's oversupplied is "generic AI job seekers"; what's scarce is "people who can independently take an Agent to production with eval data to show for it." The structural split in roles is stark: junior candidates who can only call APIs face intensifying involution, while candidates with a complete project loop (development + evals + launch + cost control) are still fought over.

Zooming into the Agent niche, a few 2026 market snapshots (small samples, for reference only):

  • Liepin live listings (searched August 2026): AI Agent Development Engineer, Nanjing 20–40K × 14; Agent Development Expert, Beijing 40–60K × 15; mid-level roles, Shanghai 35–50K;
  • A survey of 101 AI Agent job JDs from 2026 found: 59.6% of roles pay above 25K/month, Beijing roles average above 40K, and the salary mass concentrates in the 25–40K band.

Don't get drunk on "543%"

The growth percentage sits on a tiny base (Agent jobs barely existed in 2024), and a substantial share are traditional roles with an AI title swapped on. What actually determines your negotiating power isn't market heat—it's whether you can answer this question: "The Agent you built—what's its success rate, and how did you measure it?"

3.2 Overseas: AI Engineer tops the charts two years running ​

  • LinkedIn's Jobs on the Rise 2025 (based on three years of data, 2022-2024): Artificial Intelligence Engineer ranked #1 among the fastest-growing jobs in the US, also #1 on the UK list, and the most frequently appearing job across this global ranking;
  • Per CBS News in April 2026, citing LinkedIn data: between 2023 and 2025 the US saw 639,000 new AI-related job postings, of which 75,000 were AI Engineer roles;
  • Salaries (multi-source composite, mid-2026): typical US AI Engineer base around $140K–$240K (varies by level), mid-level total comp around $230K–$380K, FAANG senior up to $340K–$550K+; engineer total comp medians at top labs (e.g. OpenAI) run significantly higher on levels.fyi self-reported data, but self-reported data carries sample bias—reference only.

One notable feature of overseas roles: titles have converged on "AI Engineer," and the words agentic workflow, tool use, and evals appear at very high rates in responsibilities—unlike the mixed bag of "Agent Engineer / Application Engineer / Algorithm Engineer" in China, overseas has converged this career path into a single standard role.

3.3 An unevenly heated fact ​

The boom concentrates at the top: ByteDance, Alibaba, Tencent, Meituan, and other giants plus first-tier Agent startups take most of the headcount, while "Agent roles" at smaller companies are often one person wearing several hats on an application team. Strategically, a portfolio gets you through resume screening better than credentials—see the Portfolio Projects chapter for how.

4. Transition Routes by Background ​

There is no "zero-to-Agent-engineer in three months" myth, but starting points differ hugely in path length. The three routes below assume a 6-12 month part-time study horizon.

4.1 Backend engineers: the smoothest road ​

Your existing advantages: system design, API development, databases, concurrency and async, production troubleshooting—these already cover over 50% of an Agent engineer's daily work.

What you have                  What you need to add
─────────────              ─────────────────────────
API/microservices/DB    ──▶   LLM API + Prompt engineering (2-4 weeks)
Async tasks/queues      ──▶   RAG: embedding/retrieval/rerank (4-6 weeks)
Distributed debugging   ──▶   One framework + tool/MCP dev (4-6 weeks)
CI/CD                   ──▶   Evals & observability (ongoing, across projects)

Concrete path:

  1. Months 1-2: follow a complete tutorial to build your first working Agent (see the hands-on tutorial); don't rush to read papers;
  2. Months 3-4: build a project with real data—wrap one of your company's internal APIs as a tool so the Agent can query and operate it. Mind data sanitization;
  3. Months 5-6: add an eval set and trace observability to the project, and write up the process of "lifting the success rate from 60% to 90%" as an article—that's the most persuasive line on your resume;
  4. When job hunting, prioritize "Agent Platform Engineer" and "AI Application Engineer" roles—the engineering intuition you have over pure-ML candidates is a direct plus in these roles.

4.2 ML/algorithm engineers: one step down the stack ​

Your existing advantages: model principles, training/fine-tuning, data processing, experimental thinking (which makes evals feel natural to you).

Your likely weak spot is engineering delivery: having written training scripts doesn't mean having written a production service that survives concurrency. Transition moves:

  1. Take one solid backend course: FastAPI/Node, databases, caching, queues, Docker deployment—the goal is making your Agent a service others can call, not a Jupyter notebook;
  2. Port the "optimize model metrics" mindset to "optimize Agent behavior metrics": the eval set is your test set; trace analysis is your bad-case analysis;
  3. Don't drop fine-tuning (SFT/RL) skills—in 2026 more and more teams find "fine-tune a small model for a vertical scenario" better value than "write a 10,000-word prompt for a general model," and Agent engineers who can do this are scarce;
  4. Job targets: Agent Engineer, LLM application algorithm roles. On your resume, highlight "model capability boundary judgment"—when to tune prompts, when to add RAG, when to fine-tune; that judgment is unique to ML backgrounds.

4.3 Frontend engineers: enter through "the Agent's interface" ​

Honest take: frontend-to-Agent is a longer jump than backend, but there's a differentiated path others don't have—the Agent's human interface is currently the most underrated direction.

  • Agent product UX is far more complex than traditional products: streaming output, mid-process display (tool call visualization), user mid-course intervention, result confirmation and rollback. This is home turf for frontend. Claude Code's terminal UI and Manus's task-replay interface are both landmark "Agent UX" work;
  • Concrete route: learn LLM APIs and prompts first (the gate everyone passes through), then build "an AI application with complete Agent UX"—streaming rendering, tool call display, human confirmation nodes. This kind of work impresses interviewers far more than yet another chat box;
  • The TypeScript ecosystem is frontend-friendly: OpenAI Agents SDK, Mastra, and Vercel AI SDK are all TS-first, with less entry friction than the Python ecosystem;
  • Job targets: AI Application Engineer (full-stack track), frontend roles on AI products. Aim to be "the frontend engineer who understands Agents best," not "a half-baked Agent engineer"—in the former you're scarce; in the latter you're a backup.

Where all three routes converge

Whichever path you enter by, everything converges on the same thing: a project you can demo publicly, with eval data, that has survived real pitfalls. Tutorial-assignment projects ("the chatbot I built along with a video") have essentially lost their power in 2026 resume screening—interviewers assume everyone has done those. Differentiation comes from problems you solved alone.

5. Guide to the Rest of This Module ​

This page is the map; the following pages are the detailed charts of each destination. Suggested reading order:

  1. JD Breakdown: a curated selection of real Agent job JDs from home and abroad, each broken down into "what this line actually requires, and how it will be tested in interviews." Read this before writing your resume, so you know what they want;
  2. Knowledge Map and Interview Topics: maps the site's technical content onto an interview syllabus—which concepts are must-know, which are bonus points, and to what depth each gets tested;
  3. Resume Analysis and Rewrites: anti-examples of problem resumes plus rewrite demonstrations. Core principle: write "what I built and how I verified it," not "what I've studied";
  4. Interview Questions and Answer Frameworks: real interview questions graded by frequency, with answer frameworks rather than standard answers—Agent interviews have no standard answers, only depth of thinking.

Pair these with two hands-on pages from outside the module: Portfolio Projects (build the things you can put on a resume) and Writing AGENTS.md (incidentally demonstrates your grasp of AI-collaboration engineering—already an interview plus).

If you're still unsure whether to take this path, go back to the Learning Paths page to check the cost-benefit expectations; if you'd rather see the technical panorama before the job talk, start from Anatomy of an Agent.

References ​