From concept to code: AGNTCY’S Internet of Agents is now on GitHub

The AGNTCY is an open source collective building the infrastructure for the Internet of Agents: an open, interoperable internet for agent-to-agent collaboration. 

On March 6, in partnership with LangChain and Galileo, we announced the AGNTCY, and today we’re dropping the initial code ⬇️💻 that you can get your hands on for discovering, composing and deploying multi-agent software (more on that later). 

Plus, we’ll outline the high level, various components of the AGNTCY Collective including how they fit into the overall workflow for the Internet of Agents (IoA), and who will find value in them. Every component of the IoA is built to deliver value as a standalone piece of software but will work better together with other components through the use of common specifications and APIs. Let’s dive in! 

Tackling the agentic application lifecycle 

As we began ideating the need for AGNTCY, we divided the agentic software lifecycle into four stages: Discover, Compose, Deploy, and Evaluate. There are components of the Internet of Agents which are relevant to each stage. All these components will also be used by developers and operators as part of building, running, and managing multi-agent software, but our primary focus in this blog post will be for those who build tools within this life cycle.  

Discover stage 

This is the stage where the collective has been spending the most development time to date, with the code for its two main components now available in GitHub. 

Open Agent Schema Framework (OASF) 

️⬇️💻 Code now available: https://github.com/agntcy/oasf 

OASF provides a standard form in which the identity and capabilities of an agent can be described in a vendor and platform agnostic manner. It provides a common, interoperable agentic definition which can be used for describing and discovering agents and multi-agent software.  

Who will use OASF and why?

OASF can be used by partners who build products and frameworks for creating agents and multi- agent applications (e.g. LangChain, LlamaIndex) to describe the agents they build using a common format. It can be used by agent marketplace vendors to describe their agents in a way that makes them easier to discover. It can be used by developers to advertise the agents they create in a standard manner.  

Agent Directory 

️⬇️💻 Code now available:  

• https://github.com/agntcy/dir
• https://github.com/agntcy/dir-spec 

Agent Directory provides a decentralized service which will act as the source of truth for agent identities and capabilities. It holds entries of agents and multi-agent software described in the OASF format. It can be deployed as an on-prem service or delivered as a SaaS in the cloud.  

Who will use Agent Directory and why?

Agent Directory can be integrated into offerings by partners who build agent-builder products (e.g. LangChain, LlamaIndex) enabling agents built using these frameworks to be easily discovered. It can be used by agent marketplace vendors to create a decentralized agentic promotion and discovery mechanism, similar to DNS for the physical internet. It will be used by developers to discover relevant agents to create their multi-agent software.

Compose stage

Let’s start off with our new protocol for connecting agents across different frameworks, as this is also available now. Then, we’ll get into the toolkit we’ll be building to help accelerate the composition of multi-agent workflows. 

Agent Connect Protocol (ACP) 

⬇️💻 Code now available:  

• https://github.com/agntcy/acp-spec
• https://github.com/agntcy/acp-sdk 

Agent Connect Protocol allows agents from different frameworks and platforms to communicate with each other in a standard manner. This includes operations like authentication and authorization, configuration, output retrieval, context sharing, error handling, etc.  

Who will use Agent Connect Protocol (ACP) and why? 

ACP will be used by partners who build agent-builder products (e.g. LangChain, LlamaIndex) by integrating it into their agent builder workflows so that the agents built on their framework can talk to agents from other frameworks in a consistent manner, as part of multi-agent software. It will be used by developers to enable agents to collaborate with each other in a framework-agnostic manner.  

A toolkit for Multi-Agent Software (MAS) 

The concept of a Multi-Agent Software toolkit is that it provides a set of predefined agents which solve common problems involved in creating an application composed of multiple agents from different frameworks. This includes agents like the IO Mapper Agent, the API Bridge Agent (both available today), and others like a Semantic Router Agent and a Human-in-the-Loop Agent.  

IO Mapper Agent 

⬇️💻 Code now available: https://github.com/agntcy/iomapper-agnt 

In multi-agent systems, ensuring seamless communication between two agents requires that the output of the first agent is compatible with the input of the second agent. 

The IO Mapper Agent ensures that the output from one agent is transformed to be compatible with the input of another. This transformation can encompass various processes, such as:  

• JSON structure transcoding: Re-mapping a JSON dictionary into another format. 
• Text summarization: Condensing text or removing extraneous information. 
• Text translation: Converting text from one language to another. 
• Text manipulation: Reformulating parts of one text into another form. 
• A combination of the above. 

API Bridge Agent 

⬇️💻 Code now available: https://github.com/agntcy/api-bridge-agnt 

In agentic applications, seamless API connectivity is essential, but integrating APIs should be as simple as interacting with a remote agent. Traditional methods often require complex configurations and custom integrations, making API access cumbersome and less flexible. 

The API Bridge Agent simplifies API access by enabling interaction through the Agent Connect Protocol (ACP), just like other agents in an agentic workflow. It acts as an API gateway plugin that can be easily configured using any OpenAPI specification. 

The API Bridge Agent transforms natural language requests into REST API calls, converting API responses back into natural language, and selecting the most appropriate API when multiple options are available. 

Semantic Router Agent 

In multi-agent systems, it's often necessary to decide what to do next based on the results of previous steps. Some decisions are simple and can be handled with basic if statements, while others are complex enough to need a dedicated agent. However, many decisions fall in between - they rely on understanding the meaning of the input. The Semantic Router Agent helps make these decisions by comparing the input to a set of predefined options and selecting the most relevant next step. Instead of using fixed rules, it understands the meaning of the input and routes it accordingly.  

Human-in-the-Loop Agent 

Agentic applications often require human input, but integrating human interactions into automated workflows can be challenging. The system must be able to pause and wait for input while also engaging humans effectively through different communication channels. Without a standardized approach, this can lead to inconsistent and inefficient implementations. The Human in the Loop (HIL) Agent streamlines human-agent interactions by providing built-in methods to collect human input seamlessly within automated workflows. 

Who will use a toolkit for multi-agent software and why? 

This type of toolkit will be used by partners who build multi-agent composer tools. This could be the likes of LangChain, but also Outshift by Cisco, or other OSS projects. These are common tools which should be broadly used by the developer community.  

Deploy stage 

We’re starting off here again with the components that have code available today - the Gateway and Workflow Server - and then we’ll dive into the next stages of our high-level view of what should come next. 

Agent Gateway 

️⬇️💻 Code now available: 

• https://github.com/agntcy/agp
• https://github.com/agntcy/agp-spec 

The Agent Gateway provides a low latency communication mechanism designed for the kind of multi-modal state exchange required for agentic communication, including for real time and interactive use cases. It supports both peer-to-peer and pub/sub (one to many) modes of communication.  

Who will use Agent Gateway and why? 

Agent Gateway will be used by infrastructure operators and SREs within enterprises and agentic platform vendors to provide a communication layer for agents and by developers building multi-agentic systems, since this will be required once multi-agent software is created at scale.  

Agent Workflow Server 

⬇️💻 Code now available: 

• https://github.com/agntcy/workflow-srv
• https://github.com/agntcy/workflow-srv-mgr 

The Agent Workflow Server provides a standard reference runtime implementation for multi-agent software, as described in an Agent Manifest.  

Who will use Agent Workflow Server and why? 

Agent Workflow Server will be used by operators of agentic platform infrastructure within enterprises to run multi-agent software.  

Agent Manifest 

The Agent Manifest provides a standard way for agents and multi agentic systems to be described, in a way that they can be run by any platform which supports the IoA standard. This includes how to interact with an agent, how to configure it, how to transform the output of one agent to input of another agent and how to authorize and authenticate agents.  

Who will use Agent Manifest and why? 

The Agent Manifest will be used by those who build agent-builder products (e.g. LangChain, LlamaIndex) as well as by agentic platform vendors and hyperscalers. It will be used by developers to describe agents and multi-agent software so they can be run on any platform which supports the AGNTCY standard.  

Evaluate stage 

Once a multi-agent app is running, you’ll need to evaluate and evolve the workflow: measuring outcomes, resolving bottlenecks, and fine-tuning the agentic call graph based on performance among other things. Note: While we don’t have any code available today to get you started here, the collective is working on these components. 

Agent Observability Framework 

The Agent Observability Framework provides a standardized method for capturing, analyzing, and integrating real-time performance data in multi-agent software. This ensures developers and operators can easily monitor agent interactions, decisions and tool usage, detect bottlenecks, and optimize execution workflows. 

Who will use Agent Observability Framework and why? 

Agent Observability Framework can be used by multi-agent software developers, so that they can integrate logging, tracing, and performance monitoring directly into their development workflows. This can also be used observability tool developers, so that they can provide out of the box telemetry to their customers.  

Agent Evaluation Framework 

The Agent Evaluation Framework offers a unified way to assess agent effectiveness, decision reliability, and task execution quality across multi-agent environments. This standardization simplifies performance benchmarking and result validation. 

Who will use Agent Evaluation Framework and why? 

The Agent Evaluation Framework can be used by multi-agent software developers with the goal of reducing the overhead of building custom evaluation pipelines and gaining access to predefined benchmarks. This can also be used by evaluation tool developers, so that they can provide custom datasets and benchmark metrics for the entire multi-agent software. For example, they can provide benchmark metrics like success rate, accuracy, etc.  

Agent Security Framework 

The Agent Security Framework provides a standardized approach to identifying, tracking, and mitigating security risks in multi-agent environments. This includes monitoring for unauthorized actions, excessive data exposure, policy violations, and creating guardrails for agents and multi-agent systems.  

Who will use Agent Security Framework and why? 

The Agent Security Framework will be used by multi-agent software developers and platform operators to detect vulnerabilities and anomalous behavior without having to build an entire bespoke security monitoring system. Additionally, security tool developers can tap into real-time risk insights and integrate policy enforcement solutions that safeguard agent workflows across diverse environments. 

Wrapping Up 

With today’s drop, we’re excited to truly begin the AGNTCY journey towards helping developers and operators build, run, and manage multi-agent software. As part of the agentic software life cycle, you can get started with the repos outlined above at https://github.com/agntcy. 

We look forward to having you try these out as you build your agentic tooling and workflows. Forks, feedback (and stars) over on GitHub are welcome!

Join Papi Menon, Chief Product Officer and Vice President of Product Management at Outshift By Cisco, to understand why now is the time to build the Internet of Agents. Register now for Internet of Agents 101: Building the Open Infrastructure for AI’s Collaborative Future.