LLM Agent Research Guide: Breaking Down Agent Principles and Implementation Approaches

Why Is Agent So Popular in AI?

Agent (intelligent agent) is one of the hottest topics in AI today, but many research newcomers easily get lost in conceptual fog when choosing topics. A Bilibili creator shared an intuitive example in a video: you can't get up in the morning, so you ask your roommate to attend class for you. Behind this simple "delegation" is actually a chain of subtasks—raising your hand when the teacher calls roll, handing in homework, taking notes, and even reasoning that you have no food at noon and proactively bringing back lunch from the cafeteria.

This metaphor captures the essence of Agent: it's not a single model call, but a process system that "understands commands → breaks down tasks → executes step by step." The video emphasizes that there is no perfect definition of Agent—everyone's view of Agent can be completely different. It's more like a DIY concept that depends on what problem you want it to solve and through what process.

The Relationship Between Agent and LLMs: "Asking the Model" at Every Step

Many people mistakenly think Agent is a new species independent of large language models, or even that it has "grown a brain." The creator explicitly points out that every decision and action of an Agent is essentially extensive interaction with a large language model.

After the user issues the command "attend class for me," the Agent first calls the LLM to split this command into several subtasks: what to do first, what to do second. The basis for decomposition comes from the prompt—including the user's basic situation, current environment, target state, etc. Then, before executing each subtask, the Agent again asks the LLM: "What is the current environment? What command did I receive? How should this step be completed?"

In other words, Agent does not exist apart from LLMs. On the contrary, it is a systematic utilization of LLM capabilities. The creator repeatedly emphasizes: "It's essentially about better utilizing the LLM—utilizing it at every step."

Prompt Engineering is the key technique for making LLMs output expected results, and it is also the underlying support for Agent decision-making processes. It refers to carefully designing input text (i.e., prompts) to guide the model toward generating output in a specific format or content. In Agent scenarios, prompts typically include elements such as role setting, task description, environment state, user preferences, and output format constraints. For example, the prompt for a class-substitute Agent would specify: "You are an assistant attending class for Tang Yudi. The current tasks are check-in and note-taking. He likes to review notes for exams, so notes should be detailed." The quality of prompts directly determines the reasonableness of the Agent's task decomposition and the accuracy of its actions, and is also the main vehicle for rule design today.

The Limitations of Agent: Relying on Rules, Not "Self-Thinking"

One of the most valuable points in the video is a sober judgment of Agent's current capabilities. The creator states bluntly that up to now, LLMs still cannot truly understand every human behavior, and hallucinations and instability still exist. Therefore, Agent execution relies more on human-designed rules than on the model's spontaneous reasoning.

What are rules? They are hard-coded scenarios written into the prompt. Using class substitution as an example, you need to tell the model: Tang Yudi usually doesn't want to attend class but likes to review notes for exams, so take good notes; the current goal is to complete check-in and homework on his behalf. All this personal information, behavioral preferences, and task goals are input as prompts so the model can output expected actions.

The creator criticizes many current Agent frameworks and talks for "mythologizing" this: as if Agent can analyze on its own and continuously understand everything. In reality, all the successful cases he has seen are the result of well-designed rules. "If you ask it to write code now, what's the logic of writing code? First a product manager defines the process, then programmers implement each function. Agent does not yet have self-thinking—if you don't design rules, the results are very poor."

LLM Hallucination refers to the model generating content that seems plausible but is inconsistent with facts or fabricated out of thin air. It is a major source of instability in Agent execution. In an Agent's multi-step process, hallucinations can occur in any stage—task decomposition, environment understanding, or action generation—causing errors to accumulate and amplify. For example, the model may invent a nonexistent classroom number or misjudge check-in status. Current methods for mitigating hallucinations mainly rely on rule constraints: limiting the action space in prompts, requiring structured output formats, introducing external tools to verify results, and designing fallback mechanisms. Understanding the causes and boundaries of hallucination helps researchers design more robust Agent workflows rather than blindly trusting the model's "autonomous judgment."

Implications for Research Topics: Starting from Rule Design

For researchers choosing the Agent direction, this video offers a pragmatic entry point: do not try to make Agent "think autonomously"; instead, study how to design better rules and prompting strategies.

Specifically, experimental plans can revolve around several dimensions: How does the granularity of task decomposition affect final performance? What environmental information and user states should be included in prompts? In which scenarios can rule design significantly reduce hallucination rates? Answers to these questions can be verified through controlled-variable experiments, without pursuing the grand narrative of a "general Agent."

Although the class-substitution example in the video is drawn from daily life, it fully demonstrates the Agent workflow: receiving commands, splitting tasks, calling the LLM item by item, and outputting results combined with rules. Research experiments can fully borrow this framework by replacing "class substitution" with research scenarios such as literature review, experiment workflow orchestration, and data preprocessing, designing reproducible Agent workflows and comparing performance differences under different rule designs.

Final Thoughts

The popularity of Agent is reasonable—it moves LLMs from "question-and-answer" to "multi-step execution," solving complex tasks that a single call cannot complete. But researchers need to stay clear-headed: the current ceiling of Agent is determined by rule design, not by the model's autonomous consciousness. Only by understanding this can one avoid the trap of conceptual hype and produce solid experimental plans.

One-line Summary

Agent essentially calls LLMs to decompose and execute tasks, relying on rule design rather than autonomous thinking.

Paragraph Summary

Using the everyday example of "a roommate attending class for you," the article breaks down the Agent workflow: after receiving instructions, it first calls the LLM to split subtasks, then asks the model step by step to complete each one. The author emphasizes that Agent is not a new species independent of LLMs, but a systematic utilization of LLM capabilities. The current limitation of Agent lies in its reliance on human-designed rules and prompts; LLMs do not yet possess true autonomous thinking, and hallucinations and instability remain. So-called success stories are mostly the result of well-designed rules and should not be mythologized. For research topic selection, the article suggests starting from controllable variables such as rule design, task decomposition granularity, and prompting strategies, designing reproducible experimental plans, and staying alert to conceptual hype.