AI Agent — From an Ordinary Chatbot to a System That Can Do Something

Some time ago I was stuck thinking about one thing: AI chatbots are actually just machines that answer questions. He can explain how to cook fried rice, summarize a book, or write code. But it couldn't really do anything — it couldn't check the weather, send email, or run commands on my server. Then the term AI Agent appeared, and it turned out to be a very interesting concept: what if we gave AI the ability to think, decide, and then act?

This concept is like giving extra wheels to a bicycle. Ordinary chatbots can only show maps. The AI ​​Agent can drive down the road, turn the steering wheel, and hit the brakes if necessary. He doesn't just know; he can do. In this article, I want to share my understanding of AI Agent, how it works, and why it is starting to become the foundation of many modern applications.

What is the difference between a chatbot and an AI agent?

Imagine you walk into a restaurant. A chatbot is like a waiter who can only explain the menu: he knows what's available, can recommend dishes, and answer your questions about ingredients. But he couldn't cook, couldn't take orders, and couldn't ask the kitchen for extra chili.

AI Agent is a servant who can do it all. He takes the order, saves it, takes it to the kitchen, checks the stock of ingredients, and notifies you again if the dish you ordered is out of stock. In essence, the AI ​​Agent doesn't just answer — it takes action to achieve the goal.

In a technical context, chatbots work in a cycle: user input → model generates text → output to the user. AI Agent works in several cycles: accept the task → think → choose action → run the tool → observe the results → think again. This cycle repeats until the goal is achieved.

Three Main Components of an AI Agent

In my opinion, AI Agent can be understood through three main components. All three must be present so that the system can truly be called an agent, not just a slightly smarter chatbot.

First, the language model. This is the brain. It can be GPT-4, Claude, Gemini, or local models such as Qwen and Llama. It is this model that understands instructions, plans steps, and decides what to do next.

Second, memory. The agent needs to remember what has happened. There are two types of memory: short-term which stores the current conversation, and long-term which stores facts, preferences, or learning outcomes from previous sessions. Without memory, the agent will be trapped in the same loop, like someone who forgets to have ever asked.

Third, tools. Tools are the agent's hands and feet. Through tools, AI can search the internet, read files, run code, send emails, or even execute commands in the terminal. Without tools, AI can only talk. With tools, AI can act.

ReAct Workflow — Think, Act, Observe

One of the most common mindsets used in AI Agents is ReAct, short for Reasoning and Acting. This pattern invites the model not to answer immediately, but to think first, act, then observe the results.

A simple example like this. For example, I ask: "What is the temperature in Semarang now, then write me a sentence to update your social media status?" Ordinary chatbots might answer as they are, even guessing. Agent with ReAct will perform the following steps:

1. Thinking: Users want to know Semarang temperature and status sentences.
2. Act: Call the weather tool for the city of Semarang.
3. Observe: The tool returns temperature data of 31 degrees Celsius and cloudy.
4. Think again: Enough data, now make sentences light and personal.
5. Answer: "Semarang today is 31°C and is cloudy. The heat is still tolerable, just don't panic."

ReAct makes AI not only linguistically intelligent, but also connected to reality. It knows when to look for external information and when to stop.

Simple Example in Terminal

To make it more concrete, I want to show how a simple agent can be created in Python. Here I use a manual pattern to make it easy to understand, without a big framework like LangChain.

import requests

API_URL = "http://localhost:8080/v1/chat/completions"

def get_weather(city):
    # Simulasi tool cuaca
    fake_data = {"Semarang": "31°C berawan", "Jakarta": "33°C cerah"}
    return fake_data.get(city, "Data tidak tersedia")

def ask_llm(messages):
    response = requests.post(API_URL, json={
        "model": "qwen2.5-coder-7b",
        "messages": messages
    })
    return response.json()["choices"][0]["message"]["content"]

messages = [
    {"role": "system", "content": "Kamu adalah asisten yang bisa memanggil tool cuaca. Jika butuh data cuaca, balas dengan [WEATHER:kota]."},
    {"role": "user", "content": "Cuaca di Semarang gimana?"}
]

reply = ask_llm(messages)
if reply.startswith("[WEATHER:"):
    city = reply.split(":")[1].rstrip("]")
    weather = get_weather(city)
    messages.append({"role": "user", "content": f"Data cuaca: {weather}. Silakan jawab."})
    final = ask_llm(messages)
    print(final)
else:
    print(reply)

The script above is very simple, but the essence of the agent is already visible: the model decides when to call the tool, then the results are returned to the model to be formed into the final answer. In real applications, this process is much more complex, with tool call parsing, error handling, and retry mechanisms.

Tool Use: Giving a Hand to AI

The most interesting part of AI Agent in my opinion is tool use. Without tools, AI can only generate text from knowledge that already exists in the model. With tools, AI can:

• Search for the latest information on the internet via search engines.
• Reading and writing files on the local system.
• Execute a query to the database.
• Send emails or messages via API.
• Call another AI model for a specific task.

My personal experience, tool use feels like hiring an assistant who previously could only talk, now can actually take care of housework. For example, I once created a small script that asked AI to check server logs, filter out lines that contained errors, then summarize them in one sentence. What previously required several manual commands, can now be an automatic flow.

But there is an important note: the more tools provided, the greater the risk. AI may call the wrong tool, provide dangerous arguments, or repeat actions endlessly. Therefore, permission constraints and input validation are very important.

When is AI Agent Useful, When is It Overkill

In my opinion, not all problems need to be solved with an AI Agent. There are times when a simple solution is actually better. AI Agent is most useful when:

• The task requires several steps and decisions along the way.
• External data is required that cannot be predicted by the model.
• There is a need to automate repetitive workflows.

On the other hand, an AI Agent can be redundant if its job is only to answer one simple question, or if the system can already be solved with ordinary rule-based automation. Using AI Agent to turn on the bedroom lights might be cool, but the switch would still be faster.

Building a Local AI Agent

One of the reasons I'm interested in AI Agent is because we can build it ourselves at home. With on-premises models like Qwen, Llama, or Mistral, we don't need to send sensitive data to cloud services. Everything can run on a simple home server.

There are various stacks that can be used. Some use Ollama to run models, LangChain or LlamaIndex for orchestration, and ChromaDB or Qdrant to store long-term memory. Or, for those who like full control like me, you can write an agent from scratch using Python and a local API endpoint.

The most important thing is not the framework, but understanding the cycle of thinking and acting. If we understand ReAct, memory, and tool use, we can build agents with any tools available.

Conclusion

AI Agent is a natural step after chatbots. It transforms AI from simply answering questions into a system that can plan, act, and learn from the results. With three main components — language models, memory, and tools — agents can handle tasks that are more complex and more connected to the real world.

For me, understanding AI Agent is like learning to drive after just hitchhiking. Previously we only saw the road through the window. Now we can hold the steering wheel, choose a route, and get to our destination. Of course it takes practice, and not all journeys are smooth. But at least, we are no longer just sitting around waiting for an answer.

If you have ever tried building your own AI Agent, or even this is your first time hearing this term, I want to hear your opinion in the comments column. Don't forget to share this article if you find it useful.