1 of 29

Internet of Agents and the AGNTCY Project

2 of 29

An open-source collective for inter-agent collaboration. A project of the Linux Foundation

80+ collaborating organizations

Formative Members

3 of 29

A paradigm shift in computing is underway

Deterministic 🡪 Probabilistic

[ cloud computing 🡪 agentic computing ]

4 of 29

Agents must collaborate to solve problems

Like a team of subject matter experts

5 of 29

Agentic computing needs a collaboration framework

Agents

come from different vendors

use different development frameworks

run on different clouds

have different access controls

belong to different organizations

take on different profiles and personas

6 of 29

Evolving the OSI model

Internet of Agents

VM | Bare metal

SaaS | Cloud Native Services

Agentic Software

VM | Bare metal

SaaS | Cloud Native Services

Agentic Software

Cloud Internet

Internet

physical

data link

network

transport

session

presentation

application

semantic

syntactic

1

2

3

⍺

7

6

5

4

β

TCP, UDP, QUIC

IP, IPsec, OSPF

Ethernet frames, ARP

802.3 100G, DOCSIS

BSD Sockets

SSL, TLS

HTTPS, gRPC, Mesh

Agent-to-Agent Protocol

Model Context Protocol

Semantic Protocols

Secure Low-latency Interactive Messaging

7 of 29

Why do we need a new internet?

Agents have human-like attributes and communication needs

but operate at machine speeds and scale

a

embodied

mobile

edge

DC

cloud

h

m

a

semantic*

syntactic*

discover and identify

find agents for specific tasks? are they reputable?
identify them, give access on my behalf?

assemble them to collaborate on the job to be done?
interpret probabilistic / natural language inputs and outcomes?
efficiently & securely transfer text-video-image-audio state?

doing what they are supposed to do?
getting into conflicts, loops

securely connect

observe and evaluate

1

2

3

And the reason we need this is because agents are truly a new type of entity. They combine the attributes of humans and machines in interesting ways.

They communicate in probabilistic ways.

They communicate using natural language rather than structured data.

But they operate at machine speeds, and they have a kind of ephemerality of a software entity.

These bring very unique aspects to agent communication.

And there are several things that we need to address when we talk about agents.

How do you identify and discover the right agents for a specific task?

Once you've discovered them, how do you connect them together?

Enable them to talk to each other across different frameworks, across different deployment modes, across different platforms.

How do you enable them to efficiently transfer data?

And then once you've done that, and once you've connected these agents together into a multi agent system, how do you observe them and evaluate what they're doing?

This is a very thorny problem because, as we know, they are probabilistic in nature, and their work needs to be evaluated to ensure that the agent or multi-agent software is actually doing what it's supposed to do.

8 of 29

Ensembles of Agents need a secure collaboration layer

Scientific & Math

Agentic Apps

(e.g., GNoME)

Social or Personal

Agentic Apps

(e.g., Apple or Meta Avatars)

B2B Agents

(e.g., SFDC Agents)

Infrastructure

Agentic Apps

(e.g., Cisco AI Assistant)

Services

Agentic Apps

(e.g., ServiceNow, CX)

Embodied / Physical

Agentic Apps

(e.g., Physical Intelligence)

Internet of Agents

Workflow example A

Workflow example B

A: IT App Deployment & Management

(biz logic description) : (service-ticket generation) : (service-graph generation): (scale-checker) : (security-checker) : (cost-manager)

B: Drug discovery, Materials Discovery:

(protein-modeling) : (cost-modeling) : (protein-modify) : (efficacy-vector-search) : (safety-check) : (reaction-check)

Ex. Vendors: Open AI, ServiceNow, Salesforce, Microsoft, Cisco, …

Ex. Vendors: Anthropic, Evolutionary Scale, Physical Intelligence, …

And this is not a theoretical problem. This is stuff that we are encountering today. Take two distinct areas.

If you think about the domain of IT application deployment and management, which is a very well-defined problem space.

We see that agents on very different domains need to come together to solve problems.

So for example, you might have an agent that is from a platform like Salesforce that is trained on customer data, which needs to talk to an agent from ServiceNow, which is adapted to ticketing workflows, which needs to talk to an agent from Cisco, which understands everything about your runtime environment.

You need all these agents that have different expertise and are in different domains to be able to collaborate to solve a problem that is related to the end to end deployment life cycle of an IT application.

If you look at a different domain at things like drug discovery and materials discovery, there you have agents that are doing protein modeling or cost modeling talking to agents that are embodied agents - agents running on robots that may be conducting experiments.

So you have agents from companies like EvolutionaryScale, talking to agents from embodied agents from entities like Physical Intelligence and they need to collaborate to solve this problem of discovering new drugs.

So again, we are starting to see the beginning of what we are calling the Internet of agents.

Agents that are trained on different domains, on different data sets, all collaborating to solve problems.

We are starting to see the contours of this new world taking shape, and we need a common set of protocols and standards that will enable this to take shape.

9 of 29

Agent Directory

Agent Identity

Agent Messaging

Agent Observability

The open standards and foundational technologies being built by AGNTCY

A secure, scalable, decentralized technology that holds agent and MCP server records.

An identity framework that assigns, verifies and manages credentials for AI agents and MCP servers.

A messaging layer enabling real-time, multi-model state exchange among agents and models.

A framework that monitors and assesses multi-agent software performance.

Now let's get a little bit more into the details of what we are building within AGNTCY.

1st AGNTCY is building an Agent Directory technology to address the discoverability problem. An agent needs to be able to describe itself. It needs to be able to talk about its providence and its capabilities in a standard form that other agents and other humans can understand. Once it's described itself, it can then be discovered by other agents. In summary, the discoverability problem is all about finding what agents are out there, discovering their capabilities, and finding the right one that's fit for purpose for the task that you're trying to solve.

Having discovered the agents that you're interested in, how do you verify their identity, manage credentials and specify access control policies? How do you make sure that the agents built on different frameworks and running on different platforms can communicate their identity and permissions in a meaningful way?

How do you orchestrate the communications between these different agents in a multi agent system? Your agents need to be able to extend beyond gRPC style interactions to include pub/sub, streaming, fire & forget, etc. That's the messaging piece.

Once the system is deployed and running, you have the big problem of evaluation. How do you ensure that the agent or multi agent system is doing what it's supposed to do? How do you ensure that it's not doing what it's not supposed to do? How do you gather the right metrics? How do you put the right checks in place to ensure that the agents are doing what they are supposed to do?

What we have built at AGNTCY is a set of foundational technologies that will help address all of these different parts.

10 of 29

This is the overall, holistic view of the AGNTCY components. Let's go through this one by one and understand what each of the components do.

You have Agent Identity that defines how agents prove who they are and how we govern what they can do.

We start the Agent Catalog with the OASF. That’s the open agentic schema framework. It's a common format in which the capabilities and attributes of an agent can be described. So you can talk about things like the agent provenance, where it was built, who built it, the identifier for the agent. The skills and capabilities of the agent, et cetera. So this is how you would describe an agent in a common interoperable way.

Now, once that agent is described, the description lands in the Agent Directory. This is where all of the different entries for agents and MCP servers are captured. The Agent Directory is a distributed decentralized service. It can be run in multiple organizations, so you could have an Agent Directory that's running in org A, another running in org X and they can share information about the agent metadata that they have. It's important to note here that you could have an enterprise private directory as well. So you could have a directory that is running within <org name> that is for developers within <org name> to share information about the agents they are building. But there could be public agents that are part of that directory that could be shared with other public directories.

We think of this very similar to the DNS for the physical internet. So, this is a place just like for the DNS, you could go discover where a machine is and how to get to it. Similarly, here you can discover what an agent can do and how you can find it. So that overall is the discoverability piece.

Now you get into the composition piece. And here you have several capabilities at both the semantic layer and the syntactic layer for agents to be able to talk to each other.

E.g., at the syntactic layer, we have the A2A protocol from Google. And you've all probably heard about model context protocol or MCP from anthropic. We see that as being a slightly orthogonal but complementary piece as well, so we support it.

We do support all the different protocols that are out there and we either translate between protocols or we support them. The goal for AGNTCY is to enable this vision to come true. So, in service of that, if there are other protocols that other players in the ecosystem release, we find ways either to converge with them, adopt their standard or translate between them.

Now below that we have the messaging layer, which is where the rubber meets the road in terms of taking all of these agents and multi agent systems and deploying them onto your internet infrastructure. We have built Secure Low-latency Interactive Messaging, which is a messaging service optimized for agentic communication. If you think about it, agentic communication has certain, unique attributes. For instance, it needs to be low latency to support human in the loop interactions, for example. It needs to support large state exchange because agents talk in a multimodal way using a lot of state to exchange context, and the messaging layer needs to support that. So Secure Low-latency Interactive Messaging really is a message layer that is optimized for agent-to-agent communication. But we also support other messaging services such as NATS and Kafka.

Agent observability covers how we measure the right attributes from these agents and from these multi agent systems. Ensuring the agents are performing as expected.

Security is another big piece, which is also being built out within AGNTCY.

11 of 29

MCP

A2A

SLIM

…

❤️

Protocols

12 of 29

Core

Identity

Observe-Eval

common

+ app-sdk

coffee-app-sdk

Working Groups

13 of 29

AGENT COMMUNICATION

Video intelligence monitoring

Legacy video monitoring systems lack real-time, actionable insights in complex environments, relying on isolated AI models or manual review. This results in missed events, delayed responses, and limited situational awareness, making them inadequate for today’s demand for scalable intelligence.

Problem

SoftServe partnered with AGNTCY to deploy a multi-agent video intelligence system powered by SLIM (Secure Low-latency Interactive Messaging). ��SLIM enables fast, secure communication between specialized agents handling tasks and ensures real-time responsiveness and coordination. This allows the system to scale efficiently while maintaining semantic clarity and operational trust.

Solution

Download the

whitepaper

14 of 29

AGENT COMMUNICATION

Autonomous network operations

Swisscom experienced a network outage caused by a misconfiguration that slipped through traditional lab testing, exposing the limits of manual change management and static environments.

Problem

Partnering with Outshift, they built a multi-agent system using Agentic Network Validator to simulate, verify, and prevent failures—transforming network operations from reactive to predictive.

Solution

AGENT OBSERVABILITY

Download the

whitepaper

15 of 29

Platform operations automation

Our Outshift platform engineering team was overwhelmed by cognitive load, fragmented tooling, and repetitive tasks across complex cloud-native environments. Traditional automation couldn’t scale across domains like CI/CD, Jira, Kubernetes, and GitHub—leaving engineers stuck in support queues and context-switching instead of innovating.

Problem

Outshift created CAIPE, a open-source multi-agent framework, that automates platform workflows through intelligent agent collaboration. Using semantic routing, agent identity, and protocols like SLIM (Secure, Low Latency, Interactive Messaging) and Agent Connect, it provides a unified communication fabric for scalable, extensible, and secure platform engineering.

Solution

AGENT COMMUNICATION

AGENT DISCOVERY

Read the blog

16 of 29

Distributed MAS deployment

Multi Agentic Systems are complex. Not only are we going from deterministic computing paradigm to non-deterministic, but we must also accomplish a similar refactoring effort of the technology stack as the on-premise to cloud transition. But instead of 7 - 10 years, we have 1 - 2 years. The Internet of Agents is upon us, and there needs to be a reference application that instantiates the vision.

Problem

Digital Realty and Cisco are leveraging coffeeAGNTCY to build and deploy a small POC network across multiple servers in different geographies. When you tightly couple an AI ready data center stack to agentic workloads, customers save money and achieve lower latency in their apps.

Solution

AGENT COMMUNICATION

AGENT OBSERVABILITY

AGENT IDENTITY

Read the blog

17 of 29

AI observability

As AI systems grow more complex—especially with multi-agent architectures—traditional observability tools fall short. They focus on infrastructure metrics like latency and error rates but fail to capture the semantic quality of AI outputs. This leaves businesses blind to critical issues like hallucinations, incoherence, or misalignment with user intent, making it difficult to trust and scale these systems in production.

Problem

AGNTCY and Splunk are redefining AI observability by embedding agentic semantic conventions into OpenTelemetry. Their Metrics Compute Engine (MCE) combines infrastructure metrics with LLM-based evaluations of output quality—like factual accuracy and coherence—giving teams a holistic view of system performance.

Solution

AGENT COMMUNICATION

AGENT DISCOVERY

Read the blog

18 of 29

Healthcare booking automation

Accessing healthcare is often a fragmented, frustrating experience. Patients must repeat their symptoms at every step, wait for insurance verification, and navigate disconnected systems—all while providers struggle with overloaded call centers and inefficient workflows.

Problem

Infermedica, Cisco, Webex, and Infinitus have teamed up to create a Healthcare Booking Multi-Agent System (MAS). This prototype uses specialized AI assistants to guide patients from symptom check to appointment scheduling—seamlessly and securely. Each agent handles a specific task, coordinated by Webex’s AI supervisor, creating a smooth, scalable, and collaborative healthcare experience.

Solution

AGENT IDENTITY

AGENT DISCOVERY

AGENT OBSERVABILITY

Watch the webinar

19 of 29

Take the next step

https://agntcy.org/

https://github.com/agntcy

https://github.com/agntcy/governance/blob/main/working-groups/WORKING-GROUPS.md

Join a working group

Learn more

Adopt & Contribute

20 of 29

Thank you!

21 of 29

Appendix

22 of 29

Industry examples of multi-agent systems

Healthcare

Monitor and coordinate responses to detected anomalies, ensuring timely and appropriate interventions.

Manufacturing

Automate responses to predicted production shortages, optimizing resource allocation and minimizing downtime.

Banking

Analyze and evaluate a consumer loan applications, streamlining the approval process and reducing manual effort.

Retail / E-commerce

Re-engage lost customers on social media platforms by tailoring advertising placements and promotional offers.

Transportation

Automate response to vehicle incidents or traffic accidents, speeding public safety responses and streamlining insurance claim processing.

23 of 29

Components

24 of 29

Agent Directory

A secure, scalable, decentralized service that holds agent and MCP server records

Publish and discover agent records across the network of decentralized directories
Provides a cryptographic trust model that ensures authenticity and provenance of each record
Leverages the Open Agentic Schema Framework (OASF) to describe agents
Available as open-source software, or try out the hosted SaaS (https://agent-directory.outshift.com/)

25 of 29

AGNTCY Agent Identity

Trusted identity for secure, accountable, autonomous systems

Assign, verify, and manage cryptographically verifiable identities for AI Agents (OASF, A2A), and MCP Servers

Tap into your trusted Identity Provider – Duo, Okta, Ory, or AGNTCY’s built-in decentralized identity provider

Create fine-grained (task-tool based) access control policies

Add human-in-the-loop approvals for sensitive actions

Establish trust across distributed agentic services

Enforce fine-grained access control

Build interoperable agentic systems

Agent identity isn’t just another checkbox — it’s the line between uncertainty and trust.

First, agents must prove who they are — with cryptographic identities that can’t be faked. That stops impersonation before it begins.

Second, we need to govern what they can do — not with broad, static rules, but with fine-grained, task- and tool-based access, granted just-in-time. That keeps autonomy safe.And when the stakes are high, we can always bring a human into the loop for oversight.

And third, agents must work together — interoperable across systems and organizations, integrating with multiple IDPs like Duo, Okta, or Ory, so identity travels with the agent wherever it goes. That’s how you scale with confidence.

So the formula is simple: Prove it. Govern it. Scale it. That’s the power of AGNTCY Agent Identity.

26 of 29

TBAC – Granular Access Controls for Agentic Services

Evolving RBAC, ABAC to support Access Controls

TBAC enables fine-grained, contextual, and auditable access controls, ensuring trust, compliance, and security across all AI-driven operations.

Tools

Agents can access which tools: APIs

e.g., access to book_flight API

Tasks

Agents can perform what actions

→ e.g., ability to book a flight

Transactions

Agents can execute which specific requests

→ e.g., book flight SEA → NYC, 9/11-9/15, <$500

Traditional access control models — RBAC, ABAC, ReBAC — were built around users. They answer questions like:

Who is this person? (RBAC)

What attributes or context apply? (ABAC)

What relationships define their scope? (ReBAC)

But autonomous agents don’t fit that framing. They don’t have job titles or organizational relationships. They are defined entirely by the work they are performing.

That’s why we need Task/Tool/Transaction-Based Access Control (TBAC) — a model designed to authorize work, not people.

It’s not a replacement — it’s a capability layer. TBAC lets us scope access to the specific task the agent is performing in the moment. That creates tighter controls, cleaner audit trails, and significantly reduces risk from over-permissioned agents.

TBAC progressively scopes and narrows access — from broad intent (task) down to precise, auditable actions (transactions).

Task (T):What is the agent actually trying to accomplish?

Tool (T): Which systems, APIs, or platforms does the agent need to touch to complete that task?

Transaction (T): What exact actions are permitted within those tools for this task?

Together, these three dimensions define a temporary, just-in-time permission envelope:

Activated only while the task is active

Scoped to the minimum necessary tools

Limited to specific, auditable transactions

Revoked automatically once the task is complete

This is the opposite of delegation or impersonation. Instead of pretending the agent is a user, TBAC authorizes the work itself.

27 of 29

SLIM: Secure Low-latency Interactive Messaging

A messaging service enabling real-time, multi-modal state exchange between agents, models and tools

Extends gRPC to support pub/sub interactions in addition to request/reply, streaming, fire & forget, …
Employs authentication, authorization and end-to-end encryption to protect data privacy and integrity (TLS, MLS)
Enables agent group-based collaboration, human-in-the-loop interactions and large state exchange through low latency communication patterns
Supports MCP and A2A protocols
Provides decentralized, secure and scalable routing for distributed systems (agents, MCP servers, models)

28 of 29

Agent Observability & Evaluation

A framework that monitors and assesses multi-agent software performance

Capture traces, metrics and events from multi-agent software and export data to an OTel collector endpoint
Support agents from various frameworks by mapping and translating third-party schemas
Provide end-to-end visibility into multi-agent software by aggregating telemetry data across agents and components
Gain insight into derived evaluation and observability metrics
Engage the Metrics Compute Engine (MCE) providing comprehensive visibility into AI quality: accuracy, appropriateness, safety, and fairness—all computed automatically from standardized telemetry and delivered alongside your operational metrics.

Advancements in OpenTelemetry (OTel), the open source standard for observability, have been achieved through collaboration with Microsoft and Splunk.

Learn more

Observability SDK
A translator template

(3) A Telemetry hub for aggregation and recomposition of MAS sessions

(4) Metrics Compute Engine (MCE)

29 of 29

coffeeAGNTCY Reference App + AGNTCY SDK

See what AGNTCY can do and jumpstart your multi-agent software development

The OSS reference app ("coffeeAGNTCY" in Github) represents a fictional global coffee company but is easily modifiable for any multi-agent use case
Highlights best practices for using AGNTCY repos, architecture, components
Re-usable SDK capturing common AGNTCY patterns
Demonstrates agent-to-agent communication using SLIM, the Messaging Layer that is isolated from Semantics, multiprotocol (A2A, MCP), secure, reliable, low-latency, async, point-to-point ("Corto" demo) OR many-to-many ("Lungo" demo using Pub/Sub)
Coming Soon: End-to-end demonstration of all AGNTCY components including Directory, Identity, and Observability

Semantic Layer

Messaging Layer

Agent Directory

Syntactic Layer

Agentic Observability

Agentic Security

Agent Identity

coffeeAGNTCY Reference App

AGNTCY SDK