AI Agent

You may be used to this kind of interaction: you ask a question, and the AI gives an answer.

• You ask it to write an article, and it writes an article.

• You ask it to translate a sentence, and it translates a sentence.

In this mode, the AI is more like a consultant — it gives you advice, but doesn't directly do things.

But what if the task is slightly more complex? For example: help me check tomorrow's weather in Beijing. If the temperature exceeds 25 degrees, recommend a short-sleeved shirt within a budget of 300 yuan, then compile the results into an email and send it to my boss.

With an ordinary conversational AI, you have to break it down into several steps:

• Step 1: Check tomorrow's weather in Beijing.

• Step 2: If it exceeds 25 degrees, recommend a short-sleeved shirt within 300 yuan.

• Step 3: Write an email to my boss with the content ...

Each step requires you to manually move forward.

andAI AgentThe idea is: you just say "help me do this" once, and it will handle the rest by itself.

It will automatically determine what needs to be done, which tools to call, in what order to execute them, and how to adjust when problems arise, until the task is complete.

Simple understanding: a regular LLM is a strategist that gives you advice; an AI Agent is an executor that takes the goal and goes get things done on its own.

What is an AI Agent?

An AI Agent is an autonomous system that can perceive its environment, make decisions, and take actions.

A more academic definition is:An Agent is an entity situated in an environment; it perceives the environment through sensors and acts upon the environment through actuators to achieve a set of goals.。

This definition sounds a bit abstract, so let's break it down in plain language.

Agent vs. Regular LLM

First, take a look at a comparison table:

Take a concrete example: "Help me book a flight from Shanghai to Beijing tomorrow, with a price under 1,500 yuan."

A regular LLM might answer: "Okay, I can write you a snippet of code to query flight prices, or tell you which website to check." But it won't actually search for flights, let alone book one for you.

A qualified Agent, on the other hand, will:

• 1. Understand the goal: Book a flight from Shanghai to Beijing tomorrow, under 1,500 yuan.

• 2. Decide on an action: I need to call a flight query API.

• 3. Execute the action: Call the API and get the list of flights.

• 4. Observe the results: Got 10 flights, 3 of which are under 1,500 yuan.

• 5. Think again: Which one to choose? Maybe need to check departure and arrival times, or ask the user for preferences.

• 6. Continue acting: Maybe call another API to check on-time rates, or directly recommend options to the user.

• 7. Complete the task: Help the user lock in a seat and generate an order link.

See the difference?A regular LLM gives you answers; an Agent gives you results.。

Core Capabilities of an Agent

A complete Agent typically possesses the following three core capabilities:

• Perception, means the Agent can see what's happening. For example, a user sends a message, an API returns a result, or a new file is added to the file system—these are all perception inputs.

• Decision, means the Agent decides what to do next based on the perceived information. Should it answer the user directly? Does it need to call a tool? Does it need to break a big task into smaller subtasks? These are all decisions.

• Action, means the Agent actually carries out the decisions. Calling a search API, reading a file, sending an email, operating a database—these are all actions.

Basic Architecture of an Agent

Now let's look at the Agent's standard "four-piece puzzle": brain, tools, memory, and planning.

First, let's look at an architecture diagram:

Brain: LLM as the Reasoning Core

An Agent's brain is typically a large language model, such as GPT-4, Claude, Llama, etc.

This LLM is responsible for:

• 1. Understanding the user's intent: when the user says "help me book a ticket," what does he really want?

• 2. Making decisions: what should I do next?

• 3. Generating tool call parameters: what parameters are needed to call a flight query API?

• 4. Organizing the final answer: now that enough information has been collected, how do we give the user a clear summary?

The LLM is the core of an Agent, but not everything—just like the human brain is important, but you still need hands and feet to get things done.

Tools: Expanding the Boundaries of AI Capabilities

Native LLMs have two obvious limitations:

• 1. Knowledge cutoff: it doesn't know what happened after training concluded.

• 2. No interaction capability: it can't directly read files, query databases, or call APIs.

Tools are designed to solve these problems.

Common tool types:

Giving tools to an Agent is like equipping a person with a computer—it instantly goes from only being able to think to being able to act.

Memory: Short-term vs. Long-term Memory

LLMs are naturally amnesic—every conversation starts fresh unless you stuff the context in.

And an Agent needs to remember a lot:

• Short-term memory: What did the user just say? What tool did I call in the last step? What result did I get?

• Long-term memory: What are the user's preferences? How were similar tasks handled in the past? What lessons have been learned?

Common implementation approaches for memory systems:

A good memory system can make an Agent seem like it remembers you, rather than acting like it's meeting you for the first time every time.

Planning: Task Decomposition

Complex tasks won't be completed in a single step; an Agent needs to be able to break a big goal down into smaller steps.

For example: Help me plan a birthday party for 10 people.

The Agent might plan it like this:

• 1. First clarify: What's the budget? When is it? Where is it? What are the preferences of the guest of honor?

• 2. Then: Look up nearby venues.

• 3. Next: Design the menu.

• 4. After that: Make a shopping list.

• 5. Finally: Generate a schedule.

Common planning strategies:

• Chain-of-Thought: Think through step by step—what to do first, what to do next.

• Tree-of-Thought: Consider multiple possible paths at the same time and choose the optimal one.

• Reflection: After completing a step, look back and check whether there are any issues and whether adjustments are needed.

Tool Use / Function Calling

Tool calling is the most fundamental and important capability of an Agent.

Let's start by explaining what it is.

What is Function Calling?

Simply put:Function Calling is when the LLM outputs a structured JSON telling you which function it wants to call and what parameters to pass.。

It's not that the LLM actually executes the function—it just tells you that it wants to call it, and you still have to do the execution.

The whole process usually goes like this:

• 1. You tell the LLM: "Here are some functions you can call. Each function's name, parameters, and purpose are..."

• 2. The user sends a message: "Help me check tomorrow's weather in Beijing."

• 3. The LLM replies: "I want to call the get_weather function, with parameters city='Beijing', date='tomorrow'."

• 4. You call the function (actually querying the weather API) and get the result.

• 5. You feed the result back to the LLM: "The previous function call returned: temperature 25 degrees, sunny."

• 6. Based on this result, the LLM gives the user a natural language answer: "Beijing will be sunny tomorrow, 25 degrees, very comfortable."

See? The LLM does the thinking, and you do the executing.

Defining a Tool's JSON Schema

To make the LLM call tools, you first need to tell it what tools are available.

This process of telling is describing the functions with JSON Schema.

Let's look at a standard function definition format:

Key points:

• description is very important — the LLM relies on this description to understand what the tool does and when to use it.

• Parameters should also be described clearly — for example, if unit has an enum constraint, the LLM knows it can only choose from these two values.

• required marks the required fields — the LLM will ensure these parameters always have values.

Hands-on Code: Adding Search and Calculation Tools to AI

Now let's write a complete, runnable example.

For demonstration, we use Python to simulate the complete Function Calling flow.

Although this example is simple, it demonstrates the complete closed loop of Function Calling:

Understand → Decide → Call the tool → Observe the result → Generate a response.

In a real project,_decide_actionthis step would be replaced with a real LLM call, letting the model decide which tool to use and what parameters to pass.

ReAct Planning Loop

With tool-calling capabilities in place, the next question is: when to stop?

Simple tasks can be completed in one step, but complex tasks often require multiple rounds of iteration.

This is the problem the ReAct framework aims to solve.

Thought → Action → Observation

The name ReAct comes from the combination of Reasoning and Acting.

Its core idea is simple: let the Agent, like a human, think one step, act one step, observe, and then repeat this loop until the task is complete.

Let's look at a flowchart:

Each cycle consists of three steps:

Then return to Thought — based on the observed results, decide what to do next.

This loop continues until the Agent determines that the task is complete, at which point it exits the loop and provides the final answer.

Let's use a concrete example to see how ReAct works:

• User question: In what year was SpaceX founded? What was the name of its first rocket to successfully reach orbit?

• Thought 1: I need to find the founding year of SpaceX and the model of its earliest rocket to complete an orbital launch. This information may come from different sources, so it's best to search with keywords covering both at once.

• Action 1: Call web_search to query "SpaceX founding time first orbital rocket".

• Observation 1: The search result summary shows: "SpaceX (Space Exploration Technologies Corp.) was founded in 2002 by Elon Musk. Its first rocket to successfully enter Earth orbit was Falcon 1, which succeeded on its fourth test flight on September 28, 2008." (The information is complete and covers both sub-questions.)

• Thought 2: The search results already provide both the founding year (2002) and the first orbital rocket (Falcon 1). There is no ambiguity and the information is credible. No additional search is needed.

• Final answer: SpaceX was founded in 2002, and its first rocket to successfully reach orbit was Falcon 1, which achieved this milestone on September 28, 2008.

• Note: See? Every step has a clear "Thought", "Action", and "Observation", and the Agent judges for itself when to stop — here it took only 1 round of action to collect all the needed information, so it went directly to the final answer without extra loops.

Loop Termination Conditions

The ReAct loop cannot run indefinitely; it needs a termination condition.

Common termination conditions:

When designing an Agent, be sure to have a "maximum steps" safety valve — otherwise, it may spin in circles and never stop.

Memory System Design

When an agent works for a long time, it encounters a problem: the context window cannot hold all the conversation history.

At this point, a good memory system is needed.

Conversation History: Short-term Memory

The simplest memory is to completely save the conversation history.

Every time, all previous messages are stuffed into the LLM, so that it can remember what just happened.

But this approach has an obvious drawback: the context window of LLM is limited.

For example, GPT-4 is 8K or 32K, and Claude is 200K—though large, it's still not infinite.

It’s fine when the conversation is short, but once it gets very long, or each round of tool calls returns a lot of content, it quickly runs out of space.

Vector Database: Long-term Memory

When there is too much to remember and the context can't contain it, a common solution is:Store memories in a vector database, and "retrieve" the relevant ones when needed.。

This approach is called RAG (Retrieval-Augmented Generation), and it applies equally to Agents.

Workflow:

• Whenever a memory is generated (what the user said, the result returned by the tool, the Agent's thinking), it is converted into a vector (Embedding).

• 2. Store this vector in the vector database.

• 3. When the Agent needs to recall, also convert the current question into a vector.

• 4. Search the vector database for the few "most similar" memories.

• 5. Only put these few relevant memories into the LLM context.

This way, even if there are ten thousand historical memories, only the most relevant ones need to be retrieved and used.

Summary-Based Memory Compression

Another memory optimization scheme:Do not store the full conversation texts; instead, a large model periodically generates concise summaries of historical sessions, and only the summaries are persistently saved.。

Original long dialogue:

• User: Help me check the weather.

• Agent: Which city to check?

• User: Beijing.

• Agent: Which day?

• User: Tomorrow.

• ……

Compressed summary:

用户需要查询北京明日天气，Agent 先后确认城市与日期，用户明确查询时间为明天。

This approach can significantly reduce Token overhead: a full conversation that originally occupied 500 Tokens only needs a 50-Token summary to retain core information.

Production projects usually use multiple solutions together, managing conversation memory in layers:

• Recent latest dialogues: fully retained, directly sent into the model context;
• Distant historical dialogues: uniformly generate summaries, replacing the original text with summaries;
• Long-term key information: stored in a vector database, retrieved on demand.

Mainstream Agent Frameworks

After understanding the principles, you can write your own Agent, or use existing frameworks.

The most popular ones now are:

LangChain Agents

LangChain is currently the most popular LLM application development framework, and it has a built-in Agent system.

Core concepts:

Agent: the brain, decides what to do.

Tools: list of tools.

Toolkits: tool suites (for example, bundling several database-related tools together).

AgentExecutor: the executor, responsible for running the ReAct loop.

LangChain's advantage is its rich ecosystem — many ready-made tool integrations, out of the box.

The disadvantage is that it sometimes feels a bit heavy, with many layers of abstraction, making debugging difficult when problems arise.

LlamaIndex Agents

LlamaIndex (formerly called GPT Index) focuses more on data connection — connecting your private data (documents, databases, APIs) to the LLM.

Its Agent strengths are:

• 1. Querying structured and unstructured data.

• 2. Routing between multiple data sources.

• 3. Doing document question-answering (RAG).

If your Agent needs to work extensively with "your data," LlamaIndex is a good choice.

AutoGPT Principles

AutoGPT is a project that became popular in early 2023, and its characteristic is: full autonomy.

You give it a big goal (e.g., "help me build a website"), and it will itself:

• 1. Generate a task list.

• 2. Execute tasks.

• 3. Self-reflect.

• 4. Adjust the plan.

• 5. Continue moving forward.

AutoGPT let many people see the power of "autonomous Agents" for the first time, but it also exposed many problems with Agents:

It often keeps running in the wrong direction without stopping losses in time.

It is prone to falling into infinite loops and repeating the same actions.

High cost — one run may spend tens of dollars in API fees.

But AutoGPT is very instructive as a proof of concept.

CrewAI Multi-Agent

What we just talked about are single Agents, whereas CrewAI's approach is: let multiple Agents team up and collaborate.

For example, you can define:

Product Manager Agent: responsible for understanding requirements and writing PRDs.

Engineer Agent: responsible for writing code.

Reviewer Agent: responsible for Code Review and providing feedback.

Then let them collaborate like a real team — discuss with each other, assign tasks, and deliver results.

Multi-agent is a very promising direction: a single Agent may make mistakes, but multiple Agents can correct each other and complement one another.

Hands-on: Building an Automated Information-Gathering Agent

Now let's tie together the knowledge points from earlier and write a truly usable Agent.

The Agent we are going to make is calledexample-researcher— give it a topic, and it will automatically search, organize, and generate a research report.

Although this Agent simplifies LLM calls (simulated with rules), the entire workflow is genuinely usable.

You just need to_thinkreplace the method with real LLM API calls, and_search_webreplace it with a real search API, and it can truly help you do research.

Limitations and Failure Modes of Agents

AI Agents are powerful, but they are not omnipotent.

Understanding its limitations helps you use it in the right scenarios and avoid pitfalls.

Common Failure Modes

1. Wrong Tool Selection

When a user asks about the weather, the Agent calls a search; when a user wants to search, the Agent calls a calculator.

This kind of error is very common, especially when tool definitions are not clear enough.

2. Parameter Passing Errors

Wrong date format, missing required parameters, wrong parameter types—these can all cause tool calls to fail.

3. Infinite Loop

The Agent gets stuck in an infinite loop of "search A → not found → search A again → still not found → search A once more…"

4. Premature Stopping

Before collecting enough information, the Agent decides it's "enough" and gives an incomplete answer.

5. Hallucination

The Agent may fabricate tools that don't exist, parameters that don't exist, or make up fake search results.

6. Lack of Common Sense

Sometimes the Agent does things that seem foolish to humans—for example, when a user says "book me a flight for tomorrow," the Agent looks up what "tomorrow" is, but it should actually use today's date plus one day.

How to Make Agents More Reliable

To address these problems, the industry has some commonly used mitigation strategies:

A practical suggestion: don't aim for full autonomy from the start. Begin with a human-in-the-loop mode—the agent proposes what to do, and a human confirms before it executes. Once you're confident in it, gradually delegate more authority.