A Firsthand Take from a Former Manus Engineer: Building an Effective Agent Requires Three Capabilities | AI Practitioners

By Changpeng Xu | Content Strategy by Zhuo Zhang | Produced by AI Nao

Intro

This is AI Nao's new column, AI Practitioners. We keep our eyes on AI builders who use new paradigms and fresh understanding to solve real problems.

Over the past six months, one capability in the AI industry has become both essential and scarce: Agentic Process Architect. In simple terms, this means turning a large language model into an "employee who gets things done."

Industry consensus is shifting: as model progress slows, Agent architecture will only grow more important. Some major Silicon Valley companies are offering junior Agent process architects salaries of up to $2 million a year.

This piece is shared by Changpeng Xu (CP @yan5xu), formerly an engineer at Manus & Monica, a longtime active voice on Twitter, and self-described "AI wild researcher."

He's noticed that when people discuss how to architect an Agent, they tend to fall into two traps:

First, believing it can do anything and everything;

Second, oversimplifying it as merely calling a large language model multiple times.

"The core reason is that people lack an embodied understanding of the Agentic loop," Xu told AI Nao. "It's like everyone jumped straight to the answer, skipping all the intermediate thinking."

Drawing from his hands-on experience building Agents and intensive conversations with numerous teams after leaving his role, he's arrived at a key insight:

Building a useful Agent doesn't stem from a leap in model intelligence, but from designing an effective "cognitive process" around the model.

Xu believes this process is essentially trading more computational steps and longer thinking time for a result that's "genuinely useful" in the real world — "trading time for quality." "We don't make the optimistic assumption that we can get the result in one shot. Instead, we ensure result quality through a trustworthy process."

He uses a vivid analogy: the large language model is a prodigy named Xiaoming. If you have Xiaoming take the college entrance exam directly, he probably won't score well. The reason is that he lacks basic understanding of the study-test cycle.

So someone must guide him:

• Check your work after finishing, or you'll make careless mistakes (basic API calling stage);
• Reason step by step, or you'll skip steps and leave gaps (Chain-of-Thought, CoT);
• Proactively review your problem-solving process and correct errors (self-reflection);
• When facing difficult problems the teacher never covered, learn to budget time, consider the big picture, decide what to abandon and what to secure, and adjust strategy to maximize your score

Only after this series of trainings can Xiaoming achieve good results.

"How Xiaoming gradually improves his score through process design — his knowledge (intelligence) doesn't change, but process changes can dramatically boost his final score (outcome)," Xu says. Below is his share, which we've re-edited from the original with his corrections. This piece focuses on "how to build an effective cognitive process for an Agent."

Three Methods: Installing a "Heart" for the Agent

Xu believes many people, upon first encountering Agents, feel puzzled: why is it so slow, so clumsy, going back and forth for several rounds just to look something up, far inferior to asking ChatGPT and getting an answer in one second.

But this "slowness" precisely reveals a profound shift:

Agent process architecture is moving away from pursuing the one-shot, intuitive fast thinking of large language models (LLMs), toward designing a structured, verifiable slow thinking.

The core of this "slow thinking" is the process we design for AI.

• Books recommended by Changpeng Xu

LLMs' native thinking mode is "divergent" and "flat." When facing a real, complex task, their long-chain reasoning is fragile — easily "veering off course" at some intermediate step, or simply "forgetting" the original goal.

Designing processes — Planning, Chain-of-Thought (CoT), or even more complex Tree of Thoughts — is essentially forcibly constructing a "logical scaffold" for AI's chaotic thinking process.

"Planning" breaks down a goal too massive to think through at once — say, building a skyscraper — into a series of clear, ordered, executable steps: Step 1: lay the foundation; Step 2: build the structure; Step 3: top it off. It ensures every action AI takes serves the final goal.

"Chain-of-Thought" guarantees rigorous internal logic at each step, somewhat like an Internal Construction Manual: rebar must be tied this way, concrete must be C50 grade, forcing AI's reasoning process to be tightly interlocked.

This "logical scaffold" dramatically raises the ceiling of AI's ability to solve complex problems.

The second method addresses LLMs' limited attention.

Designing processes like Reflection and Summarization is essentially creating an "efficient compression algorithm" for AI's memory.

Consider a travel planning case: when an Agent using browser-use discovers that "Forbidden City tickets are sold out," the Reflexion process is triggered. But the Agent won't stuff all the lengthy, raw information — the full HTML code returned by the official website, popup notifications, etc. — into its already precious "memory."

If it did, its context window would quickly be bloated with useless information. Instead, it initiates a "memory compression," distilling this failed interaction into a single high-information-density conclusion, and stores it as an "experience" in memory: Forbidden City tickets require booking one week in advance; not feasible this week.

This process is a "lossy but extremely effective" compression. It discards 99% of irrelevant details to preserve, with minimal context space, information 100% critical to future decisions.

This "compression algorithm" gives AI "long-term memory" that is dynamic, allowing it to handle longer timelines and complete more complex tasks within limited attention scope.

The third method is designing "tools" to connect the model to the real world.

However exquisitely designed a process may be, if it's completely isolated from the real world, it's merely a castle in the air. Therefore, the process must have the ability to interact with the world — hence the concept of Tools.

Tools aren't a concept parallel to process; they're more like the process's "neural tendrils."

The ReAct framework is one that deeply binds thinking with action (tool calling). Driven by this framework, when AI realizes during thinking that "my internal knowledge is insufficient to support the next decision," it proactively extends a "search_api" to connect to the internet, feeds dynamic objective facts back to its brain, and continues thinking.

Therefore, the primary responsibility of architecting an Agent is designing the model's thinking structure, memory mechanism, and paradigm for interacting with the world. It combats the model's forgetting and confusion through two core mechanisms.

1. Efficient information compression

As in the Reflexion process, it doesn't stuff lengthy failure logs directly into memory, but distills them into a single high-information-density lesson learned. This is a lossy but efficient compression, preserving the most critical decision information at extremely low token cost.

2. Precise selective injection

Before every Think step, the process acts like a top surgical instrument nurse, precisely judging which historical experience we most need at this very moment, which tool we most need, then combining this information into a clean, efficient context to hand to the LLM for processing.

Two Foundational Understandings: Information Theory and Methodology

Here we need to trace back to two important theories:

Why is the cycle designed for Agents — from thinking -> action -> observation — fundamentally effective?

We need to step outside the AI paradigm and understand "cybernetics" and "information theory."

First, cybernetics. Cybernetics manifests how Agents "approach" solutions step by step.

Cybernetics has two systems: open-loop systems and closed-loop systems.

A typical open-loop system is like an old-fashioned heater with a timer. You set it to run for an hour, expecting it to warm the room, but it has no ability to sense "current room temperature." Therefore, if it's sunny today, the room will be stifling after an hour. Its fundamental flaw is "lack of feedback." This is precisely the working mode of standard chatbots: receive instructions and generate results in one shot, without verifying whether the result actually solves the problem.

A classic closed-loop system is the refrigerator. The refrigerator's core task is "maintaining the refrigerator compartment at a constant 5°C."

1. Goal: User-set "5°C."
2. Sensor: Internal thermometer, continuously observing the actual current temperature.
3. Controller: Temperature control chip, thinking "Is there deviation between current temperature and target temperature?"
4. Actuator: Compressor. Once the controller detects deviation (say, temperature rises to 6°C), it commands the compressor to act.
5. Feedback loop: Compressor working causes temperature to drop; sensor feeds new temperature back to controller; controller finds deviation eliminated (back to 5°C), so commands actuator to stop.

We can clearly see that the steps by which an Agent approaches its goal correspond one-to-one with the refrigerator's internal operating system.

1. Goal: User's instruction
2. Sensor: Observation step, obtaining results returned by tools
3. Controller: Thinking step, LLM conducting reasoning and planning
4. Actuator: Action step, calling tools
5. Feedback loop: Feeding observation results as input to the next round of thinking

"Information theory," meanwhile, reveals what an Agent should "do" when exploring complex and unknown problems.

Information theory defines "entropy" as a measure of uncertainty. The greater a system's information, the smaller its uncertainty, and the lower its entropy value.

The process of solving problems can essentially be viewed as a "reducing entropy by acquiring effective information" process.

When an Agent faces complex work, it's conducting an "entropy reduction" operation in an abstract problem space. Every action-observation cycle is a scientific experiment, aimed at acquiring more information about uncertainty. When "uncertainty" is completely eliminated, the sole path to the answer becomes clear.

In summary, cybernetics provides Agents with the ability to correct toward goals. Information theory defines the core theory for Agents exploring unknown spaces.

These two theories are the scientific foundations we must understand for how Agents operate.

Three Breakthroughs: Boosting Agent Performance

From here we've clarified that the core work of architecting an effective Agent includes:

1. Designing AI's thinking process

Defining how AI plans, decomposes, reasons, and reflects. You're not designing a prompt, but AI's "cognitive kernel" and "code of conduct."

2. Empowering AI's action tools

Forging hands and feet for AI to interact with the physical and digital worlds. Keenly identifying information bottlenecks in the process, and creating or connecting appropriate tools to extend AI's capability boundaries.

3. Constructing AI's decision context

Not being a context porter, but through exquisite process design, ensuring that at every decision moment, AI's attention is precisely focused on the most valuable information.

But now this powerful "slow thinking," while improving result quality, also brings a new engineering challenge: execution efficiency.

How can Agents pursue high quality while also achieving high performance? Frontline engineering practice is seeking breakthroughs from several key dimensions.

1. Architecture selection and pruning

Not all tasks require complex ReAct loops. Practice has found that for scenarios solvable in one or two steps, using LLMs' built-in tool-calling paradigm is more efficient. This reduces token consumption and end-to-end latency.

2. Parallelized execution

When an Agent's planning result contains multiple "subtasks with no dependencies" (for example, querying Beijing weather and searching popular restaurants), modern Agent frameworks like LangChain already support parallel tool calling. Leveraging asynchronous I/O capabilities, multiple API requests that would otherwise wait in serial can be fired concurrently, reducing total time from "sum of all task durations" to "duration of the longest task." This is the most significant method for improving execution efficiency.

3. Model specialization and routing

Single-model strategies are being phased out. The better practice is adopting a mixed-model strategy.

For example, using a lightweight, high-speed model (like gemini-2.5-flash, claude-haiku-4.5) for high-frequency, low-complexity tasks like "planning," routing, or simple tool selection in the process; only calling heavyweight, high-cost core models (like gpt-5-pro, gemini-2.5-pro) when encountering complex nodes requiring deep reasoning. A layered strategy can complete most process steps at lower cost and latency.

4. Efficient memory architecture

LLMs' limited context windows mean we cannot stuff all historical information into prompts. Therefore, designing an efficient "memory retrieval" mechanism is crucial. This is not merely a technology choice (like using vector databases), but a strategy design. How to compress, distill, and structurally store conversation history, past action trajectories, successful experiences, and failed lessons.

—At the End—

After we've installed a "heart" and "accelerator" for Agents, the greatest future challenge is "building a brain" for the model.

The industry's most cutting-edge explorations are precisely focused on the following directions:

1. Cognitive dispatch center: intelligent workflow orchestration

A mature Agent should be like an experienced project manager: faced with different tasks, it can autonomously plan and orchestrate the optimal execution workflow. This is the core idea of "dynamic workflow orchestration."

Anthropic's newly released Skills feature is the best practice of this idea, representing that Agents' thinking has evolved from tactical decisions of "what to do next" to strategic planning of "how to achieve the final goal step by step."

2. Spec-driven layered architecture: from individual to team

For complex tasks, layering and divide-and-conquer are inevitable choices. The key lies in how multiple Agents can collaborate efficiently and reliably. The answer is Spec-Driven.

A "planning Agent's" primary task is generating a detailed, clear technical specification — like an engineering blueprint — becoming the sole contract for all downstream "execution Agents" to work from. This is precisely the core idea explored by cutting-edge projects like GitHub's open-source SpecKit, marking that Agent collaboration is evolving into traceable, verifiable "modern software engineering."

Ps: For extended reading on this section, see our previous coverage on multi-agent collaboration: Former AWS Scientist Teaches Agents to Cooperate, Compete, and Even Argue | Talking Swarm Intelligence with OpenAgents Founder Raphael Shu

3. Just-in-time code generation: from "using tools" to "creating tools"

Traditional tool use lets Agents make multiple-choice selections from a fixed toolbox. The future direction is letting Agents create their own tools. Research like CodeAct (CodeAct: A Multi-Turn Code Agent with In-Context Learning) is leading this trend.

When facing situations with no existing tools available, Agents dynamically generate a snippet of Python code (a micro-tool), execute it in an isolated environment, and advance the task based on execution results. This evolves the Act step from "calling APIs" to "code generation and execution" with unlimited possibilities, infinitely expanding Agents' capability boundaries.

These most cutting-edge explorations are what make architecting an "Agent" the most exciting work of the future.

References and Extended Reading

Part 1: Core Academic Papers

1. Chain of Thought (CoT) Title: Chain-of-Thought Prompting Elicits Reasoning in Large Language Models Link: https://arxiv.org/abs/2201.11903 Summary: First systematic proof that adding "thinking process" examples in prompts can elicit large language models' ability to solve complex reasoning tasks. Foundational work for structured prompting.

2. Tree of Thoughts (ToT) Title: Tree of Thoughts: Deliberate Problem Solving with Large Language Models Link: https://arxiv.org/abs/2305.10601 Summary: Extends linear chain-of-thought to tree-shaped multi-path exploration. Allows Agents to explore multiple different reasoning paths at a thought node, using self-evaluation to determine the optimal solution — a more powerful structured thinking process.

3. Reflexion Framework Title: Reflexion: Language Agents with Verbal Reinforcement Learning Link: https://arxiv.org/abs/2303.11366 Summary: First framework-izes and automates the concept of "self-reflection/review." Proves that Agents can iteratively optimize their own behavior through "linguistic reflection" on past failures, without retraining the model.

4. ReAct Framework Title: ReAct: Synergizing Reasoning and Acting in Language Models Link: https://arxiv.org/abs/2210.03629 Summary: Proposes the milestone Thought -> Act -> Observe framework, deeply interweaving "Reasoning" and "Acting." The theoretical cornerstone of modern Agent frameworks interacting with the external world.

5. CodeAct Framework Title: CodeAct: A Multi-Turn Code Agent with In-Context Learning Link: https://arxiv.org/abs/2402.01030 Summary: Eloquently proves that Agents' Act step can evolve from "calling predefined tools" to "generating code on the fly and executing it," dramatically expanding Agents' capability boundaries.

Part 2: Industry Resources and Practical References

1. Foundational survey: Lilian Weng's LLM-powered Autonomous Agents Link: https://lilianweng.github.io/posts/2023-06-23-agent/ Summary: Written by OpenAI's head of applied research, the most widely cited Agent survey in the industry. The first stop for building a global cognitive map of this field.

2. Core concept: LLM Operating System by Andrej Karpathy Summary: In multiple talks, Andrej Karpathy (OpenAI founding member) presciently proposed that LLMs are the "CPU" of a new computing paradigm, while Agent frameworks play the role of the "operating system."

3. Mainstream development frameworks: LangChain & LlamaIndex Links: https://python.langchain.com/ and https://www.llamaindex.ai/ Summary: The two de facto standard libraries for building Agent applications today. LangChain focuses on process (Chain & Agent); LlamaIndex focuses on data (RAG). The preferred tools for developers putting theory into practice.

4. Cutting-edge architecture exploration: Specification-Driven Collaboration Summary: The key to solving multi-Agent collaboration lies in establishing a machine-readable "contract" or "specification." Representative projects in this direction include AI IDE Kiro (https://kiro.tech/) and open-source toolkit Spec Kit (https://github.com/braid-work/spec-kit).

5. Intelligent orchestration of complex tools Summary: A powerful Agent should be able to autonomously, multi-step plan and call a series of tools to achieve a complex goal. Anthropic's Skills feature (https://www.anthropic.com/news/skills) elevates Agents' tool-use capability from "single call" to "intelligent orchestration" — the best industry practice in this direction.

6. Emergence of social behavior: Stanford's "Westworld Town" Paper: Generative Agents: Interactive Simulacra of Human Behavior (https://arxiv.org/abs/2304.03442) Summary: A phenomenal AI experiment demonstrating how Agents, once endowed with memory and reflection capabilities, can emerge convincingly spontaneous behaviors in a virtual society. Excellent extended reading for multi-Agent system exploration.

Image sources | Unsplash

Graphics | Youmind

—Call for Submissions—

If you're also a builder exploring AI products on the front lines, we'd love to hear about your practice.

Contact via the WeChat card below.

Recommended Reading