<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Parthh Pathak on Medium]]></title>
        <description><![CDATA[Stories by Parthh Pathak on Medium]]></description>
        <link>https://medium.com/@parth1078?source=rss-123889bd5f35------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*pY-IdTFPymMACIypUh_AEA.jpeg</url>
            <title>Stories by Parthh Pathak on Medium</title>
            <link>https://medium.com/@parth1078?source=rss-123889bd5f35------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 23:35:25 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@parth1078/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Realizing: Agent-to-Agent Communication]]></title>
            <link>https://generativeai.pub/realizing-agent-to-agent-communication-fc0d5107523a?source=rss-123889bd5f35------2</link>
            <guid isPermaLink="false">https://medium.com/p/fc0d5107523a</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[generative-ai-solution]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[web3]]></category>
            <dc:creator><![CDATA[Parthh Pathak]]></dc:creator>
            <pubDate>Wed, 23 Sep 2026 03:00:55 GMT</pubDate>
            <atom:updated>2026-09-23T03:00:55.562Z</atom:updated>
            <content:encoded><![CDATA[<h4>How protocols, registries, and orchestration turn independent AI agents into one coordinated system.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BZjEkCb9shQEjnooBtwjhg.png" /></figure><p>The <a href="https://medium.com/agentic-web/global-backbone-of-the-agentic-web-building-blocks-531f5fa976cc">last piece</a> in this series laid out a six-layer stack for the Agentic Web: trust, identity, communication, delegation, orchestration, and memory. That stack answers what needs to exist. This piece answers a narrower question: once those layers are in place, what actually makes a pile of independent agents behave like one coordinated system?</p><p>Three things, as it turns out. A shared <strong>protocol</strong> so agents can talk to each other without a translator. <strong>A registry</strong> so an orchestrator can find the right agent instead of hard-coding a list of endpoints. And a <strong>planning layer</strong>, the part I’ll call the Brain, that turns a human’s intent into a working plan and routes it across the mesh.</p><p>Put those three things around a set of specialized agents, and you get what the earlier article called a quilt: dozens of narrow, purpose-built agents stitched together into something that can handle a real workflow. The quilt is the output. Protocol, registry, and Brain are what make the stitching possible.</p><h4><strong>The Protocol Layer: Three Standards, Three Different Jobs</strong></h4><p>Ask five people what “agent-to-agent communication” means, and you’ll get five different answers because the industry hasn’t converged on a single protocol. Instead, it has converged on three: MCP, A2A, and ANP; each solving a different slice of the problem. Here’s how the three line up:</p><pre>+----------------+-----------------------+-----------------------+-----------------------+<br>| DIMENSION      | MCP                   | A2A                   | ANP                   |<br>+----------------+-----------------------+-----------------------+-----------------------+<br>| Purpose        | Vertical connection:  | Horizontal connection:| Peer-to-peer inter-   |<br>|                | Defines how one agent | Defines how two inde- | actions. Trustless,   |<br>|                | talks to its toolbox. | pendent agents find &amp; | no central authority  |<br>|                |                       | exchange tasks.       | or shared registry.   |<br>+----------------+-----------------------+-----------------------+-----------------------+<br>| Governed by    | Anthropic, open spec  | Linux Foundation      | Open source community |<br>|                |                       | (orig. Google)        |                       |<br>+----------------+-----------------------+-----------------------+-----------------------+<br>| Primary job    | Agent to tool access  | Cross vendor task     | Decentralized peer to |<br>|                |                       | delegation            | peer discovery        |<br>+----------------+-----------------------+-----------------------+-----------------------+<br>| Topology       | Hub and spoke,        | Client server,        | Decentralized mesh    |<br>|                | host to server        | task delegation       |                       |<br>+----------------+-----------------------+-----------------------+-----------------------+<br>| Transport      | stdio,                | HTTPS, SSE,           | HTTPS and decentral-  |<br>|                | Streamable HTTP       | webhooks, gRPC        | ized transports       |<br>+----------------+-----------------------+-----------------------+-----------------------+<br>| Identity       | Host managed OAuth    | OAuth 2.0, mTLS,      | Cryptographic         |<br>| &amp; Auth         | or API keys           | A2A extensions        | W3C DIDs              |<br>+----------------+-----------------------+-----------------------+-----------------------+<br>| Discovery      | Manual or             | /.well-known/         | DID resolution        |<br>|                | static config         | agent-card.json       | and .well-known       |<br>+----------------+-----------------------+-----------------------+-----------------------+</pre><p>The Model Context Protocol, or MCP, is the one most developers have already touched. It serves as a vertical tether connecting an agent directly to its tools. However, it is not built for agent-to-agent conversation, and it was never meant to be.</p><p>The Agent-to-Agent protocol, A2A, fills that exact gap. Proposed by Google and now stewarded by the Linux Foundation, it handles the horizontal task exchange between agents. Yet, A2A leaves critical pieces undefined. It does not standardize a native publish-and-subscribe pattern for many agents listening to one event, nor does it provide a single signed envelope that carries proof of identity and authority with every message.</p><p>Finally, the Agent Network Protocol, ANP, takes a different bet entirely. Though less mature and driven largely by open-source community efforts, ANP targets a scenario the others sidestep. It asks what happens when agents need to trust each other directly with no intermediary at all.</p><p>Here is the overarching point I want to make. None of these three protocols is wrong, and none of them is the whole answer. MCP handles the vertical connection to tools. A2A handles horizontal task exchange between agents. ANP handles the trustless, no-registry case. What <strong>remains missing</strong> across all three is <strong><em>a shared envelope</em></strong>.</p><p>We desperately need a unified layer that allows a message to carry the identity and authority of its sender in a form every recipient can verify, regardless of which protocol moved it. That missing link, a unifying communication layer carrying undeniable proof of provenance, is exactly what Layer 3 of the proposed stack was designed to solve.</p><h4>The Registry Layer: Finding the Right Agent</h4><p>A protocol only matters once you know who to send the message to. That’s the registry’s job, and it’s exactly the semantic DNS problem described in Layer 2 of the earlier article: not <strong>“where is agent X,” but “find me an agent that can do Y, certified for Z, under this latency budget.”</strong></p><p>A handful of real projects are already building toward that:</p><pre>+-----------------------+----------+-----------------------------------+-------------------------------------------------------------------+<br>| REGISTRY / SOLUTION   | ORG      | PRIMARY FOCUS                     | KEY MECHANICS &amp; FEATURES                                          |<br>+-----------------------+----------+-----------------------------------+-------------------------------------------------------------------+<br>| NANDA Index           | MIT      | Global Agent Discovery            | Maps decentralized identifiers to capability descriptions.        |<br>|                       |          |                                   | Separates routing information from verifiable trust claims so     |<br>|                       |          |                                   | lookups and trust checks are decoupled.                           |<br>+-----------------------+----------+-----------------------------------+-------------------------------------------------------------------+<br>| Google Agent Registry | Google   | Enterprise Governance             | Centralized catalog for MCP servers and A2A agents inside Google  |<br>|                       |          |                                   | Cloud. Prevents redundant integrations and pairs with Agent       |<br>|                       |          |                                   | Gateway to enforce permissions.                                   |<br>+-----------------------+----------+-----------------------------------+-------------------------------------------------------------------+<br>| AWS Agent Registry    | AWS      | Enterprise Discovery &amp; Federation | Provides a centralized, searchable catalog within AWS for agents, |<br>|                       |          |                                   | tools, and MCP servers with built-in approval workflows. Supports |<br>|                       |          |                                   | the open Agentic Resource Discovery (ARD) specification, enabling |<br>|                       |          |                                   | federation across different registries and multi-cloud            |<br>|                       |          |                                   | environments like a DNS for agents.                               |<br>+-----------------------+----------+-----------------------------------+-------------------------------------------------------------------+<br>| fetch.ai              | fetch.ai | Personal AI Agents with Discovery | Within the Fetch.ai ecosystem, Agentverse acts as the central     |<br>|                       |          |                                   | discovery and growth engine. Rather than serving as a static      |<br>|                       |          |                                   | directory, it functions as a live semantic registry where systems |<br>|                       |          |                                   | can find, evaluate, and deploy agents based strictly on their     |<br>|                       |          |                                   | capabilities and operational constraints.                         |<br>+-----------------------+----------+-----------------------------------+-------------------------------------------------------------------+</pre><p><a href="https://nandaindex.org/">NANDA Index</a>, <a href="https://docs.cloud.google.com/gemini-enterprise-agent-platform/govern/agent-registry">Google Agent Registry</a>, <a href="https://aws.amazon.com/blogs/machine-learning/agentic-resource-discovery-ard-an-open-specification-for-agent-discovery/">AWS Agent Registry</a>, and <a href="http://fetch.ai/">fetch.ai</a>.</p><p>Along with a registry, you need an agent’s resume for the registry to search against. That resume is Agent Facts. Picture a newly minted AI agent arriving at a massive digital switchboard like the AWS or Google Registry. Rather than waiting passively, it immediately presents a highly structured resume.</p><p>This capability manifest holds the vital “Agent Facts” required for discovery: the agent’s exact identity, its authorized permissions, and its strict operational boundaries. By broadcasting these core attributes long before any work begins, the registry transforms from a blind directory into an intelligent matchmaker, instantly pairing complex jobs with the exact digital worker built to solve them.</p><pre>+-------------------------------------------------------------+<br>|                                                             |<br>|                       AGENT FACTS                           |<br>|                    (Capability Manifest)                    |<br>|                                                             |<br>+-------------------------------------------------------------+<br>|                                                             |<br>|  [1] IDENTITY &amp; GOVERNANCE                                  |<br>|      * Decentralized ID (DID)                               |<br>|      * Publisher / Owner Info                               |<br>|      * Version Number                                       |<br>|      * Approval Status (Pending / Approved)                 |<br>|                                                             |<br>|  [2] SEMANTIC CAPABILITIES                                  |<br>|      * Executable Task Descriptions                         |<br>|      * Connected Tools &amp; Endpoints                          |<br>|      * Input/Output Data Formats (MIME types)               |<br>|                                                             |<br>|  [3] TRUST &amp; COMPLIANCE                                     |<br>|      * Cryptographic Signatures                             |<br>|      * Regulatory Certifications (e.g., SOC 2, HIPAA)       |<br>|      * Operational &amp; Financial Constraints                  |<br>|                                                             |<br>+-------------------------------------------------------------+</pre><p>Different projects, different motivations, but the same underlying need. Without a centralized registry and standardized Agent Facts feeding it, every multi-agent system has to be wired by hand, which is fine for a demo and unworkable at scale.</p><h4>The Brain: Turning Intent Into a Plan</h4><p>This is the part that actually does the coordinating, what Layer 5 of the stack calls the Orchestration Mesh. Give it a complex goal, and it has to figure out which agents are needed, in what order, and how to route the work between them, all without a human standing in the loop for every step. It helps to break that into three stages:</p><p><strong>Planning</strong>: A supervisor agent takes the incoming goal and decomposes it into a directed acyclic graph, a map of tasks where each node knows what has to finish before it can start. Frameworks like LangGraph make this concrete. Once the plan exists as a graph rather than a script, a few things become possible almost for free: independent subtasks can fan out to multiple agents in parallel, dependent steps can wait behind a synchronization barrier until everything upstream is ready, and the plan can branch conditionally based on what earlier steps return.</p><p><strong>Resolution:</strong> Once the plan says “this node needs an agent that can do X,” something has to translate that requirement into an actual candidate. This stage takes the natural language description of what’s needed and turns it into a structured capability query against the registry, coming back with a ranked list of agents that fit the skill, price, and compliance requirements for that specific node. It’s worth naming this stage carefully. OWASP has its own proposal in this space called the Agent Name Service, and rather than reuse that name for a different design, it’s cleaner to call this stage what it does: capability resolution.</p><p><strong>Gateway:</strong> Once a specific agent has been chosen, something has to turn that logical identity into a live, secure network connection. The gateway handles the actual handoff, negotiates the protocol exchange (A2A, most commonly, for cross-vendor calls), and keeps the communication channel bound and authenticated for the life of the task.</p><p>Planning decides what needs to happen. Resolution decides who does it. The gateway makes the connection real. Together, that’s what turns a set of independently capable agents into a single system that can execute a goal a human only had to state once.</p><h4>Where This Leaves Us</h4><p>Go back to the Cisco analogy from the first article in this series. Cisco didn’t win by building the smartest application. It won by owning the layer every application had to run through to talk to anything else. Protocol, registry, and orchestration are that layer for the Agentic Web: not the agents themselves, but the connective tissue that lets independently built agents behave like one coordinated system instead of five hundred employees with no shared language.</p><p>The pieces exist today in early, uneven form. MCP and A2A are real and in production. Registries like NANDA and fetch.ai are running at a meaningful scale. Orchestration frameworks like LangGraph are already shipping the planning stage described above.</p><p>What’s still missing is the unifying envelope from Layer 3 and a delegation model mature enough to make the payment layer trustworthy at scale, which is exactly where the next article in this series picks up.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*m9M97I8JFb8-Xa-x.png" /></figure><p>This story is published under the <a href="https://generativeai.pub/">Generative AI</a> publication. Connect with us on <a href="https://www.linkedin.com/company/generative-ai-publication">LinkedIn</a> and follow <a href="https://www.zeniteq.com/">Zeniteq</a> to stay in the loop with the latest AI stories. Let’s shape the future of AI together!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*Yif2bpjdT3vDJvUr.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fc0d5107523a" width="1" height="1" alt=""><hr><p><a href="https://generativeai.pub/realizing-agent-to-agent-communication-fc0d5107523a">Realizing: Agent-to-Agent Communication</a> was originally published in <a href="https://generativeai.pub/">Generative AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Global Backbone of the Agentic Web: Concept]]></title>
            <link>https://medium.com/agentic-web/global-backbone-of-the-agentic-web-concept-756f68ad63b2?source=rss-123889bd5f35------2</link>
            <guid isPermaLink="false">https://medium.com/p/756f68ad63b2</guid>
            <dc:creator><![CDATA[Parthh Pathak]]></dc:creator>
            <pubDate>Mon, 27 Jul 2026 21:43:19 GMT</pubDate>
            <atom:updated>2026-07-28T13:51:54.942Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Building the Agentic Web with an Operating System underneath the Operating System</strong></p><p><strong>Authors:</strong> <a href="https://medium.com/@parth1078">Parthh Pathak</a> and <a href="https://medium.com/@mahendru.sandeep">Sandeep Mahendru</a></p><p>Everyone is talking about smarter AI models. We are obsessed with benchmark scores and parameter counts. But we are missing the much bigger problem: <strong>what is the point of smarter AI if these agents cannot talk to each other?</strong></p><p>Right now, organizations are rapidly deploying an army of disconnected AI assistants. One tool summarizes meetings. Another writes code. Another analyzes legal documents. Another answers customer questions. It sounds incredibly efficient until you realize you have just hired hundreds of digital workers who do not naturally know how to communicate, trust each other, or coordinate.</p><p><em>Imagine onboarding 500 human employees tomorrow. Now, imagine giving them no organizational chart, no operating model, and no shared language.</em></p><p><strong>Chaos</strong></p><p>That is exactly where enterprise AI is heading. The next wave of AI will not be defined solely by building smarter agents. It will be defined by building the system that lets those agents work together, “the invisible infrastructure”, the <strong><em>operating system underneath the operating system</em></strong>. Without deliberate investment in this shared infrastructure, the AI industry will fracture into incompatible silos, much like enterprise software did before the commercial internet forced interoperability.</p><h3>The “Cisco Moment” for AI</h3><p>We are transitioning into the <strong>third wave of AI</strong> adoption. The <strong>first</strong> wave treated models as oracles (users asked questions). The <strong>second</strong> wave treated them as tools (users invoked APIs). The third wave treats models as <strong>agents</strong>: systems that receive intent and autonomously execute multi-step plans across tools, data sources, and other agents.</p><p>The development paradigm is shifting from “code-first” to “intent-first.” Developers are decomposing monolithic applications into quilts of autonomous, specialized agents. However, frameworks like LangChain, CrewAI, and AutoGen lack a standardized interoperability layer. An agent built on one framework cannot discover, trust, or communicate with an agent built on another.</p><p><strong>The Evolution of Agentic Development</strong></p><p><em>The industry is rapidly shifting from “writing code” to “describing tasks.”</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fLnSqpGAPo6m1uDUGwVePg.png" /></figure><p><strong><em>Reference: </em></strong><a href="https://medium.com/@mahendru.sandeep/proposal-for-the-global-backbone-of-the-agentic-web-718339ae25f2"><em>https://medium.com/@mahendru.sandeep/proposal-for-the-global-backbone-of-the-agentic-web-718339ae25f2</em></a></p><p>We are facing an infrastructure gap identical to the one Cisco, 3Com, and the IETF closed for the packet-switched internet in the 1980s and 1990s.</p><h3>Why Existing Primitives Are Insufficient</h3><p>To understand the required infrastructure, we must first define exactly why our current tools fail to support an interconnected Agentic Web.</p><p><strong>Trust:- </strong>No cryptographic root or Public Key Infrastructure (PKI) exists for agents. There is no hardware attestation to verify an agent is running the model it claims in a secure environment.</p><p><strong>Identity:- </strong>OAuth, SAML, and API keys are built for humans or static integrations, not ephemeral agents that spawn, execute a task, and terminate in 30 seconds.</p><p><strong>Discovery:- </strong>There is no semantic registry (like a DNS for agents) to query agents based on capabilities, latency, or regulatory compliance (e.g., HIPAA certification).</p><p><strong>Communication:- </strong>Existing protocols (like MCP or A2A) do not specify a complete, transport-agnostic wire format for synchronous calls, streaming, pub/sub, and signed message provenance.</p><p><strong>Delegation:- </strong>OAuth scopes and RBAC roles offer no principled way to handle 5-to-6 hop delegation chains where an orchestrator agent transfers limited authority to sub-agents.</p><p><strong>Accountability:-</strong>There is no standard ledger for immutable agent action logging that meets the evidentiary standards of SOC 2 Type II or the EU AI Act.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JvL1Az_nkPhOq59IhzDRhA.png" /></figure><p>Refer the article to the Agentic Web <a href="https://medium.com/agentic-web/global-backbone-of-the-agentic-web-building-blocks-531f5fa976cc?postPublishedType=repub">Building Blocks</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=756f68ad63b2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/agentic-web/global-backbone-of-the-agentic-web-concept-756f68ad63b2">Global Backbone of the Agentic Web: Concept</a> was originally published in <a href="https://medium.com/agentic-web">Agentic Web</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Global Backbone of the Agentic Web: Building Blocks]]></title>
            <link>https://medium.com/agentic-web/global-backbone-of-the-agentic-web-building-blocks-531f5fa976cc?source=rss-123889bd5f35------2</link>
            <guid isPermaLink="false">https://medium.com/p/531f5fa976cc</guid>
            <category><![CDATA[networking]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[observability]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[memories]]></category>
            <dc:creator><![CDATA[Parthh Pathak]]></dc:creator>
            <pubDate>Sat, 04 Jul 2026 21:10:37 GMT</pubDate>
            <atom:updated>2026-07-27T21:41:22.438Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Continuation from Agentic Web </strong><a href="https://medium.com/@parth1078/global-backbone-of-the-agentic-web-concept-building-blocks-2b5a3a80c924"><strong>Design</strong></a></p><p><strong>Authors:</strong> <a href="https://medium.com/@parth1078">Parthh Pathak</a> and <a href="https://medium.com/@mahendru.sandeep">Sandeep Mahendru</a></p><h3>A New OSI Like Stack is Required: To Realize Agentic Web</h3><p>Just as Cisco and the IETF closed the infrastructure gap for the packet-switched internet in the 1990s, to realize true Agent-to-Agent communication, the OSI-style, six-layer technology stack below is required.</p><p>This technology stack addresses gaps in the existing primitives covered in the previous article. This model is deliberately analogous to the OSI reference model. Like OSI, it is a conceptual framework rather than an implementation prescription — each layer defines its interfaces and contracts, and implementations may vary as long as the contracts are honored. Like OSI, the value of the model is that it allows each layer to evolve independently: a superior attestation mechanism at Layer 1 does not require re-engineering Layer 5.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*EScG_WEzQkZhwxBzs6NOCw.jpeg" /><figcaption>Agentic OSI Layer</figcaption></figure><p><strong>Layer 1 — Trust Substrate.</strong> The cryptographic foundation on which everything else rests. It is the cryptographic foundation that everything else in the stack depends on, and it does three things.</p><ul><li><strong>First</strong>, it gives every agent a tamper-proof certificate, essentially a digital ID card. This builds on X.509, the same certificate standard that already secures websites, but extends it to carry information specific to agents.</li><li><strong>Second</strong>, it ties that identity to the actual hardware the agent runs on. Using secure chip features (such as Intel SGX/TDX and TPM 2.0), the system can confirm that an agent really is running the specific model it claims, inside a protected environment that can’t be faked or tampered with. Because this proof is rooted in hardware rather than software, it is extremely hard to forge.</li><li><strong>Third</strong>, it keeps a public, append-only log of every certificate that gets issued — a Certificate Transparency log. Anyone can inspect this record to see which agents were granted credentials and by whom, and this works without relying on a single central authority that everyone has to trust.</li></ul><p><strong>Layer 2 — Identity and Discovery.</strong> In the Agentic Web, this layer allows the system to automatically “discover” and “hire” the best AI for the job in real-time, based on a specific set of requirements, without a human having to manually search for it. It works in two parts.</p><ul><li><strong>First,</strong> every agent gets a persistent, verifiable identifier using a W3C Decentralized Identifier (DID) — an identity the agent owns and controls, rather than one handed out by a single company. Associated with that identity is a capability manifest: a structured description of what the agent can do, the conditions it operates under, what it charges, and which compliance certifications it holds.</li><li><strong>Second,</strong> the Global Agent Registry Service (ARS) acts as the “semantic DNS” of the network. Ordinary DNS only translates a name into an address — you have to already know the name. The ARS goes further: it lets you search by capability and requirements, not just by name, and returns a ranked list of agents that fit, each with full provenance. It’s built to run as a globally federated, CRDT-backed directory, meaning it’s spread across many locations with no single point of failure and no central authority everyone is forced to trust.</li></ul><p><strong>Layer 3 — Communication.</strong> This layer is the grammar and the postal system of the Agentic Web. It ensures that when two agents “talk,” they understand each other perfectly, regardless of the app or server they are running on.</p><ul><li>At the center of this layer is the Agent Communication Protocol (ACP). ACP brings the three main ways agents communicate under one roof: a direct request and response (synchronous), a result that streams back over time (streaming), and a publish-and-subscribe broadcast that many agents can listen for (event-driven). Crucially, all three share a single signed message envelope, so the sender’s identity and authority travel with every message and can’t be forged or stripped away.</li><li>ACP is also transport-agnostic, meaning it doesn’t care which underlying network technology carries the message. The exact same rules and meaning apply whether a message travels over HTTPS/2, gRPC, WebSocket, or NATS JetStream. Developers can pick whichever transport suits their setup — broad compatibility, high internal throughput, or large-scale event streaming — without changing how agents understand each other.</li></ul><p><strong>Layer 4 — Delegation and Authorization.</strong> If the Identity layer is the “Passport,” this layer is the Power of Attorney. This is the most technically novel layer, with no adequate precedent in existing internet infrastructure. The proposed design builds on three established components rather than inventing from scratch.</p><ul><li>UCAN (User-Controlled Authorization Networks) provides the core mechanism. It lets an agent delegate specific capabilities with scope limits, time limits, and revocation by issuing signed tokens that form a verifiable proof chain, all without handing over any private keys. UCAN is already built around decentralized identifiers (DIDs), which is exactly the identity foundation Layer 2 establishes, and here it’s extended for agent-specific authority models.</li><li>Alongside it, Open Policy Agent (OPA) enforces policy at runtime — the rules that decide, in the moment, whether a given action is actually allowed.</li><li>And Zanzibar-style relationship graphs (the model behind Google’s authorization system) handle complex, multi-tenant decisions where permissions depend on webs of relationships between users, organizations, and resources rather than on simple roles.</li></ul><p><strong>Layer 5 — Orchestration.</strong> Orchestration is the brain that actually gets the job done. It’s the Project Manager that takes a complex goal and breaks it down into a step-by-step plan for the agents to follow.</p><ul><li>The Orchestration Mesh at this layer runs that plan as a DAG (Directed Acyclic Graph) a map of tasks where each step knows which steps must come before it. That structure unlocks several things at once; it can fan out work to many agents in parallel, hold a synchronization barrier so dependent steps wait until everything they need is ready, and take conditional branches so the plan adapts based on what earlier steps return.</li><li>It also has to handle failure gracefully, which is where two ideas come in. The Saga pattern handles partial failures. If a long workflow fails partway through, instead of leaving a mess behind, it runs compensating steps that cleanly unwind the work already done. And durable checkpointing, via a workflow engine like Temporal, periodically saves the workflow’s progress so it’s crash-safe. A job that has been running for two hours can survive an infrastructure failure and resume from its last saved point rather than starting over.</li></ul><p>Together, these are what transform a loose collection of capable agents into a single, coherent, goal-directed system. The orchestration layer isn’t one race, it’s several different bets, each shaped by where the company already sits. The simplest way to see it as the following three design patterns:</p><ul><li>Open-source developer frameworks — orchestration as code.</li><li>Hyperscaler managed platforms — orchestration as managed runtime, anchored to data gravity.</li><li>SaaS incumbents — orchestration centered on a domain system-of-record.</li></ul><p><strong>Layer 6 — Context and Memory. </strong>Agents are built to be stateless, each one spins up, does its job, and forgets everything when it terminates. Layer 6 is the stateful substrate that keeps agents coherent over time and across handoffs, think of it as long-term memory for agents.</p><p>The <strong>Context Exchange Service (CXS)</strong> at this layer maintains three tiers of memory, each tuned to a different speed and lifespan.</p><ul><li>Working memory is the fast, short-lived scratchpad for a workflow in progress, the place collaborating agents leave notes for each other in the moment.</li><li>Episodic memory stores past interactions as vector embeddings, so an agent can recall that a counterpart resolved a similar ambiguity a few workflows ago, ranked by how recent and how relevant it is.</li><li>Semantic memory holds long-horizon facts in persistent knowledge graphs — the accumulated knowledge that informs reasoning indefinitely.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=531f5fa976cc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/agentic-web/global-backbone-of-the-agentic-web-building-blocks-531f5fa976cc">Global Backbone of the Agentic Web: Building Blocks</a> was originally published in <a href="https://medium.com/agentic-web">Agentic Web</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>