Bilibili's 100-Episode Agent Tutorial: A Complete Zero-to-Hero Breakdown

Why Is This Agent Tutorial Worth Watching?

Search "Agent tutorial" on Bilibili and you'll find plenty of popular videos with hundreds of thousands or even millions of views, alongside niche content with just a few hundred. But in the opening of this course, the creator admits that after spending a month researching these tutorials, he found that most courses offer fragmented, unstructured knowledge—and after finishing them, learners still can't independently build an agent. This "learned it but can't use it" pain point is exactly what this 100-episode systematic course aims to solve.

This course took three months to produce and positions itself as "zero foundation to实战 employment." It doesn't stop at concept popularization—it breaks the learning path into four modules: fundamentals, advanced, hands-on projects, and career. Each module has clear capability goals. Below we break down its design logic layer by layer and offer objective course-selection advice.

Course Structure: How the Four Modules Build on Each Other

The creator divides the 100 episodes into four stages, each corresponding to different learning objectives. This "stepped" design is rare among free tutorials, because most courses mix fundamentals and hands-on content together—leaving beginners thrown into projects before they even understand agent architecture.

Fundamentals: Building Agent Principles and Workflow Thinking

The fundamentals module covers agent principles, prompt engineering, and workflow design. These three are the foundation for all subsequent hands-on work—without understanding the agent's decision loop, the prompts you write are just ordinary conversation templates; without understanding workflows, multi-agent collaboration becomes a pile of loose API calls. The course puts these three first, signaling that it wants learners to build a "systems view" before getting hands-on.

The agent decision loop typically refers to the iterative process of "perceive-plan-act-observe": the agent receives environmental input (perceive), reasons and decomposes tasks based on goals (plan), calls tools or outputs actions (act), then adjusts the next step based on execution results (observe). Unlike ordinary conversational models, agents can autonomously call tools, maintain memory, and dynamically adjust strategies. In agents, prompt engineering is no longer just about designing conversation templates—it requires defining roles, available tools, output formats, and stopping conditions. Workflow design focuses on how to orchestrate multiple steps or agents into reusable processes, commonly including serial, branching, and looping structures. Understanding these is key to avoiding "loose API calls."

Advanced: RAG, Multi-Agent Collaboration, and Framework Practice

The advanced module dives into RAG knowledge bases, agent architecture, multi-agent collaboration, and tool calling, combined with mainstream frameworks for development. RAG is currently the most common technical combination when enterprises deploy agents, and multi-agent collaboration is key to automating complex tasks. The creator emphasizes "hands-on development with mainstream frameworks," meaning this section won't just be theory—it will involve writing code.

RAG (Retrieval-Augmented Generation) is a technical architecture that combines external knowledge base retrieval with large language model generation. Its core process: after a user asks a question, the system first retrieves the most relevant document fragments from a vector database, then splices these fragments as context into the prompt, and hands it to the LLM to generate an answer. The benefit is enabling the model to answer with the latest or private knowledge beyond its training data while reducing hallucinations. Enterprises commonly use RAG to build knowledge base Q&A and customer service assistants because it requires no model retraining, is low-cost, and offers strong interpretability. Learning RAG requires understanding several key steps: text chunking, embedding models, vector retrieval, and prompt assembly.

Multi-agent collaboration means decomposing complex tasks into multiple subtasks, completed by multiple agents with different roles and tools working together, coordinated through message passing or shared state. Common patterns include supervisor-worker architecture (a scheduling agent assigns tasks to several execution agents), debate-style collaboration (multiple agents propose solutions and review each other), and pipeline collaboration. Compared to single agents, multi-agent systems can improve parallelism and specialization, but also bring challenges like communication overhead, state consistency, and debugging complexity. Mainstream frameworks like LangGraph, AutoGen, and CrewAI all provide multi-agent orchestration capabilities; when learning, focus on understanding inter-agent communication protocols and task allocation strategies.

Hands-On: Three Projects Covering Mainstream Application Scenarios

The hands-on module includes three projects: a personal knowledge base assistant, a customer service agent, and an automated office assistant. These three scenarios are highly representative: the knowledge base assistant corresponds to RAG, customer service to multi-turn dialogue and tool calling, and the office assistant to process automation. Running what you've learned through real projects is the only way to test whether you can actually use it.

Career: Job Landscape, Resume, and Interview Questions

The career module analyzes the agent development job landscape and hiring standards, teaches learners to polish their resumes and portfolios, and provides detailed explanations of big-tech interview questions. For those looking to change careers or find a job, this section is as valuable as the technical content—many people pass the technical bar but get stuck on resumes and interview presentation. The creator also compiles a complete learning roadmap, project source code, prompt templates, deployment tools, course notes, and interview questions, available in the comments for learners to claim.

Who Is This Course For? And Who Isn't It For?

Suitable for: complete beginners who want a systematic introduction to agent development; "half-baked" learners who have watched scattered tutorials but can't complete projects independently; people preparing to apply for agent-related positions who need a portfolio and interview preparation. The course reorganizes the learning path from a zero-foundation perspective, making it beginner-friendly.

Use caution if: you already have development experience and only want to dive into a specific framework or cutting-edge direction—you may find the fundamentals module slow-paced; you want to learn the latest research (like complex reasoning or multimodal agents)—this course leans more toward engineering implementation than academic frontiers. Also, 100 episodes means a significant time investment. The creator's claim of "from novice to expert in seven days" is more marketing talk; the actual learning cycle depends on your background and practice volume.

Three Reminders for Agent Learners

First, writing code matters more than watching videos. The course provides project source code and deployment tools, but there's a lot of debugging between "understanding" and "getting it running." After each module, reproduce it yourself—even if you just tweak parameters.

Second, don't skip the fundamentals and jump straight into hands-on projects. Many people prefer diving into projects, but if prompt engineering and workflow design aren't solid, you'll get stuck halfway through. The "boring" fundamentals content is exactly what saves you from detours later.

Third, treat the career module as part of learning, not the final step. Understanding the job landscape and hiring standards early helps you decide what to focus on, avoiding wasted time on irrelevant details.

Summary: A Well-Structured Entry Path, But "Expert" Still Requires Your Own Practice

The core value of this Bilibili agent course is systematicness: it strings scattered knowledge points into a complete chain of "fundamentals → advanced → hands-on → career," tested with three real projects. Supporting materials (source code, prompt templates, interview questions) also lower the barrier to entry. However, no tutorial can replace hands-on practice—"from novice to expert in seven days" is idealized marketing. What truly determines whether you can independently build an agent is the number of times you debug and iterate on projects after class. If you need a clear learning map, this course is worth bookmarking; if you expect to be job-ready right after watching, you may need to adjust expectations and leave more time for writing code yourself.