The Most Comprehensive AI Agent Tutorial on Bilibili: A Step-by-Step Guide to Building Enterprise-Grade Agents from Scratch

Why Do You Still Not Know How to Use Agents After Finishing Every Tutorial Out There?

There's no shortage of AI Agent tutorials on Bilibili, but very few actually explain clearly "what an Agent is, why you need one, and how to put one into production." Most mainstream tutorials suffer from two fatal flaws. First, they put the cart before the horse: they open with a pile of jargon—tool calling, task planning, memory mechanisms, the ReAct framework—and beginners get lost in concepts before they've even started. Second, they're all about quick wins: gimmicks like "Learn Agents in Ten Minutes" or "Build an Agent with One Snippet of Code" grab attention, but following along only reproduces a finished product. You don't understand the principles, you can't tune it, you don't know how to adapt it to a business—and the moment you change the scenario, it falls apart.

The positioning of this tutorial series is clear: ditch the dry jargon and the empty promise of quick mastery. Use plain language and accessible examples to help learners build a complete knowledge system first, then gradually move on to real projects. The goal isn't just to write code—it's to thoroughly grasp the underlying logic and independently handle the entire process, from requirements analysis and solution design to deployment and launch.

From Raw Large Models to Agents: The Four-Stage Evolution

To understand the value of Agents, you first need to see clearly the path large models take when enterprises adopt them. The tutorial breaks this into four stages, each more difficult than the last.

Stage One: The Birth of Raw Large Models

After ChatGPT exploded onto the scene, people discovered that large models could write articles and write code—seemingly capable of anything. But models at this stage had obvious limitations: no autonomous reasoning, only concept generation; a knowledge cutoff, so they couldn't answer questions about anything after their training date; a strong tendency toward hallucination; and no way to connect to traditional enterprise business processes. For enterprise-grade commercial deployment, this stage was far from enough.

Stage Two: Prompt Engineering

Many people tried to improve output quality by optimizing prompts, and "master prompt engineering and you can go commercial" was once a popular industry catchphrase. But prompt engineering still has core shortcomings: it can't access private enterprise data, can't handle business processes, and output quality depends heavily on how well a person designs the prompt. The tutorial offers a vivid analogy—you need to know how to type before you can use a computer, but knowing how to type doesn't make you an IT engineer. Prompt engineering is a fundamental skill, not the finish line.

Prompt Engineering refers to designing and optimizing the instruction text fed to a large model to guide it toward more accurate, more expected outputs. Common techniques include role setting, few-shot examples, and Chain-of-Thought (getting the model to reason step by step). Its value lies in drawing out the model's existing capabilities at extremely low cost, with no need to train or modify the model itself. But its boundaries are equally clear: prompts can only mobilize knowledge and reasoning patterns already baked into the model—they can't give the model access to private information beyond its training data, nor can they truly execute external actions. That's why prompt engineering is often seen as the "entry-level fundamental skill" of large model applications rather than a complete engineering solution—which also explains why the field later evolved toward RAG and Agents.

Stage Three: RAG (Retrieval-Augmented Generation)

The idea behind RAG is this: store an enterprise's fixed, repetitive business data (tables, images, documents) in a knowledge base, have the large model perform a relevance search before answering, and then deliver the retrieved results to the user. This solved part of the problem, and most knowledge Q&A systems on the market are built on RAG. But RAG's inherent flaws are just as obvious: it can only passively retrieve information, it doesn't think proactively, and it won't answer unless asked; it can't handle complex business processes and only supports a one-question-one-answer delivery model. Take the tutorial's example—an e-commerce company's entire workflow from customer inquiry to order placement, inventory check, and address change—RAG can't do it.

The core process of RAG (Retrieval-Augmented Generation) typically has three steps. First, enterprise documents, tables, and other materials are split into chunks and vectorized into a vector database. When a user asks a question, the system also converts the question into a vector, performs a similarity search in the database, and recalls the most relevant chunks. Finally, these chunks are assembled as context into the prompt and handed to the large model to generate an answer. It effectively mitigates the problems of outdated knowledge and hallucination, giving answers a basis in evidence. But RAG is essentially a one-way pipeline of "retrieve—assemble—generate." It lacks multi-step reasoning, tool calling, and state memory, and it struggles with tasks that require cross-system operations or multi-turn collaboration—exactly the gaps Agents are meant to fill.

Stage Four: Agent

Agents have the ability to plan and execute autonomously, upgrading from a Q&A tool into a "digital employee" that can call various tools to complete complex tasks and also supports multi-agent collaboration to close the loop on enterprise business processes. This is the approach that even the national level is strongly promoting for deployment.

ReAct (Reasoning + Acting) is one of the most classic paradigms for building Agents. Its idea is to have the large model alternate between "reasoning" and "acting": the model first outputs a Thought, deciding what to do next; then selects an Action, such as calling a tool or performing a retrieval; then obtains an Observation of that action's result, on which it continues reasoning, looping until it reaches a final answer. This "think—act—observe" loop enables Agents to handle complex tasks dynamically rather than generating an answer in one shot. Alongside it are supporting components such as task planning, tool-calling protocols, and memory mechanisms, which together form the engineering foundation of an Agent's autonomous execution capability.

What Exactly Is an Agent? The Translator Analogy

The tutorial explains Agents with a diagram: suppose a user asks a question—there are two ways to invoke a raw large model, either by writing code or through an API call. But a raw large model has only basic reasoning ability, has knowledge limitations, can't go online, can't read files, and can't call tools. The Agent's role is to serve as an intermediary bridge, much like how communication between a Chinese speaker and an American speaker requires a translator. The user asks a question, the Agent understands the need, calls tools, completes complex tasks, and returns the result to the user.

More specifically, Agents solve four core problems:

• Translator: Translates natural-language requests into instructions the large model can understand, then converts the output into usable results.
• Tool Master: Helps the large model call APIs, search data online, operate files, and connect to enterprise systems—turning the large model from something that can "only talk" into something that "can act on data."
• Memory Keeper: Remembers context, user preferences, and conversation history, enabling coherent multi-turn dialogue without losing track.
• Task Manager: Breaks complex problems into one-to-three-step subtasks and plans their execution, proactively invoking solutions when problems arise.

In fact, you use Agents every day: when you send a question to Doubao, it isn't sent directly to a raw large model—it goes through an Agent that calls and processes it before returning the result. Cursor and Claude Code, which programmers use, are also Agents—they can remember project structure and call the compiler to check code.

The Four Main Agent Categories and Monetization Tracks

Agents built on commercial logic basically fall into four categories, which are also currently the most stable monetization tracks.

Tool-Type Agents (Auto Brand Customer Service Type)

A typical scenario is the dedicated intelligent customer service on an auto brand's official website, embedded in the brand's app and website. When a user wants to buy a car, everything from model pricing and after-sales to configurations can be answered by it 24/7 in place of staff. Any company of even modest scale is either already doing this kind of transformation or preparing to.

Persona-Type Agents (Multimodal Digital Humans)

The type ordinary people see most often when scrolling short videos—digital humans, virtual anchors, livestream shopping hosts. Traditional short-video companies and e-commerce companies are already using them in large numbers; technically, they're a combination of Agent capabilities and digital humans.

Utility-Type Agents (Single-Function)

Their defining feature is solving one specific functional need and doing that one thing thoroughly and well—AI writing, resume generation, Cursor, Cortex, and so on. This category is well suited for ordinary individuals to enter: build a product around a single functional pain point and monetize through memberships or traffic. Traditional enterprises can also build tools around internal functional pain points to boost employee efficiency.

Industry-Type Agents (End-to-End B2B)

Aimed at the transformation of traditional B2B enterprises, this category has the highest ceiling. Healthcare, finance, e-commerce, logistics, industrial, legal—any industry can be combined with large models. Typical scenarios include finance Agents, e-commerce Agents, and industrial Agents—an industrial Agent can run the entire workflow from customer inquiry to inventory check to order address change, reaching deep into the full end-to-end business process of an enterprise. This is also the main content of the systematic learning course, and the track is extremely broad.

Why Now Is the Window to Get Into Agents

The tutorial offers a timeline judgment: 2024 was the year of large models, a contest of compute and parameters; 2025 is when Agents move from concept to small-scale deployment, a phase of early adopters testing the waters; 2026 will be the year of hundred-billion-scale Agent explosion, with central SOEs, state-owned enterprises, mid-to-large and small-to-medium enterprises, and industries like power and logistics all deploying large models as part of digital transformation. For traditional programmers, moving into Agent development lands right on the cusp of a massive industry-wide transformation—many positions, few people, and plenty of companies that can't find anyone.

This judgment echoes policy: the national "AI+" action plan covers science, industrial development, consumption, and public welfare, and sets a goal of 70% adoption of next-generation Agents by 2027 and full-scale development by 2035. The tutorial also draws an analogy to the "Internet+" action from a decade ago—those who followed the policy direction back then seized the opportunities in mobile payments, ride-hailing, and livestream e-commerce.

The "AI+" action is China's policy deployment for deeply integrating AI with all sectors of the economy and society. The thinking is similar to the earlier "Internet+"—emphasizing embedding AI as a general-purpose technology into industry, consumption, public welfare, and other scenarios. Related policy documents set phased goals, including a significant increase in the adoption of applications such as next-generation Agents by 2027 and full-scale development by 2035. The significance of such top-level design is that it sends a clear industrial signal: government and enterprise procurement and digital transformation budgets will tilt toward Agents, which in turn will generate a large volume of project demand and job vacancies—one of the key reasons the tutorial judges this to be a window for entry.

Suggested Learning Path

Based on the tutorial's framework, here's an actionable path for developers who want to systematically get into Agents: first build a macro understanding of the four-stage evolution and grasp why Agents are irreplaceable compared with prompt engineering and RAG; then thoroughly learn the four core capability models of Agents—translator, tools, memory, and task management; then identify where you fit among the four categories—go with utility-type Agents if you want to build personal products, aim for industry-type Agents if you want to take client work or provide enterprise services; finally, practice requirements analysis, solution design, and deployment tuning in real projects. Skipping the underlying logic and copying case studies means it falls apart the moment the scenario changes—this is the core point the tutorial emphasizes repeatedly, and every learner would do well to take it to heart.

The quality of a course is ultimately tested by real-world project outcomes. This article merely organizes and summarizes the tutorial's public content; for actual learning, please refer to the original author's complete videos.

One-line Summary

Explains Agents' evolution logic, capability model, four categories, and timing for entry in plain language.

Paragraph Summary

The article addresses the two shortcomings of existing Agent tutorials—jargon overload and quick-win gimmicks—and argues for building a complete knowledge system before starting projects. The core framework is the four-stage enterprise adoption of large models: raw models limited by knowledge cutoff, hallucination, and inability to connect to business; prompt engineering as just a fundamental skill; RAG able to retrieve private data but still passive Q&A; and Agents with autonomous planning and tool-calling capable of closing business loops. Using a "translator" analogy, it explains how Agents solve instruction translation, tool calling, memory management, and task decomposition, then categorizes Agents into tool-type, persona-type, utility-type, and industry-type with their monetization tracks, and closes with a learning path informed by the 2026 explosion forecast and "AI+" policy.