5 levels of Agentic AI systems, clearly explained (with visuals):
Agentic AI systems don't just generate text; they can make decisions, call functions, and even run autonomous workflows.
The visual explains 5 levels of AI agency, starting from simple responders to fully autonomous agents.
Let's dive in to learn more!
1️⃣ Basic responder
- A human guides the entire flow.
- The LLM is just a generic responder that receives an input and produces an output. It has little control over the program flow.
See this visual👇
2️⃣ Router pattern
- A human defines the paths/functions that exist in the flow.
- The LLM makes basic decisions on which function or path it can take.
Check this visual👇
3️⃣ Tool calling
- A human defines a set of tools the LLM can access to complete a task.
- LLM decides when to use them and also the arguments for execution.
Check this visual👇
4️⃣ Multi-agent pattern
A manager agent coordinates multiple sub-agents and decides the next steps iteratively.
- A human lays out the hierarchy between agents, their roles, tools, etc.
- The LLM controls execution flow, deciding what to do next.
See this visual👇
5️⃣ Autonomous pattern
The most advanced pattern, wherein, the LLM generates and executes new code independently, effectively acting as an independent AI developer.
Here's a visual to understand this👇
To recall:
1) Basic responder only generate text. 2) Router pattern decides when to take a path. 3) Tool calling picks & runs tools. 4) Multi-Agent pattern manages several agents. 5) Autonomous pattern works fully independently.
Here's the visual again for your reference👇
That's a wrap!
If you found it insightful, reshare it with your network.
Find me → @_avichawla
Every day, I share tutorials and insights on DS, ML, LLMs, and RAGs.
Qwen-3 Coder is Alibaba’s most powerful open-source coding LLM.
Today, let's build a pipeline to compare it to Sonnet 4 using:
- @LiteLLM for orchestration.
- @deepeval to build the eval pipeline (open-source).
- @OpenRouterAI to access @Alibaba_Qwen 3 Coder.
Let's dive in!
Here's the workflow:
- Ingest a GitHub repo and provide it as context to the LLMs.
- Generate code from both models using context + query.
- Compare the generated code using DeepEval.
After MCP, A2A, & AG-UI, there's another Agent protocol.
It's fully open-source and launched by IBM Research.
Here's a complete breakdown (with code):
ACP is a standardized, RESTful interface for Agents to discover and coordinate with other Agents, regardless of their framework.
Just like A2A, it lets Agents communicate with Agents. There are some differences, which we shall discuss later.
Let's dive into the code first!
Here's how it works:
- Build the Agents and host them on ACP servers.
- The ACP server receives requests from the ACP Client and forwards them to the Agent.
- ACP Client itself can be an Agent to intelligently route requests to the Agents (like MCP Client does).