How Protocols Influence Agentic AI Development

𝗔𝗜 𝗔𝗴𝗲𝗻𝘁𝘀 𝗔𝗿𝗲 𝗚𝗲𝘁𝘁𝗶𝗻𝗴 𝗦𝗺𝗮𝗿𝘁𝗲𝗿 — 𝗕𝘂𝘁 𝗢𝗻𝗹𝘆 𝗜𝗳 𝗧𝗵𝗲𝘆 𝗖𝗮𝗻 𝗧𝗮𝗹𝗸 𝘁𝗼 𝗘𝗮𝗰𝗵 𝗢𝘁𝗵𝗲𝗿 As AI shifts from single-task assistants to multi-agent systems, what truly powers this transformation isn't just bigger models — it's the rise of 𝘀𝘁𝗮𝗻𝗱𝗮𝗿𝗱𝗶𝘇𝗲𝗱 𝗽𝗿𝗼𝘁𝗼𝗰𝗼𝗹𝘀. These protocols define how agents communicate, manage memory, invoke tools, and collaborate across ecosystems. To make sense of this emerging landscape, I mapped out 𝟭𝟬 𝗺𝗼𝗱𝗲𝗿𝗻 𝗔𝗜 𝗮𝗴𝗲𝗻𝘁 𝗽𝗿𝗼𝘁𝗼𝗰𝗼𝗹𝘀 that are shaping how agents work — together. Here’s a breakdown of what’s included: • 𝗔𝗴𝗲𝗻𝘁 𝗖𝗼𝗺𝗺𝘂𝗻𝗶𝗰𝗮𝘁𝗶𝗼𝗻 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹 (𝗜𝗕𝗠): Lifecycle and workflow standardization • 𝗔𝗴𝗲𝗻𝘁 𝗚𝗮𝘁𝗲𝘄𝗮𝘆 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹: Message routing between agents and external systems • 𝗔𝗴𝗲𝗻𝘁-𝘁𝗼-𝗔𝗴𝗲𝗻𝘁 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹 (𝗚𝗼𝗼𝗴𝗹𝗲): Structured inter-agent collaboration (Gemini & Astra) • 𝗠𝗼𝗱𝗲𝗹 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹 (𝗔𝗻𝘁𝗵𝗿𝗼𝗽𝗶𝗰): Unified memory and tool embedding inside LLMs • 𝗧𝗼𝗼𝗹 𝗔𝗯𝘀𝘁𝗿𝗮𝗰𝘁𝗶𝗼𝗻 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹 (𝗟𝗮𝗻𝗴𝗖𝗵𝗮𝗶𝗻): Standard JSON for tool metadata • 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻 𝗖𝗮𝗹𝗹 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹 (𝗢𝗽𝗲𝗻𝗔𝗜): Schema-enforced function execution • 𝗧𝗮𝘀𝗸 𝗗𝗲𝗳𝗶𝗻𝗶𝘁𝗶𝗼𝗻 𝗙𝗼𝗿𝗺𝗮𝘁 (𝗦𝘁𝗮𝗻𝗳𝗼𝗿𝗱): Declarative task graphs and coordination • 𝗔𝗴𝗲𝗻𝘁𝗢𝗦 𝗥𝘂𝗻𝘁𝗶𝗺𝗲: Managing stateful, long-lived agents in enterprise settings • 𝗥𝗗𝗙 𝗔𝗴𝗲𝗻𝘁 (𝗦𝗲𝗺𝗮𝗻𝘁𝗶𝗰 𝗪𝗲𝗯): Linked data agent reasoning using SPARQL • 𝗢𝗽𝗲𝗻 𝗔𝗴𝗲𝗻𝘁 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹: A community push toward cross-framework interoperability    This space is evolving quickly. Protocols like these are quietly becoming the 𝗿𝗲𝗮𝗹 𝗶𝗻𝗳𝗿𝗮𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 behind the AI agents of tomorrow. Whether you're designing LLM workflows or deploying AI into production systems, these are the interfaces you'll be working with next. Curious which ones you've already explored — or plan to?

𝗧𝗵𝗲 𝗺𝗼𝘀𝘁 𝗰𝗼𝗺𝗽𝗿𝗲𝗵𝗲𝗻𝘀𝗶𝘃𝗲 𝘀𝘂𝗿𝘃𝗲𝘆 𝗼𝗻 𝗔𝗜 𝗔𝗴𝗲𝗻𝘁 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹𝘀 𝗷𝘂𝘀𝘁 𝗱𝗿𝗼𝗽𝗽𝗲𝗱! ⬇️ LLMs can now plan, reason, use tools, and collaborate. But most of them don’t speak the same language. And without a shared protocol, we’ll never unlock scalable, autonomous systems. It’s the missing infrastructure of the AI age. A team of researchers from Shanghai Jiao Tong University (great to see my former university here) just released what might be the most comprehensive survey on AI Agent Protocols to date. Their goal? To map the emerging landscape of how LLM-powered agents interact with tools, data, and each other — and why current fragmentation is holding us back. 𝗧𝗵𝗲 𝗽𝗮𝗽𝗲𝗿 𝗯𝗿𝗲𝗮𝗸𝘀 𝗻𝗲𝘄 𝗴𝗿𝗼𝘂𝗻𝗱 𝗯𝘆: * Proposing a new classification system for protocols * Comparing 13+ protocols (like MCP, A2A, ANP, Agora) * Outlining the technical gaps we need to solve * Showing how protocol design will shape the future of multi-agent systems and collective AI 𝗛𝗲𝗿𝗲 𝗮𝗿𝗲 6 𝗞𝗲𝘆 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆𝘀 𝘄𝗵𝗶𝗰𝗵 𝘀𝘁𝗼𝗼𝗱 𝗼𝘂𝘁 𝘁𝗼 𝗺𝗲: ⬇️ 1. 𝗔𝗴𝗲𝗻𝘁 𝗜𝗻𝘁𝗲𝗿𝗼𝗽𝗲𝗿𝗮𝗯𝗶𝗹𝗶𝘁𝘆 𝗜𝘀 𝗕𝗿𝗼𝗸𝗲𝗻 ➜ Today’s agents are siloed. Everyone builds their own APIs, their own wrappers, their own formats. This is the early-internet problem all over again. 2. 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹𝘀 𝗔𝗿𝗲 𝘁𝗵𝗲 𝗡𝗲𝘄 𝗜𝗻𝗳𝗿𝗮𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 ➜ Think TCP/IP — but for agents. These standards will determine whether tools and agents can communicate across vendors, platforms, and environments. 3. 𝗠𝗖𝗣 𝗜𝘀 𝗟𝗲𝗮𝗱𝗶𝗻𝗴 𝗳𝗼𝗿 𝗧𝗼𝗼𝗹 𝗨𝘀𝗲 ➜ Anthropic’s Model Context Protocol (MCP) is one of the most advanced protocols for agent-to-resource interactions — and it fixes key privacy issues in tool invocation. 4. 𝗔2𝗔 𝗮𝗻𝗱 𝗔𝗡𝗣 𝗘𝗻𝗮𝗯𝗹𝗲 𝗠𝘂𝗹𝘁𝗶-𝗔𝗴𝗲𝗻𝘁 𝗖𝗼𝗹𝗹𝗮𝗯𝗼𝗿𝗮𝘁𝗶𝗼𝗻 ➜ Google’s A2A is enterprise-grade and async-first. ANP, on the other hand, is open-source and aims to create a decentralized Agent Internet. 5. 𝗘𝘃𝗮𝗹𝘂𝗮𝘁𝗶𝗼𝗻 𝗚𝗼𝗲𝘀 𝗕𝗲𝘆𝗼𝗻𝗱 𝗦𝗽𝗲𝗲𝗱 ➜ The report introduces 7 dimensions for assessing agent protocols — from security to operability to extensibility. It’s not just about performance. It’s about trust, adaptability, and integration. 6. 𝗨𝘀𝗲 𝗖𝗮𝘀𝗲𝘀 𝗦𝗵𝗮𝗽𝗲 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹𝘀 ➜ A protocol that works for a single-agent chatbot may fail in an enterprise-grade multi-agent orchestration scenario. Architecture matters. So does context. As we move toward a true Internet of Agents, the paper outlines the standards, challenges, and architectural shifts we need to unlock scalable, interoperable agent ecosystems. Important dicussion and great insights! At the end of the day, it’s about enabling agents to coordinate, negotiate, learn, and evolve — forming distributed systems greater than the sum of their parts. You can download the survey below or in the comments!

If you want to understand how AI Agents actually work together… start by understanding their protocols. AI agents don’t collaborate magically. They communicate, share memory, negotiate tasks, and stay safe because a whole ecosystem of protocols makes it possible. Teams focus on models and tools. But it’s the protocol layer that decides whether your agents scale, or fail. This map breaks down the core building blocks every agentic system relies on: 1. Core & Widely Used Protocols These are the fundamental standards that let agents talk to each other, execute tasks, and interact with tools in a structured, predictable way. They form the backbone of any agent-based architecture. 2. Transport & Messaging This layer keeps agents connected. It handles event streams, async messaging, real-time communication, and reliable delivery - everything needed for fast, fault-tolerant workflows. 3. Memory & Context Exchange Agents can’t reason or collaborate without shared context. These protocols help them store state, exchange histories, and retrieve past knowledge so the system behaves consistently over time. 4. Security & Governance Every agent interaction must be audited, authorized, and safe. These standards ensure identity, access control, compliance, and safe execution, especially when agents touch production systems. 5. Coordination & Control This is the orchestration layer. It handles oversight, delegation, decision-making, and task handoffs - enabling multi-agent pipelines to work as one coherent system. - Why this matters As AI agents move from prototypes to production, understanding these protocol layers becomes essential. Models generate intelligence - but protocols create order, safety, and scale. If you want agents that can collaborate, negotiate, and execute reliably, this is the foundation to build on.

𝗜𝗳 𝘆𝗼𝘂 𝘀𝘄𝗮𝗽𝗽𝗲𝗱 𝘆𝗼𝘂𝗿 𝗟𝗟𝗠 𝘃𝗲𝗻𝗱𝗼𝗿 𝘁𝗼𝗺𝗼𝗿𝗿𝗼𝘄, 𝘄𝗼𝘂𝗹𝗱 𝘆𝗼𝘂𝗿 𝗔𝗜 𝗮𝗴𝗲𝗻𝘁𝘀, 𝘁𝗼𝗼𝗹𝘀, 𝗮𝗻𝗱 𝘄𝗼𝗿𝗸𝗳𝗹𝗼𝘄𝘀 𝘀𝘁𝗶𝗹𝗹 𝘄𝗼𝗿𝗸... 𝗼𝗿 𝘄𝗼𝘂𝗹𝗱 𝗲𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴 ���𝗻𝗮𝗽 𝗶𝗻 𝗵𝗮𝗹𝗳? Over the last few weeks, MCP (Model Context Protocol) has quietly gone from “cool open-source project” to real infrastructure for solving that exact problem:  • Microsoft just moved MCP support for Azure Functions to GA, with identity-aware, streamable tool triggers so agents can call serverless functions safely.   • Google announced official MCP support across Google Cloud services, with fully managed MCP servers for BigQuery, GKE, GCE and more.  • Anthropic donated MCP to the Agentic AI Foundation under the Linux Foundation, alongside OpenAI’s AGENTS.md and Block’s goose, making MCP a neutral, open standard that looks a lot like the “HTTP moment” for agentic AI. This is bigger than plumbing; it’s a shift in how we architect agents: 𝗧𝗼𝗼𝗹𝘀 𝗯𝗲𝗰𝗼𝗺𝗲 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝘀,𝘁𝗵𝗲 𝗽𝗿𝗼𝘁𝗼𝗰𝗼𝗹 𝗯𝗲𝗰𝗼𝗺𝗲𝘀 𝘁𝗵𝗲 𝗽𝗹𝗮𝘁𝗳𝗼𝗿𝗺 𝗮𝗻𝗱 𝘁𝗵𝗲 𝗺𝗼𝗱𝗲𝗹 𝗯𝗲𝗰𝗼𝗺𝗲𝘀 𝗮 𝗿𝗲𝗽𝗹𝗮𝗰𝗲𝗮𝗯𝗹𝗲 𝗰𝗼𝗺𝗽𝗼𝗻𝗲𝗻𝘁. If you’re building enterprise AI agents, here’s how I’d think about MCP and standardized workflows:  1. 𝗗𝗲𝗳𝗶𝗻𝗲 𝘁𝗼𝗼𝗹𝘀 𝗮𝘀 𝗰𝗼𝗻𝘁𝗿𝗮𝗰𝘁𝘀, 𝗻𝗼𝘁 𝗵𝗲𝗹𝗽𝗲𝗿𝘀: treat each MCP tool as a versioned, testable API surface with strict schemas, auth scopes, and SLAs, not as a “convenience wrapper” hidden inside prompt code.  2. 𝗦𝗲𝗽𝗮𝗿𝗮𝘁𝗲 𝗼𝗿𝗰𝗵𝗲𝘀𝘁𝗿𝗮𝘁𝗶𝗼𝗻 𝗳𝗿𝗼𝗺 𝗶𝗻𝗳𝗲𝗿𝗲𝗻𝗰𝗲: let your workflow engine (orchestrator) own state, routing, retries, and compensations, and let MCP tools + models handle reasoning and side effects behind that control plane.  3. 𝗖𝗲𝗻𝘁𝗿𝗮𝗹𝗶𝘇𝗲 𝗴𝗼𝘃𝗲𝗿𝗻𝗮𝗻𝗰𝗲 𝗮𝘁 𝘁𝗵𝗲 𝗽𝗿𝗼𝘁𝗼𝗰𝗼𝗹 𝗯𝗼𝘂𝗻𝗱𝗮𝗿𝘆: enforce identity, permissions, rate limits, tenant isolation, and audit logging at the MCP layer so every model and agent inherits the same guardrails by design.  4. 𝗗𝗲𝘀𝗶𝗴𝗻 𝗳𝗼𝗿 𝗺𝗼𝗱𝗲𝗹 𝗮𝗻𝗱 𝘃𝗲𝗻𝗱𝗼𝗿 𝗺𝗼𝗯𝗶𝗹𝗶𝘁𝘆: write conformance tests at the MCP level so you can plug different LLMs or agent runtimes into the same tool graph without re-wiring business logic.  5. 𝗠𝗮𝗸𝗲 𝘄𝗼𝗿𝗸𝗳𝗹𝗼𝘄𝘀 𝗠𝗖𝗣-𝗻𝗮𝘁𝗶𝘃𝗲, 𝗻𝗼𝘁 𝗺𝗼𝗱𝗲𝗹-𝗻𝗮𝘁𝗶𝘃𝗲: when you design a new agentic workflow, start by asking “what MCP tools and flows do we expose?” rather than “what should this model prompt say?” so your investment lives in protocols, not in one provider’s SDK. If MCP is the “USB-C for AI agents,” the 𝗿𝗲𝗮𝗹 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁𝗶𝗮𝘁𝗼𝗿 won’t be who has the flashiest agent demo—it’ll be who designs the cleanest, most 𝗴𝗼𝘃𝗲𝗿𝗻𝗮𝗯𝗹𝗲 𝗠𝗖𝗣-𝗻𝗮𝘁𝗶𝘃𝗲 𝘄𝗼𝗿𝗸𝗳𝗹𝗼𝘄𝘀 across their stack.

It's been thirteen months since Anthropic dropped MCP, and it has become the de facto standard for connecting agents to systems, both internal and external. Thousands of servers. SDKs in every major language. Adoption from OpenAI, Microsoft, Google, and most of the major tooling vendors. Earlier this month, Anthropic donated MCP to The Linux Foundation, formalizing what the industry had already decided. This week, Anthropic released Agent Skills as an open standard. Agent Skills were introduced in October, but the move to open them up signals something important. Where MCP standardizes how agents connect to systems, Agent Skills standardize how agents learn to do complex work. I spent some time this week trying to deconflict these two concepts. On the surface, they seem like they could overlap. The short answer here is they do overlap, in the sense that both shape how agents work. But Anthropic built these two standards to be complementary by design. MCP gives agents new tools. Callable functions with JSON schemas. Connect to Salesforce. Query a database. Post to Slack. The agent gains capability it didn't have before. Agent Skills don't give agents new tools. They teach agents how to use the tools they already have. A PDF skill doesn't create a "fill_form" function. It provides instructions that tell the agent to run a Python script via bash, read the output, and proceed. The tools stay the same. The agent just gets better at using them. The architectural difference that matters most is token efficiency. MCP loads tool definitions upfront. Complex servers can consume 50,000 tokens before the agent does anything. Agent Skills use progressive disclosure. At startup, the agent sees a short description, maybe 100 tokens. Full instructions load only when the skill becomes relevant. Both are now open standards. Both are being adopted across vendors. The infrastructure for agentic AI is solidifying faster than I expected. For risk practitioners, you have two distinct surfaces to manage here. MCP servers represent access risk. What systems can this agent reach? Are credentials secure? Do we have complete observability across the LLM call, tool call, and target system? Agent Skills represent instruction risk. What procedures has the agent internalized? Who authored this skill, and was it validated before deployment? Can a malicious skill poison the agent's behavior? https://lnkd.in/gtuziRRc

Perhaps the most critical enabler for scalable agentic systems today is the emergence of formal agent communication protocols. As organizations start deploying multiple agent systems across sales, legal, ops, and internal tools , they’re quickly realizing that even great agents break down when they can’t talk to each other. What’s missing is not more LLMs, but standards for how agents coordinate. Let’s say your CEO gets excited by a Salesforce demo and signs up for AgentForce, a platform that promises automated contract review. The results fall short. It routes documents but lacks reasoning, memory, or recovery paths. So your engineering team layers in LangGraph to build a smarter pipeline: clause extraction, redline generation, fallback logic, and human-in-the-loop escalation. Then the CEO meets with Google, sees a demo of Agentspace, and kicks off a new MVP giving employees a Chrome-based AI assistant that can answer questions, summarize docs, and suggest revisions. Now you have three agent systems running… and none of them are compatible. This is where agent protocols become essential. They’re not frameworks or tools. They’re the glue that defines how agents interact across platforms, vendors, and use cases. There are four key types: • 𝗠𝗖𝗣 (𝗠𝗼𝗱𝗲𝗹 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹) handles how a single agent uses tools in its environment. Whether in LangGraph or AgentForce, every tool (e.g., clause scorer, template filler) can be invoked using a standard wrapper. • 𝗔𝟮𝗔 (𝗔𝗴𝗲𝗻𝘁-𝘁𝗼-𝗔𝗴𝗲𝗻𝘁 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹) defines how agents exchange structured messages. A risk-analysis agent in LangGraph can send its findings to a negotiation agent in Agentspace, even if they were built by different teams. • 𝗔𝗡𝗣 (𝗔𝗴𝗲𝗻𝘁 𝗡𝗲𝘁𝘄𝗼𝗿𝗸 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹) ensures that agents formally declare inputs and outputs. If the finance agent in AgentForce expects a JSON summary, ANP ensures that other agents deliver it in the right format with validation. • 𝗔𝗴𝗼𝗿𝗮 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹 supports natural language-based negotiation between agents. When structure breaks down agents can dynamically agree on how to share context and interpret intent. The point is, these protocols enable composability. They make it possible to build agent systems where different vendors, models, and workflows can interoperate. Without them, you end up with silos—each agent powerful on its own but useless together. Most companies don’t realize they’ve hit this wall until it’s too late. They start with one agent platform, then bolt on a second, then hit scaling issues, redundant logic, or conflicting behaviors. Protocols like A2A, ANP, and Agora give you a way to standardize communication and preserve flexibility. If your org is working with multiple agent platforms or planning to integrate them across domains, it may be time to design around protocols and not just prompts.

Agentic AI and the Model Context Protocol (MCP): Why Apache Kafka Is the Missing Link: #AgenticAI systems are starting to move from research to real enterprise use. A key enabler of this shift is the Model Context Protocol (#MCP). MCP defines a standard way for #AI agents, tools, and applications to share context and communicate effectively. It allows agents to access structured data, call external APIs, and collaborate with other systems. However, MCP alone is not enough. It needs a #DataStreaming backbone with an #EventDrivenArchitecture to provide real-time, reliable, and scalable access to the data and events that drive intelligent behavior. This is where #ApacheKafka comes in. Kafka acts as the event broker that connects all components of an agentic architecture. It continuously streams data between systems, ensuring that AI agents always work with the most recent and accurate information. MCP defines howagents communicate; Kafka enables what they communicate: contextual, time-sensitive data that reflects the real world. With Kafka as the event layer, MCP-based agents can: - Subscribe to real-time events from business systems, IoT devices, or APIs from cloud services. - Publish insights, actions, or recommendations back to the enterprise in milliseconds. - Replay historical events for learning, auditing, or debugging. - Connect to both operational and analytical systems with full decoupling and traceability. This combination eliminates brittle point-to-point spaghetti integrations. Instead, it creates a flexible, event-driven architecture where AI agents, #microservices, and applications communicate through Kafka topics, governed and secured by the data streaming platform. In simple terms, MCP provides the language for agents to collaborate, while Kafka provides the bloodstream that keeps their context fresh and alive. Together, they form the backbone of modern agentic AI architectures: modular, adaptive, and ready to scale across cloud and edge environments. If AI agents depend on context to act intelligently, how valuable can they really be without a continuous stream of fresh, trusted data flowing through Kafka?

Just reviewed IBM's groundbreaking guide on building enterprise AI agents with MCP, and it's a game-changer. If you're developing agentic AI solutions for enterprise, this verified framework from IBM and Anthropic is essential reading. The paradigm shift is real:- - From deterministic to probabilistic systems. - From static to adaptive behavior. - From code-first to evaluation-first development. Key insight: Traditional DevSecOps isn't enough. AI agents require an entirely new development lifecycle (ADLC) that addresses:- ✓ Non-deterministic outputs (same input ≠ same output). ✓ Autonomous decision-making with real business impact. ✓ Expanded attack surfaces (prompt injection, tool misuse). ✓ Continuous drift monitoring vs. one-time testing. The MCP (Model Context Protocol) advantage:- Instead of building bespoke integrations for every tool, MCP standardizes how agents access enterprise systems. It serves as the 'API standard' for agentic AI, with built-in security, governance, and observability. Real-world validation:- The guide includes case studies from healthcare (HIPAA-compliant agents), telecom (95% accuracy requirements), and finance (regulatory compliance) that demonstrate these patterns work at enterprise scale. My biggest takeaway:- Sandboxing isn't optional anymore. With agents executing dynamic code and accessing sensitive data, infrastructure-level isolation and gateway-level governance create a defense in depth. Bottom line:- If you're serious about production-grade AI agents, you need evaluation frameworks, governed catalogs, continuous monitoring, and security integrated from day one, not added later. The full guide covers everything from planning to retirement, with practical checklists and architecture patterns. Are you building enterprise AI agents? What’s your biggest challenge - security, evaluation, or governance. #AIAgents #EnterpriseAI #MCP #DevSecOps #AgenticAI #AIGovernance #MachineLearning

I’m pleased to share one of our latest papers from Santander AI Lab: “Self-Evolving Coordination Protocol in Multi-Agent AI Systems: An Exploratory Systems Feasibility Study”. This work tackles a structural problem in agentic AI: coordination mechanisms are typically static, while the environments they operate in are dynamic, uncertain, and often regulated. That tension creates fragility. In this paper, we introduce the concept of Self-Evolving Coordination Protocols (SECPs) �� coordination layers that can adapt their own logic within bounded, formally verifiable constraints. The key idea is not unconstrained self-modification, but governed evolution: systems that can expand decision coverage while preserving safety, auditability, and fault tolerance. What is novel here is the combination of: -- Controlled self-adaptation at the protocol level ---External validation mechanisms -- Formal guarantees suitable for high-trust domains such as finance For regulated industries, this is not a theoretical exercise. If multi-agent systems are to operate at scale, their coordination logic must be as robust as their predictive models. At Santander AI Lab, we are exploring how to move from static consensus mechanisms to adaptive, governed coordination architectures — a necessary step toward production-grade agentic systems. Open to discussion and collaboration with researchers and practitioners working on multi-agent governance, formal methods, and trustworthy AI. 🔗 https://lnkd.in/e9yG6xNp

🚀 Why Model Context Protocol (MCP) could change the way we build AI Agents When I was delivering a session on Multi Agent AI Ecosystem at Huddle, an event organized by Kerala Startup Mission last year, a question came up —"How can we build AI agents that not only connect but also work together ?". A few days later, in another session with a NASSCOM group of fellow AI enthusiasts, the same debate resurfaced. In both the forums, we all acknowledged the difficulty and agreed that the protocols we had - like Knowledge Query and Manipulation Language (KQML) and Foundation for Intelligent Physical Agents (FIPA)—helped, but they had their limitations. 👉 This is why Model Context Protocol (MCP) is getting so much attention now. Building an AI agent ecosystem today is like running a company where different teams—marketing, engineering, and finance—each work in silos. They all have valuable data, but without a shared project management system, things get duplicated, key insights get lost, and efficiency drops. Now imagine this analogy with AI models. Each large language model (LLM) has its own way of processing and storing context. They don’t naturally share information or build on each other’s knowledge. This makes multi-agent collaboration difficult. This reminds me of how the internet worked before Transmission Control Protocol/Internet Protocol (TCP/IP). Back then, different networks couldn’t talk to each other efficiently. TCP/IP changed that by creating a standard protocol, making seamless communication possible. MCP is doing something similar for AI agents. What does MCP solve? 🔹 Context persistence – AI agents won’t forget past interactions, making them more useful over time. 🔹 Efficient Multi-Agent workflows – Agents can divide work intelligently instead of repeating efforts. 🔹 Standardized communication – Different AI models can work together without compatibility issues. 👉 How is MCP different from other protocols? We did have AI communication protocols before—KQML, FIPA, RESTful APIs, and Simple Public Key Infrastructure (SPKI/SDSI)— that were designed for specific communication needs. But these don’t handle shared memory or deep agent collaboration like MCP does. MCP is built for LLM-based AI agents, ensuring they can store, retrieve, and build on context dynamically—just like how humans remember and build upon past experiences in a conversation. Just like TCP/IP enabled the internet, I strongly believe that MCP can unlock a new era of autonomous AI ecosystems. Instead of isolated models generating responses independently, we’ll have AI agents that work together, share knowledge, and continuously learn from one another. The needle has moved beyond "smart AI" to --> "AI that truly collaborates". I write about #artificialintelligence | #technology | #startups | #mentoring | #leadership | #financialindependence   PS: All views are personal Vignesh Kumar