DEV Community: Uma Baleboyina

Middleware in DeepAgents

Uma Baleboyina — Wed, 10 Jun 2026 03:55:00 +0000

Middleware is a component that sits between different parts of an agent system and can observe, manage, modify, or track the flow of information during execution.

In Deep Agents, middleware is part of the framework architecture. It operates between components such as the user request, the model, and tool execution. Middleware can perform different responsibilities depending on its purpose.

There are different types of middleware. For example:

TodoListMiddleware – Creates and manages a task list (todos) for complex requests and tracks task completion.
PatchToolCallsMiddleware – Helps manage and validate tool-calling behavior.
Logging Middleware – Records execution details and events.
Summarization Middleware – Can summarize conversation history or intermediate results.

It is important to note that not every middleware performs verification. Different middleware have different responsibilities. Some middleware may validate requests, some may track progress, some may summarize information, and some may simply log activity.

In Deep Agents, certain middleware are added automatically by the framework. For example, when I created an agent using create_deep_agent(), I observed middleware such as TodoListMiddleware and PatchToolCallsMiddleware appearing in the execution trace even though I did not explicitly add them.

The TodoListMiddleware creates and maintains todos internally. These todos are typically based on the user's goal and the tools available to the agent. The middleware tracks which tasks are pending and which have been completed during execution.

For example, if the user asks:

"Get me the weather of the most popular city in India."

The internal todo list might conceptually look like:

Find the most popular city.
Get the weather for that city.

As the agent completes each step, the middleware can update the status of the corresponding task.

The actual tool outputs are stored in the agent's state and used by the model for reasoning, while the TodoListMiddleware primarily focuses on planning and tracking task progress.

Some middleware are automatically included by the framework, while other middleware may need to be explicitly added by the developer depending on the application's requirements.

From Simple LLMs to Intelligent AI Agents

Uma Baleboyina — Tue, 26 May 2026 16:12:40 +0000

Understanding Deep Agents and Agentic AI

Artificial Intelligence has evolved from simple text generation models to intelligent systems called AI Agents. Before understanding agents, we first need to understand how Large Language Models (LLMs) work.

What are LLMs?

LLMs (Large Language Models) are AI models trained on massive amounts of data. Their main job is to predict the next token based on previous tokens.

For example:

Input: "India is a"
Output: "country"

The model continuously predicts the next token to generate complete responses.

Modern AI models can generate different types of outputs, also called modalities.

Some common modalities are:

Text generation
Code generation
Image generation
Audio generation
Video generation

Examples:

Chatbots generate text
Code assistants generate code
AI art tools generate images
Video models generate videos
Problem with Using Different LLM APIs

Different AI companies provide different APIs.

For example:

OpenAI API
Gemini API
Claude API

Each API has:

different syntax
different configurations
different SDKs

So developers had to write separate code for every model.

How LangChain Helped

LangChain introduced a common framework for working with multiple LLMs.

Instead of rewriting the entire codebase for each model, developers can use a common interface.

Example idea:

Without LangChain:

openai.chat()
gemini.generate()
claude.messages()

With LangChain:

llm.invoke()

Only the configuration changes slightly.
This made AI application development much easier.
From Simple LLMs to Intelligent Agents

Simple LLMs can generate:

text
code
images
videos

But they cannot directly perform real-world tasks like:

booking train tickets
reserving hotels
sending emails
searching live data

Initially, developers combined LLMs and traditional programming logic to perform such actions.

Example flow:

User Request
↓
LLM understands request
↓
Python code calls APIs
↓
Action gets completed
Tool Calling in AI Agents

Later, AI systems evolved into tool-using agents.

Now the LLM itself can decide:

which tool to use
when to use it
what parameters to pass

Examples of tools:

search engines
calculators
booking APIs
databases
browsers This made AI systems appear more intelligent and autonomous.

ReAct Agents

One important concept in Agentic AI is the ReAct Agent.

ReAct stands for: Reason + Act

The agent:

Reasons about the problem
Chooses an action/tool
Observes the result
Continues reasoning

Flow:

Thought → Action → Observation → Thought

This allows the AI agent to solve complex tasks step-by-step.

Challenges in AI Agents

Even though agents are powerful, they still face many challenges.

1. Garbage In, Garbage Out (Prompt Quality)

LLMs highly depend on prompts.

If the input prompt is poor or unclear, the output quality also becomes poor.

This is called:

Garbage In → Garbage Out

Better prompts usually produce better results.

2. Guardrails

Guardrails are safety mechanisms added to AI systems.

Their purpose is to:

prevent harmful outputs
protect sensitive information
restrict unsafe actions
ensure ethical behavior Example: An AI agent should not reveal private user data or perform dangerous actions.

3. Grounding
Grounding means the AI should provide information based on:

real facts
reliable sources
actual context If the model does not know something, it should honestly say: “I do not have enough information.” instead of generating false information. This helps reduce hallucinations.

Conclusion

AI systems are evolving from simple text generators into intelligent autonomous agents. Frameworks like LangChain and ReAct-based architectures are helping developers build more capable AI applications.

However, challenges such as:

prompt quality
safety
hallucinations
grounding

What is MCP? My Beginner's Guide to Model Context Protocol

Uma Baleboyina — Fri, 08 May 2026 07:51:19 +0000

Introduction

When I started learning Generative AI, one of the first things I came across was something called MCP. At first it sounded complex, but once I understood it, everything clicked. In this blog, I want to share my understanding in the simplest way possible.

What is MCP?
MCP stands for Model Context Protocol. It is a lightweight protocol developed by Anthropic — the company that also created Claude AI. In simple terms, MCP acts as a bridge between an AI assistant and the outside world — connecting it to functions, tools, and external environments so the AI can actually do things, not just talk.

Where did the idea come from?
MCP was inspired by LSP — the Language Server Protocol. If you have used VS Code, you already benefited from LSP without knowing it. LSP is the reason VS Code can support multiple programming languages like Python, JavaScript, Java and more — all through one common standard.
MCP follows the same idea. Instead of building a separate integration for every AI model, MCP provides one common standard that works across multiple models. You build the server once, and any MCP-compatible AI model can use it.

How do you build an MCP server?
Building your first MCP server is simpler than it sounds. You start by importing MCP from the FastMCP library. Then you define your tools using the @mcp.tool decorator and write the logic — the actual code that performs the action. Finally, you connect it to Claude and your server is ready.

The two main components of MCP
MCP has two core components:

MCP Client — This is the intelligent side, like Claude. It understands the user's request and decides what needs to be done.
MCP Server — This is the action side. It actually performs the tasks that the client requests.

Think of the client as the brain and the server as the hands.

How does the workflow work?
Here is the step-by-step flow of how MCP works in action:

Tools vs Resources vs Prompts — what is the difference?
This is one of the most important concepts in MCP:

Tools — These are used to perform actions. When a user wants something done — like fetching weather data or saving a file — a tool does it.
Resources — These are used to feed data to the agent. They are read-only information sources the AI can access when it needs context or data.
Prompts — These are reusable question templates. They represent the general questions or instructions a user commonly asks the AI.

Conclusion
MCP is a powerful and elegant idea — one standard protocol that connects any AI model to any tool or data source. It removes the need to build custom integrations for every model and makes AI agents truly useful in the real world. I am just getting started with MCP, and I am excited to build more servers and share what I learn along the way.