# Passport Discovery

ADL solves a fundamental problem in multi-agent systems: **how does one agent learn what another agent can do, and whether it should be trusted?**

Today, agent integrations are hardcoded. If Agent A wants to use Agent B, a developer has to read B's documentation, write glue code, and manually configure credentials. This doesn't scale when you have hundreds of agents across organizations.

ADL changes this. Every agent carries a **passport** — a machine-readable document that declares its identity, capabilities, permissions, data sensitivity, and security requirements. Another agent can read this passport, understand what's available, verify trust, and start communicating — automatically.

The demo below walks through this flow step by step.

Step through the flow below to see how one agent discovers another, reads its passport, evaluates trust, and starts communicating — without any prior configuration or hardcoded integrations.

Discovery

Validate

Trust

Communicate

🔍

Discovery Agent

🤖

Service Agent

Run DemoStepReset8 steps

Click **Run Demo** to start the discovery flow, or **Step** to advance one step at a time.

This simulates the real [A2A discovery demo](https://github.com/agent-definition-language/implementations/tree/main/packages/adl-agent/examples/a2a-discovery) that runs locally with `bun run examples/a2a-discovery/run-demo.ts`

Find agents on a domainRead the agent’s passportVerify the passport is legitimateTranslate to A2A formatDecide whether to trust this agentInvoke: Explain the passport modelInvoke: Validate a documentInvoke: Compare ADL with A2A

## What you just saw[​](#what-you-just-saw "Direct link to What you just saw")

This demo illustrates four core ideas from the ADL specification:

### 1. Discovery without prior knowledge[​](#1-discovery-without-prior-knowledge "Direct link to 1. Discovery without prior knowledge")

The discovery agent didn't know anything about the service agent in advance. It queried a standard URL (`/.well-known/adl-agents`) and received a directory of available agents. Any domain can publish this directory — it's how agents find each other across organizations.

### 2. Passports are self-describing[​](#2-passports-are-self-describing "Direct link to 2. Passports are self-describing")

The ADL passport contained everything the discovery agent needed: the agent's name, what tools it offers, what data sensitivity level it operates at, and what authentication it requires. No separate API docs, no out-of-band configuration.

### 3. Trust is evaluated, not assumed[​](#3-trust-is-evaluated-not-assumed "Direct link to 3. Trust is evaluated, not assumed")

Before sending a single request, the discovery agent checked the passport's trust signals. Is the data public or restricted? Are the tools read-only? Is authentication required? These aren't just metadata — they're machine-enforceable constraints that let agents make autonomous trust decisions.

### 4. Format interoperability[​](#4-format-interoperability "Direct link to 4. Format interoperability")

The passport was converted to an A2A Agent Card with a single function call. ADL tools became A2A skills. Authentication mapped directly. An agent described in ADL can participate in the A2A ecosystem, the MCP ecosystem, or both — from one source document.

## Try it locally[​](#try-it-locally "Direct link to Try it locally")

The demo above is a simulation. To run the real thing with actual HTTP requests between two processes:

```
cd packages/adl-agent

bun run examples/a2a-discovery/run-demo.ts
```

No API keys needed — it runs entirely locally using the agent's built-in tools.