If you have already read some of my blogs, you probably know that I don't really like learning things as if they are magic. I usually need to understand the why and the how behind something before it really makes sense to me. Otherwise, my brain just refuses to accept it.

So even though I had already worked with some agentic systems and multi-agent concepts, I became more curious about how all these ideas were actually connected. Multi-agent systems was also one of the subjects I came across during my MSc, so I had already encountered some of these concepts before. But when I started seeing all these ideas coming together in what we now call Agentic AI, I started wondering: How did we actually get here? Why did these particular concepts come together? And what changed to make agentic systems suddenly become such an important part of how we think about building AI systems?

That curiosity is what made me spend the past few days going through a lot of material around agentic systems, multi-agent systems, complex systems, and how modern AI systems are being designed.

The more I went into it, the more I realized that the idea of an "AI agent" isn't something that suddenly appeared with ChatGPT or large language models. There are several ideas that have been developing across computer science for quite some time, and some of them come together in a really interesting way when we look at agentic systems.

So I wanted to share a few interesting things I found along the way and, more importantly, how I started connecting the dots between them.

One interesting place to start: nature

One area that I found particularly interesting while exploring these ideas was nature-inspired computing.

The basic idea is quite simple: instead of always trying to solve a problem by directly engineering the solution, we can also look at how nature handles similar problems.

Nature contains some remarkably sophisticated systems. Ant colonies find efficient paths to food without a central ant controlling the colony. Birds move together in large groups without a single bird commanding every movement. Bees collectively make decisions about where to search for food. An ecosystem contains countless organisms continuously interacting, competing, cooperating, and adapting.

What makes these examples interesting is that there isn't necessarily a single entity controlling the entire system. Instead, individual entities interact with their environment and with one another, and surprisingly sophisticated behavior can emerge from those interactions.

That naturally leads to another question:

What exactly is a system?

First, what is a system?

At a high level, a system is simply a collection of components that interact with one another to produce some behavior or outcome.

But not every system behaves in the same way. We can roughly think about systems at three different levels.

Simple systems

These are systems where the relationship between cause and effect is relatively straightforward.

A calculator is a good example. You provide 2 + 3, and you get 5. The behavior is predictable.

A simple physical system such as a pendulum can also often be described using well-understood rules. Once we know the relevant state and rules, we can reasonably predict what happens next.

Complicated systems

Now consider something like a modern aircraft or a large data center.

There may be thousands or even millions of components involved. The system can be extremely difficult to understand simply because of the number of components and relationships involved.

But there is an important distinction:

Complicated does not necessarily mean complex.

A complicated system can still be engineered and decomposed into components whose behavior we understand. If we had enough information and computational capability, we could theoretically model the interactions between those components.

Complex adaptive systems

This is where things become much more interesting.

A Complex Adaptive System (CAS) is not simply a complicated machine with more components. It is a system where the interactions between components can produce behavior that is difficult to predict from the individual components alone.

The components interact, respond to their environment, adapt, and their behavior can change based on previous interactions. Sometimes completely new patterns emerge from those interactions.

Think about the Internet, financial markets, biological ecosystems, cities, or social networks. You cannot simply look at one component and say, "This is exactly what the entire system will do."

The behavior emerges from the interactions. And this idea of emergent behavior becomes particularly interesting when we start talking about agents.

So, what exactly is an agent?

At its simplest, an agent is an entity that can perceive its environment and take actions within that environment in pursuit of some objective.

The environment could be physical. A robot navigating a room is an agent.

It could be digital. A software program monitoring a server can be an agent.

Or it could be simulated. An agent inside a city simulation could represent a person, a vehicle, or a business.

The important part isn't whether the agent is a human, robot, or piece of software. The important relationship is:

Agent ↔ Environment

The agent observes something about its environment, makes a decision, and takes an action that changes either itself, its environment, or both.

This gives us a simple loop:

Perceive → Reason → Act → Learn

From an agent to an agent-based system

Once we have multiple agents interacting inside an environment, we can start thinking about an Agent-Based System (ABS).

Instead of designing one large centralized program that explicitly dictates everything that should happen, we define individual agents with their own goals, states, behaviors, rules, perceptions, and actions, and then allow them to interact.

For example, imagine simulating traffic in a city.

Instead of writing one giant program that calculates exactly where every vehicle should move, we could create thousands of individual vehicle agents. Each vehicle might observe nearby traffic, know its destination, decide whether to accelerate, slow down, or change lanes, interact with other vehicles, receive feedback from the environment, and continue making decisions.

Now something interesting happens.

We didn't explicitly program:

"Create a traffic jam at this location."

Instead, traffic congestion can emerge from the interactions between individual vehicles.

This is one of the fundamental ideas behind agent-based modeling. We model the individual behavior and interactions, and then observe what happens at the system level.

The important part: the agent loop

Agents can be understood through a continuous operational cycle.

1. Perceive

The agent observes its environment. This could come from sensors, user input, files, databases, APIs, or other agents.

2. Reason

The agent interprets what it has observed and determines what to do.

Depending on the type of agent, this reasoning could be as simple as a rule:

If obstacle detected → turn left.

Or it could involve planning and evaluating several possible actions.

3. Act

The agent executes the selected action.

It might move, send a message, modify a database, call an API, trigger another system, or interact with another agent.

4. Learn

The agent observes the outcome and uses feedback to improve future behavior.

This creates a continuous loop:

Environment → Perception → Reasoning → Action → Feedback → Environment

And this loop is much more important than the word "agent" itself.

An agent isn't interesting simply because we call it an agent. It becomes interesting when it can continuously interact with an environment and make decisions within it.

But agents didn't start with Large Language Models

This is probably the part I found most interesting.

When we hear "AI agent" today, it is very easy to immediately think about an LLM calling tools, browsing the web, writing code, or interacting with other agents.

But the underlying concept of an agent is much broader.

One simple approach is rule-based behavior.

For example:

IF temperature > 30
    turn on cooling

IF obstacle detected
    change direction

IF enemy is nearby
    attack

These systems could behave autonomously, but their intelligence was limited by the rules we explicitly provided.

They could react, but they couldn't easily generalize beyond what we had anticipated.

Then agents became more sophisticated

Over time, systems started incorporating ideas such as state and memory, search, planning, utility functions, probabilistic reasoning, decision-making under uncertainty, reinforcement learning, and machine learning.

Instead of explicitly programming every possible situation, we could allow systems to learn patterns or strategies from data and experience.

This was a major shift.

Consider a traditional rule:

If X happens, do Y.

Now compare that with a machine-learning system. Instead of manually writing all the rules, we provide examples and allow the model to learn a relationship between inputs and outputs.

That is extremely powerful.

But it also highlights an important distinction.

Machine learning is powerful, but it is not the whole system

A machine-learning model is usually very good at a particular type of problem. Give it an input, and it produces an output based on patterns it has learned.

For example:

Image → Classification

Text → Prediction

Transaction → Fraud probability

User data → Recommendation

But imagine asking a system to accomplish something like:

"Plan a three-day trip to Colombo for a family of four, staying within a specific budget, find suitable accommodation, check transportation, find activities, compare options, create an itinerary, and adjust it if the weather changes."

That's no longer just a prediction problem.

The system needs to understand the objective, break the objective into tasks, gather information, use external tools, make decisions, compare alternatives, remember previous decisions, react to new information, potentially ask for clarification, execute actions, and evaluate the result.

This is where the idea of agentic systems becomes much more interesting.

From predicting to doing

This is perhaps the simplest way to understand the transition.

Traditional machine learning is often focused on:

Given this input, what should the output be?

Agentic systems are more focused on:

Given this goal, what should I do next?

That doesn't mean ML has become obsolete. Quite the opposite.

Modern agents often rely heavily on machine learning and especially large language models. The difference is that the model becomes one component inside a larger decision-making system.

The model might provide reasoning or interpretation. Other components can provide memory, tools, planning, execution, feedback, and communication.

The system connects these capabilities together.

And this is where LLMs changed the picture

Large language models introduced something particularly useful for agentic systems.

They can work with relatively unstructured human language. Instead of requiring a developer to define every possible rule, we can give the system a high-level objective.

For example:

"Find the cheapest reasonable flight and hotel combination for this trip."

The LLM can interpret the objective, decompose it into smaller tasks, determine which tools might be required, interpret the results, and decide what to do next.

Now imagine connecting that model to tools.

It can search. It can call APIs. It can query databases. It can execute code. It can read documents. It can interact with other software.

And suddenly the model is no longer simply generating text.

It is participating in a closed-loop system.

The emergence of Agentic AI

This brings us to what we commonly call Agentic AI today.

At a high level, I think of an agentic system as something like this:

Goal → Plan → Perceive → Reason → Act → Observe Result → Re-plan → Repeat

The important word here is loop.

A traditional chatbot might follow something like:

User → Model → Response

An agentic system can look more like:

Goal

↓

Understand the goal

↓

Break it into tasks

↓

Choose an action

↓

Use a tool

↓

Observe the result

↓

Evaluate

↓

Decide what to do next

↓

Repeat until the goal is achieved

That is a fundamentally different interaction model.

And then we get to multi-agent systems

Once we accept that one agent can perform a task, another interesting question appears:

Why should one agent do everything?

This is where multi-agent systems become useful.

Instead of creating one enormous agent responsible for every part of a problem, we can create specialized agents.

For example, imagine a travel planning system.

We could have:

• Destination Agent
• Accommodation Agent
• Transportation Agent
• Activities Agent
• Food Agent
• Budget Agent
• Schedule Agent
• Critic Agent

Each agent has a particular responsibility.

The Budget Agent might evaluate whether the proposed plan fits within the budget. The Accommodation Agent might search and compare hotels. The Activities Agent might find things to do. The Schedule Agent could combine all of these into a practical itinerary. And the Critic Agent could examine the final result and identify problems.

Now we are no longer simply building a model.

We are designing a system of interacting decision-making entities.

And this brings us surprisingly close to the ideas we started with in nature.

The connection back to nature

Think about an ant colony again.

There isn't one "super ant" that knows the entire plan of the colony. Individual ants follow relatively simple behaviors. They interact with their environment. They communicate. They respond to changes.

And complex colony-level behavior emerges from those interactions.

The same general idea appears in many natural systems:

Simple entities. Local decisions. Interactions. Feedback. Adaptation. Emergent behavior.

Nature-inspired computing takes inspiration from these patterns and asks whether similar principles can help us design computational systems.

And when we look at modern agentic AI through this lens, some of the connections become quite interesting.

Modern AI provides increasingly capable models. Agent architectures provide ways for those models to perceive, reason, plan, act, remember, and interact. Multi-agent architectures extend this further by allowing multiple specialized agents to collaborate.

So these aren't necessarily separate ideas.

They are different pieces of a much larger way of thinking about computation.

So what actually makes a system "agentic"?

This is where I think the terminology can become confusing.

Simply calling something an "AI agent" doesn't automatically make it agentic.

If a system receives a question and generates a response, it may just be a model-powered application.

If it can independently pursue an objective, decide what actions are necessary, interact with its environment, use tools, observe the results, and adjust its behavior, we are getting much closer to an agentic system.

The key isn't just intelligence.

It is agency.

The system has some degree of:

Goal → Decision → Action → Feedback → Adaptation

That is the core concept.

The bigger picture

What I found most interesting while looking into agentic systems is that the current excitement around AI agents can make the idea seem completely new.

It isn't.

Many of the underlying ideas have existed across different areas of computer science for decades.

What is particularly interesting today is how several of these ideas can now be combined.