Agentic AI: What is Model Context Protocol, Agent2Agent and How Does This Impact Automation?

What is Modern Context Protocol (MCP)?

Modern Context Protocol (MCP) is a concept proposed within the observability and telemetry ecosystem, particularly as an emerging framework or protocol for propagating contextual data across distributed systems, often associated with OpenTelemetry and AI observability. Modern context protocol is designed to standardize and enhance the way contextual data (like trace IDs, user IDs, session IDs, model parameters, and feature flags) is captured, correlated, and transmitted across services and systems, especially in modern cloud-native and AI-driven environments.

It expands on traditional context propagation by allowing more richer, structured, and secure contextual data sharing across:

• Microservices
• AI model pipelines
• Observability backends
• Real-time user/session telemetry

MCP has a number of key characteristics including structured context propagation, cross-domain compatibility, extensible schema, privacy and security controls, and AI observability support.

Modern systems - especially those using AI - generate a high volume of diverse, interrelated data. MCP is a response to the need for better traceability of data through the AI/ML lifecycle as well as enhanced correlation of telemetry with model inputs and outputs. MCP offers consistent semantic context propagation across APIs, models, and users, and observability tools to reason about business or user context, not just low-level telemetry.

MCP is not yet a widely standardized or finalized protocol; it is an evolving idea born from the needs of observability in complex, AI-powered, distributed systems. It may be implemented differently by vendors or built on top of OpenTelemetry concepts.

What is Agentic AI?

Agentic AI refers to a class of artificial intelligence systems that act as autonomous agents capable of setting goals, making decisions, and taking actions in dynamic environments with minimal human intervention. Agentic AI (from "agent") is AI that exhibits goal-directed behavior, often with a degree of autonomy, adaptability, and initiative. These systems don't just respond to inputs; they actively pursue objectives, often using reasoning, planning, and learning. Agentic AI is autonomous, goal-oriented, and context aware. It is capable of memory and reasoning, planning and action, and learning and adaptation.

Comparing Agentic AI to traditional AI:

Agentic AI does face a number of challenges including alignment (ensuring the agent’s goals align with human intent avoiding unintended consequences), safety and control (preventing unsafe behaviors or overreach from overly autonomous agents), evaluation (measuring success is harder when the agent defines or adapts its own goals), and complexity and cost (more infrastructure is needed for memory, orchestration, planning, and monitoring).

What are AI Agents?

AI Agents are autonomous or semi-autonomous systems that perceive their environment, make decisions, and take actions to achieve specific goals often using artificial intelligence techniques such as machine learning, reasoning, and planning. An AI Agent is an entity that receives input, processes that input, and acts in the environment to achieve goals or tasks. In essence, an AI agent is a goal-driven, decision-making system powered by AI.

There are several types of AI agents. Reactive agents respond to current inputs without memory. Deliberative agents use reasoning and planning to determine future actions. Learning agents improve behavior over time via experience. Collaborative/multi-agent systems have multiple agents interacting to achieve individual or shared goals. Embodied agents operate in the physical world and cognitive agents simulate human-like thought processes, often including memory, goals, and reasoning.

How does Agentic AI work?

Agentic AI works by combining multiple AI techniques and system components to create autonomous, goal-oriented agents that can reason, plan, act, and adapt over time. Unlike traditional reactive systems, agentic AI embodies a loop of perception, decision-making, and action, often enhanced by memory and feedback.

Agentic AI starts by defining the goal. The agent is given a goal (e.g., “Book a flight,” “Summarize a document,” “Write and deploy code”), either explicitly by a human or inferred from context.

Perceive

Then the agent observes its environment using sensors, APIs, or input prompts. It interprets the data using NLP (for language), computer vision, or structured data parsing. In the planning and decomposition stage, the agent breaks the high-level goal into smaller tasks or subgoals. It uses techniques such as classical planning, Large Language Models (LLMs) for reasoning and generating task plans, and finite-state machines or workflows. Next, the agent selects and invokes the appropriate tools or APIs to perform tasks including search engines, file systems, email clients, web browsers, and code execution environments. This is often done using LLM and tool plugins or external API orchestration. Agentic AI may store short-term memory (results of recent actions or dialogue) or long-term memory (learned knowledge, past task results, user preferences) allowing it to adapt, maintain continuity, and improve over time.

Reason

Using reasoning and feedback loops, the agent reflects on intermediate results (“Was the output good enough?”). If a task fails or results are insufficient, it adjusts the plan or retries. It can use self-evaluation, reinforcement learning, or user feedback.

Act

Agentic AI is capable of autonomous decision-making. The agent evaluates available options and makes decisions without human intervention. For example, it might prioritize tasks, choose between competing tools, or escalate problems.

Learn

Once the goal is achieved (or the process is stopped), the agent reports outcomes, stores final states, or sends a notification to the user.

Example Applications of Agentic AI

Here are example applications of Agentic AI across different industries and use cases. These systems act autonomously, pursue goals, and adapt based on feedback - making them especially useful in complex or dynamic environments.

Software Engineering

AI software engineers can write, test and deploy software autonomously. An example is Devin AI, an autonomous AI software engineer that takes a GitHub issue, writes code, debugs it, runs tests, and commits changes without human help.

Analytics & Business Insights

Agentic AI can replace rule-based robotic process automation with intelligent, adaptive agents. One example: An agent monitors invoices in a shared inbox, extracts data, validates against databases, and enters it into a finance system, flagging anomalies automatically. 

Observability 

Agentic AI is emerging as a powerful enabler in observability, transforming traditional telemetry analysis into proactive, intelligent, and autonomous workflows. Agentic AI agents can act as virtual site reliability engineers (SREs) or observability copilots, performing continuous monitoring, troubleshooting, and optimization tasks with minimal human input. Areas where agentic AI might feature in observability include autonomous root cause analysis, self-healing infrastructure agents, or an observability copilot (ChatOps/DevOps Assistant).

What is A2A?

A2A (Agent-to-Agent) refers to direct interaction and coordination between autonomous AI agents, often in a multi-agent system. Key characteristics of A2A include:

• Each agent has its own goals, memory, and capabilities.
• Agents can exchange messages, collaborate, or negotiate.
• Often used in task delegation, coordination, or distributed decision-making.

A2A could be seen when AI agents divide up software development tasks, observability agents share system state or anomalies to diagnose a cross-service failure, or supply chain agents negotiate price and availability with each other.

How do Agents communicate with each other?

In Agentic AI, agents communicate with each other through structured protocols and messaging systems that enable them to share knowledge, coordinate actions, delegate tasks, and collaborate toward shared or individual goals. This is known as Agent-to-Agent communication. Agents operate in a loop of communication, often adapting their behavior based on each other's outputs.

How Agents Communicate: Key Components

What is the difference between Agents and Models?

The difference between agents and models lies in their roles, capabilities, and levels of autonomy within an AI system. While they often work together, they are not the same.

A model is a mathematical or statistical representation trained to perform a specific task. An agent is an autonomous system that uses one or more models to perceive, reason, plan and act in pursuit of goals.

Think of a model as a calculator - it does one thing when you press a button. An agent is like a robot assistant - it uses the calculator (and other tools), decides what to do next, remembers what’s been done, and tries to achieve a final result.

<h2> How can MCP be used in the context of Agentic AI?

The modern context protocol can play a crucial role in Agentic AI by enabling structured, consistent, and secure context sharing between autonomous agents, models, tools, and systems across dynamic workflows.

In short: MCP provides the “context glue” that allows Agentic AI systems to operate coherently—especially in distributed, multi-agent, or AI orchestration environments.

Agentic AI involves multiple agents making decisions, tools and models working together, memory and planning across steps, and interactions across services or users. To make this work, rich context needs to flow seamlessly across the entire system - this is where MCP comes in.

How MCP Can Be Used in Agentic AI

1. Cross-Agent Context Propagation

• MCP allows agents to share structured context like:
  
  • User/session info
  • Task ID and subtask hierarchy
  • Current goals and constraints
  • Environment variables or config

2. Multi-Step Planning and Execution

• In Agentic AI, a plan is broken into substeps handled by different agents or tools.
• MCP propagates:
  
  • Execution trace
  • Intermediate results
  • Decision rationale

3. Context-Aware Model Use

• When agents invoke LLMs or other models, MCP can carry:
  
  • Prompt metadata
  • Model version
  • Domain-specific parameters

4. Memory Management

• MCP can help standardize what agents write to and read from shared memory:
  
  • Short-term context (e.g., current conversation)
  • Long-term memory tags (e.g., "user preference", "incident history")

5. Secure and Compliant Context Sharing

• MCP can enforce policies like:
  
  • PII masking
  • Scoped propagation (e.g., don't leak dev context to prod)
  • Trace-level access control

6. Multi-Agent Collaboration

• In a CrewAI or LangGraph setup, different agents (planner, coder, tester) need shared:
  
  • Task trees
  • Agent roles
  • Confidence scores or quality thresholds
• MCP provides a common schema and language for inter-agent communication.

How MCP Supports real-time observability 

MCP supports real-time observability by enabling the consistent, structured, and contextual flow of telemetry data across systems and services, particularly in dynamic, distributed, and intelligent environments (like those with agentic AI, microservices, or cloud-native stacks). It connects the what (telemetry) with the why, who, where, and how - across services, environments, and intelligent agents.

MCP enhances real-time observability by acting as a semantic metadata layer that ties together logs, metrics, traces, events, and AI-generated data with rich, actionable context.

MCP supports real-time observability in a number of ways. First MCP carries critical metadata through every hop in a request or event flow. Then, as telemetry data is ingested, MCP attaches rich, structured metadata, providing high-resolution observability that’s immediately actionable. Observability platforms can index and query MCP fields live allowing for instant slicing and dicing of telemetry data based on business, deployment, or user context. Also, MCP acts as a universal context bridge across logs, metrics and events, facilitating real-time alert correlation and unified views. Alerts can be generated based not just on thresholds, but also context. And finally, in agentic and AI-powered systems, MCP tracks the model version, prompt ID, latency, token usage, and outcome, to enable live dashboards and alerts for model performance and drift.

‍