Rakesh Gohel

Don't waste every day reinventing your AI Agent Architecture

Use these powerful AI Agent design patterns to move faster...

(Note: Source code samples for implementing these patterns)

📌 ReACT(Reasoning and Acting):

a. LLM1-Reasoning: This involves building a contextual understanding by interpreting input and utilizing necessary APIs from tools.

b. LLM2-Actions: Actions are the steps taken based on Reasoning when the output is shared from the APIs.

📌 CodeACT

- User Initiation: The user starts by giving a natural language instruction to the agent.

- Agent Planning: The agent plans actions using reasoning, refining based on past observations.

- CodeAct Action: The agent generates and sends executable Python code to the environment.

- Environment Feedback: The environment executes the code, providing results or errors for the agent to refine actions.

📌 Tool Use

- Unlike traditional per-API-based tool calling, MCP have now revolutionised how tool calling can be done with AI agents.

- More details about MCP - https://lnkd.in/ekZR9f3z

📌 Self-reflection/reflexion

a. Main LLM: The core LLM performs simple agentic tasks using tools and memory.

b. Critique LLM: This can be 1 or more LLMs used as a Judge to monitor the main LLM's performance.

c. Generator: Responsible for generating the answer after getting proper info from the critique LLM.

📌 Multi-agent workflow

a. Agent: The core agent commands other sub-agents with tool calling + Memory abilities.

b. Sub-Agents: These are specialized agents with their specific tools for specific tasks.

c. Combined decision: The sub-agents receive a combined response and input guidance to align the output through the aggregator.

📌 Agentic RAG

a. Tool use:-

- Utilizes web-based search and vector search protocols to identify the required documents.

- Finally, a Hybrid search is utilized using the given prompt to find the right info.

b. Main Agent: The information gathered with tool use is combined with the model's reasoning to create a desired output.

c. Decision: Finally, a Generator LLM shares and generates the output.

If you are a business leader, we've developed frameworks that cut through the hype, including our five-level Agentic AI Progression Framework to evaluate any agent's capabilities in my latest book.

🔗 Book info: https://amzn.to/4irx6nI

© Follow this guide if you want to use our content: https://lnkd.in/gTzk2k4b

Save 💾 ➞ React 👍 ➞ Share ♻️

& follow for everything related to AI Agent

MCP has become the most supported open-source toolkit of 2025

If you are still confused, I made a guide for you to get started...

MCP has become a popular tool-calling utility in AI Agents and LLM workflows.

If you also want to understand how, here's a simple guide:

📌 Definition:

- Formally, it is a universal AI protocol enabling real-time, standardized connections between AI systems and diverse data sources.

- Simply, it is a unified way to utilise a large collection of APIs using a single server architecture.

- This is plug and play; you can use a wide range of third-party APIs in your application using only a few lines of code.

📌 Why is it better than traditional tool calling?

- In traditional tool calling, an agent interacts with tools via unique APIs. This often leads to complexity due to differing API structures.

- MCP standardizes these connections, reducing the overhead of managing multiple APIs.

📌 MCP Architecture

- Third-Party APIs: On the left and right end, MCP connects to platforms like Kagi, Qdrant, and others. These represent diverse data inputs that AI systems often need to access.

- MCP Servers: MCP servers (Server 1 to Server 4) act as intermediaries, handling protocol communication with the application (client). Servers connect to API sources for different third-party applications, allowing smooth integration and use.

- Application (Client): The client application sits at the center, interacting with MCP servers to access data and tools.

- MCP Local Server: At the bottom, a local server connects to local files, ensuring even offline resources can be integrated.

📌 MCP Workflow

- Invokes Tools for Resources: The process starts by invoking tools to gather resources, such as querying databases or APIs.

- MCP Client: The MCP client processes these resources, interpolating prompts (likely preparing data for AI models).

- Finally, the MCP server exposes the processed resources, making them available for use.

📌 Actions

- Tools (Model-Controlled): Includes “Search“ and “Update Databse“ queries – these are model-driven actions to retrieve or modify data.

- Resources (Application-Controlled): Includes “Local Files“ and “API Responses“ – these are the data sources the application can tap into via MCP.

- Prompts (Use-Controlled): These are user-driven prompts, such as querying documentation or leveraging MCP for specific tasks.

Although popular, MCP is still experimental and has many vulnerabilities, which I'll cover in future posts.

If you are a business leader, we've developed frameworks that cut through the hype, including our five-level Agentic AI Framework to evaluate any agent's capabilities in my latest book.

🔗 Book info: https://lnkd.in/gQXVsTyN

© Follow this guide if you want to use our content: https://lnkd.in/gTzk2k4b

How are you using MCP in your Application?

Let me know in the comments below 👇

Save 💾 ➞ React 👍 ➞ Share ♻️

& follow for everything related to AI Agents

Dont invest in AI Agents without reading this Anthropic report

Here's a comprehensive breakdown of the research...

Often most automation that we use daily can be easily done with a few LLMs and APIs

and that's something Anthropic too is trying to convey

This research shares what they think are AI agents and why you should not always build one.

📌 We recently covered Google's whitepaper where we broke down how Google's vision of AI Agents.

Now, after reading both Google's and Anthropic's take - It is safe to say that Google's paper was more on What AI Agents.

Whereas Anthorpic's take is much more on Why and When should you should use AI Agents.

Here's a brief breakdown from their research:

📌 Agents vs. Workflows: Agents are dynamic systems where LLMs direct their own processes and tool usage, while workflows follow predefined paths. Agents shine when flexibility and decision-making are key.

📌 Core Parts of AI Agents:

1. Augmented LLMs
2. Tools used by the Agumented LLMs
3. Environment
4. Memory

📌 Key Workflow for Agents:

- Prompt Chaining: Breaking tasks into sequential steps for higher accuracy.
- Routing: Directing inputs to specialized tasks for better performance.
- Parallelization: Running tasks simultaneously for speed or diverse outputs.
- Orchestrator-Workers: A central LLM delegating tasks to worker LLMs.
- Evaluator-Optimizer: Iterative refinement by multiple processes for polished results.

📌 When to Use Agents:

You don't always need to use Agents, Often your automation can be easily done using a few automation workflow tools like N8N and other commercial tools.

Here are a few problems where you should use AI Agents:

- Open-ended problems require flexibility.
- Tasks where decision-making scales with complexity.
- Environments with trusted autonomy and clear feedback loops.

📌 Few Frameworks given by Anthropic to Consider:

- LangGraph (LangChain)
- Amazon Bedrock's AI Agent Framework
- Rivet and Vellum for GUI-based workflow building

💡 Key Takeaway: 
- Success isn’t about building the most complex system—it’s about building the right system. 
- Start simple, measure performance, and add complexity only when it demonstrably improves outcomes.
- Sometimes without understanding the core aspect of an agent we redundantly pile up too much code from a few frameworks which Often leads to redundant code being piled up without understanding.
- Hence they specifically aimed this research to bring more clarity to people who are trying to build AI agents for their businesses.

What are your thoughts about this report?

Let me know your thoughts in the comments below 👇

Please make sure to,

♻️ Share
👍 React
💭 Comment

to help more people learn

P.S. Let me know if you want a detailed summary of any other reports or papers

© Follow this guide if you want to use our content: https://lnkd.in/gTzk2k4b

Most people think AI Agents are just glorified chatbots

But what if I told you they’re the future of digital workforces

Often, I see around the internet where users describe agents with a simple chatbot architecture with API calling features.

However, that could not be further from the reality of what AI Agents do.

To give you a bit of context,

There’s a fundamental gap between what most call an “AI agent” and what a true AI-driven system can accomplish.

Let’s break it down:

📌 On the left, you can see what a simple Chatbot architecture looks like:

1. It takes your input (e.g., “Find the nearest coffee shop”) and maps it to a single, pre-defined action like calling a map API using an LLM.

2. The output? A simple response: “The nearest coffee shop is 0.5 miles away.” While useful, it’s linear and limited to a single task at a time.

📌 While on the right is a simple true AI Agent architecture:

- This system doesn’t just respond—it thinks, plans, and adapts.

As shown in the example,

if you ask it to plan a 3-day Paris trip under $1000, here’s what happens:

1. The system breaks your request into actionable components (flights, accommodations, activities, and budget).

2. It identifies the best tools, such as flight search APIs and hotel booking systems, and gathers the necessary data.

3. Using memory, it aligns suggestions with your past preferences (e.g., favourite activities or destinations).

4. The agent evaluates the plan against your budget and constraints, iterating if necessary.

5. The final output is a well-optimized, ready-to-use plan tailored to your needs.

This type of distinction matters as we move toward AI systems that don’t just perform tasks but deliver contextual, multi-step solutions.

📌 This is a simple trip-planning example I gave, you can even refer to Microsoft's very own trip-planning demo that they showed in this year's Microsoft's ignite event

- Check it out here: https://lnkd.in/gEFJgFZM

In the demo itself, it's no longer a simple chatbot giving answers.

It's a fully autonomous system that finds the details regarding the trip creates a fully detailed plan in a separate file and can even adjust its workflows dynamically.

The future of AI lies in systems that combine intelligence, adaptability, and decision-making.

The difference may seem subtle at first glance, but it’s transformative in application.

But if you are wondering what the future architecture of AI Agents looks like, you can check the comments below

What are a few common AI Agent misconceptions that you've come across?

Let me know in the comments below 👇

Please make sure to,

♻️ Share
👍 React
💭 Comment

to help more people learn

© Follow this guide if you want to use our content: https://lnkd.in/gTzk2k4b