Do U Need Agentic Systems?
agent learning 02
2026-06-07
“Entities should not be multiplied beyond necessity.” — Occam's Razor
0. Preface
My second blog, yeahhh! And this one is about my learning in the Agent-Learning-Hub stage 0. After reading the two listed resources ( Anthropic: Building effective agents, OpenAI: A practical guide to building agents), the most important lesson I learned is the principle of designing agentic systems: start from the simplest solution. The tradeoff for agentic systems is all about latency + cost vs. performance. I will showcase how to design agentic systems from a high level, the common design patterns, and some reflection about my work during the internship at Meituan.
1. Agentic System
Definition
Before asking whether we should build agentic systems, we should first have a clear understanding of what they are. So, what are they?
There are 2 types of agentic systems: workflows and agents (referencing the definition in Claude's blog). Both of them have a necessity for using LLMs, but this condition alone is not sufficient for an agentic system. Usually, they use the augmented LLM as the building block. The building block is equipped with tools, memory, and retrieval modules, which enable the LLM to output more accurate answers. For workflows, they are built with the blocks but with some predefined logic. Agents are more flexible — they can finish their task autonomously by decomposing it into clear sub-tasks and executing them with the tools and necessary human feedback.
When
The augmented LLM is the building block of the system. The strength of the augmented LLM compared to conventional software is about understanding and analyzing large, unstructured data, and doing complex reasoning. When your system can function well and doesn't need any of these features, you may want to think twice before migrating just to chase the trends in tech.
If you do find that your product can benefit from those functions, that's great. But we should start small — not even with the agentic system, but first with a single augmented LLM. Sometimes RAG or prompt engineering techniques will meet your goal. If it doesn't work, then we should think about designing the agentic system. And I would summarize all the common patterns mentioned in the 2 blogs.
2. Design Patterns
Workflows
All these patterns are not strictly defined like math equations, but you can use them as a guide map, and the details should be implemented accordingly. I categorize them into 2 basic types: prompt chaining and cooperation.
Prompt chaining is the naive one when we talk about workflows. In the workflow, each node is an LLM call, and one call follows another one's result. That's really simple. And that's the starting point for us to design the happy path.
Cooperation includes many variations (I may oversimplify here): routing, parallelization, orchestrator-workers, and evaluator-optimizer… They are more sophisticated than prompt chaining. There is more than 1 way of chaining, and some calls may even chain their states back.
Routing suits tasks that can be classified into different categories, where each category can be handled with our building block: the augmented LLM.
There are 2 typical scenarios suited for parallelization. One case is that you can decompose the task into several independent subtasks. The other case is that your task can benefit from running multiple LLM calls, which increases the sample space for the output.
Orchestrator-workers is similar to parallelization, except your subtasks are not predefined but decided by the orchestrator, and you should synthesize the output of all the LLM calls to get the answer you need.
The last one I introduce here is evaluator-optimizer, which uses an LLM call as a judge and provides feedback for the generator block to generate more accurate answers.
Agents
Agents have more freedom compared to workflows. The essence of an agent is a while-loop. The exit condition for the while-loop can be successfully completing the task, an error occurring, or reaching the maximum number of loops the agent allows. In this loop, the agent (or LLM call) gathers the right context using the tools or functions we provide for the system, and based on the task defined, approaches it step by step.
3. Some Thoughts
When I did my internship at Meituan, my task was about dealing with the bad cases that product teams gathered from users' real conversations. My internship was around the second half of 2024 (at that time, agents were not quite popular yet). Our product was deployed on smart watches for children, and we designed different characters in the app, backed by LLMs, as the chatbot. In this context, safety and correctness are important. We don't want to teach knowledge that the LLM hallucinates, and we don't want the LLM to give harmful instructions or discuss adult topics.
This was my first internship — not soo good. I only focused on the things that my tutor asked me to do, and rarely had my own thoughts on the products or solutions. After reading these 2 blogs, I think I would approach this in a better way, or at least try to discuss some of these methods first.
What I had done at that time was reading and replicating the methods about online-DPO in the paper. I spent a huge amount of time learning to set up and build all the benchmarks just to replicate the paper's results. (I think that was a bit out of focus.) In the 2nd month, I finally started to go into the real product and questions. Still, I focused on implementing the methods, not on the real things.
What made me start to reflect on this experience is the guardrails and philosophy mentioned in the blogs. With some benchmarks set up, I think I would start with prompt engineering. If it doesn't work, I would try to implement some guardrails, like calling some LLMs or training small models to classify harmful content. The point is all about how to use the right tools to resolve real problems, not just focusing on implementing some fancy techniques.
Disclaimer
The post is 100% written by myself. AI may just help me polish some sentences or correct grammar. All references are cited here. The workflow diagrams are from Anthropic's “Building effective agents” (reference 1).