Phase 16: Multi-Agent & Swarms

İletişim Protokolleri

Type: Build

Languages: TypeScript

Prerequisites: Phase 14 (Agent Engineering), Lesson 16.01 (Why Multi-Agent)

Time: ~120 minutes

Öğrenme Hedefleri

• MCP araç keşif ve çağrı uygulaması, böylece ajanlar dış sunucuların ortaya koyduğu araçları kullanabilirler.
• Bir A2A ajan kartı ve bir ajanın HTTP üzerinden çalışmayı başka birine devretmesine izin veren görev son noktasını oluşturun
• MCP (alışa erişim), A2A (astadan-astaneye), ACP (işletme denetimi) ve ANP (merkezi olmayan güven) ile karşılaştırın ve hangi protokolün hangi sorunu çözdüğünü açıklayın.
• Bir sistemde birden fazla protokolü kablolamak , bu sistemde ajanlar MCP üzerinden araçları keşfeder ve A2A üzerinden görevleri delegeder

Sorun

Sisteminizi birden fazla ajanlara ayırıyorsunuz bir araştırmacı, bir kodlayıcı, bir eleştirmen.

İlk deneme açıktır: ipler geçin. Araştırmacı bir metin parçasını gönderir, kodlayıcı onu nasıl yapabilirse öyle analiz eder. Programcı bir araştırma özetini yanlış yorumlayana kadar çalışır, ya da iki ajan birbirini bekleyen bir çıkışsızlık veya farklı ekipler tarafından oluşturulan ajanların işbirliği yapması gerekir.

Bu iletişim protokolü sorunu. ajanların bilgi alışverişini nasıl yapacağı hakkında ortak bir sözleşme olmadan, çoklu ajan sistemleri kırılgan, dinlenemez ve kişisel olarak yazdığınız bir avuç ajanın ötesinde ölçeklendirme imkansızdır.

Yapay zeka ekosisteminin yanıtları dört protokol ile, her biri farklı bir sorunun çözümüyle olmuştur:

• MCPAraçlara erişim için
• A2Aajan-ajen işbirliği için
• ACPKurumsal denetim için
• ANPMerkezsiz kimlik ve güven için

Bu ders derinlere gidiyor. Her bir özellikten gerçek tel biçimlerini okuyacak, çalışacak uygulamaları inşa edecek ve dörtünü de tek bir sisteme bağlayacaksınız.

Anlaşım

Protokol Manzarası

Bu dört protokolü farklı bir soruya cevap veren katman olarak düşünün:

flowchart TD
  ANP["ANP — How do agents trust strangers?<br/>Decentralized identity (DID), E2EE, meta-protocol"]
  A2A["A2A — How do agents collaborate on goals?<br/>Agent Cards, task lifecycle, streaming, negotiation"]
  ACP["ACP — How do agents talk in auditable systems?<br/>Runs, trajectory metadata, session continuity"]
  MCP["MCP — How does an agent use a tool?<br/>Tool discovery, execution, context sharing"]

  style ANP fill:#f3e8ff,stroke:#7c3aed
  style A2A fill:#dbeafe,stroke:#2563eb
  style ACP fill:#fef3c7,stroke:#d97706
  style MCP fill:#d1fae5,stroke:#059669

Onlar rekabetçi değiller. Farklı seviyelerde farklı sorunları çözüyorlar.

MCP (Yedekleme)

MCP'nin derinlemesine kapsamlı olduğu 13. aşamada.client-serverBir sunucu tarafından açıklanan araçları ajanın (klientin) keşfetmesi ve çağrısı yapan protokol.

sequenceDiagram
    participant Agent as Agent (client)
    participant MCP1 as MCP Server<br/>(database, API, files)

    Agent->>MCP1: list tools
    MCP1-->>Agent: tool definitions
    Agent->>MCP1: call tool X
    MCP1-->>Agent: result

MCP agent-to-toolBu ajanların birbirleriyle konuşmasına yardımcı olmaz.

A2A (Agent2Agent Protokolü)

Created by:Google (şimdi Linux Vakfı altında lf.a2a.v1)

Spec version:1.0.1

Problem:Özerk ajanlar nasıl işbirliği yaparlar, müzakere ederler ve görevleri birbirlerine nasıl delegelerler?

A2A , protokolün bir parçasıdır .peer-to-peer agent collaborationMCP bir ajanı araçlara bağladığında, A2A bir ajanı diğer ajanlara bağlar.Agent CardBilinen bir URL'de, diğer ajanlar görevleri keşfeder, müzakere eder ve ona devreder.

#### A2A Nasıl Çalışır

sequenceDiagram
    participant Client as Client Agent
    participant Remote as Remote Agent

    Client->>Remote: GET /.well-known/agent-card.json
    Remote-->>Client: Agent Card (skills, modes, security)

    Client->>Remote: POST /message:send (returnImmediately)
    Remote-->>Client: Task (TASK_STATE_SUBMITTED or TASK_STATE_WORKING)

    alt Polling
        Client->>Remote: GET /tasks/{id}
        Remote-->>Client: Task status + artifacts
    else Streaming
        Client->>Remote: POST /message:stream
        Remote-->>Client: SSE: statusUpdate
        Remote-->>Client: SSE: artifactUpdate
        Remote-->>Client: SSE: statusUpdate TASK_STATE_COMPLETED, stream closes
    end

#### Gerçek Ajan Kartı

A2A ajan kartı doğada böyle görünüyor.GET /.well-known/agent-card.json- ...

jsonCopy{
  "name": "Research Agent",
  "description": "Searches documentation and summarizes findings",
  "version": "1.0.0",
  "supportedInterfaces": [
    {
      "url": "https:TOK0
      "protocolBinding": "JSONRPC",
      "protocolVersion": "1.0"
    },
    {
      "url": "https://research-agent.example.com/a2a/rest",
      "protocolBinding": "HTTP+JSON",
      "protocolVersion": "1.0"
    }
  ],
  "provider": {
    "organization": "Your Company",
    "url": "https:TOK2
  },
  "capabilities": {
    "streaming": true,
    "pushNotifications": false
  },
  "defaultInputModes": ["text/plain", "application/json"],
  "defaultOutputModes": ["text/plain", "application/json"],
  "skills": [
    {
      "id": "web-research",
      "name": "Web Research",
      "description": "Searches the web and synthesizes findings",
      "tags": ["research", "search", "summarization"],
      "examples": ["Research the latest changes in React 19"]
    },
    {
      "id": "doc-analysis",
      "name": "Documentation Analysis",
      "description": "Reads and analyzes technical documentation",
      "tags": ["docs", "analysis"],
      "inputModes": ["text/plain", "application/pdf"],
      "outputModes": ["application/json"]
    }
  ],
  "securitySchemes": {
    "bearer": {
      "httpAuthSecurityScheme": {
        "scheme": "Bearer",
        "bearerFormat": "JWT"
      }
    }
  },
  "securityRequirements": [{ "schemes": { "bearer": { "list": [] } } }]
}

Dikkat edilmesi gereken önemli şeyler:

• SkillsBu, bir istemci ajansının isteklerini ele alabilmeyeceğini belirler.
• supportedInterfacesTek bir ajan aynı anda JSON-RPC, REST ve gRPC konuşabilir.
• SecurityKartın içine yerleştirilmiştir: securitySchemesHer bir programın adı ve securityRequirementsMüşteri tek bir talebi yapmadan önce neye ihtiyacı olduğunu bilir.

#### Görev Yaşam Çeviri

Görevler A2A'nın temel çalışma birimidir.TASK_STATE_her devletin tel üzerinde taşıdığı ön işaret):

stateDiagram-v2
    [*] --> SUBMITTED
    SUBMITTED --> WORKING
    WORKING --> INPUT_REQUIRED: needs more info
    INPUT_REQUIRED --> WORKING: client sends data
    WORKING --> COMPLETED: success
    WORKING --> FAILED: error
    WORKING --> CANCELED: client cancels
    SUBMITTED --> REJECTED: agent declines

    COMPLETED --> [*]
    FAILED --> [*]
    CANCELED --> [*]
    REJECTED --> [*]

    note right of COMPLETED
        Terminal states are immutable.
        Follow-ups create new tasks
        within the same contextId.
    end note

Tüm 8 devlet (spektrin aynı zamanda tanımladığı UNSPECIFIEDBurada atılan bir bekçi olarak:

Bir görev son durumuna ulaştığında değişmez. Daha fazla mesaj yok. Takipler aynı görev içinde yeni bir görev oluşturur.contextId- Evet .

#### Kablo Formatı

A2A JSON-RPC 2.0 kullanıyor. Gerçek mesaj değişimi nasıl görünüyor:

Client sends a message:

jsonCopy{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "SendMessage",
  "params": {
    "message": {
      "messageId": "msg-001",
      "role": "ROLE_USER",
      "parts": [{ "text": "Research React 19 compiler features" }]
    },
    "configuration": {
      "acceptedOutputModes": ["text/plain", "application/json"],
      "historyLength": 10
    }
  }
}

Agent responds with a task:

jsonCopy{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "task": {
      "id": "task-abc-123",
      "contextId": "ctx-xyz-789",
      "status": {
        "state": "TASK_STATE_COMPLETED",
        "timestamp": "2026-03-27T10:30:00Z"
      },
      "artifacts": [
        {
          "artifactId": "art-001",
          "name": "research-results",
          "parts": [{
            "data": {
              "findings": [
                "React 19 compiler auto-memoizes components",
                "No more manual useMemo/useCallback needed",
                "Compiler runs at build time, not runtime"
              ]
            },
            "mediaType": "application/json"
          }]
        }
      ]
    }
  }
}

Streaming via SSE:

textCopyPOST /message:stream HTTP/1.1
Content-Type: application/a2a+json
A2A-Version: 1.0

data: {"task":{"id":"task-123","contextId":"ctx-123","status":{"state":"TASK_STATE_WORKING"}}}

data: {"statusUpdate":{"taskId":"task-123","contextId":"ctx-123","status":{"state":"TASK_STATE_WORKING","message":{"messageId":"msg-002","role":"ROLE_AGENT","parts":[{"text":"Searching documentation..."}]}}}}

data: {"artifactUpdate":{"taskId":"task-123","contextId":"ctx-123","artifact":{"artifactId":"art-1","parts":[{"text":"partial findings..."}]},"append":true,"lastChunk":false}}

data: {"statusUpdate":{"taskId":"task-123","contextId":"ctx-123","status":{"state":"TASK_STATE_COMPLETED"}}}

AKT (Agent İletişim Protokolü)

Created by:IBM / BeeAI

Spec version:0.2.0 (OpenAPI 3.1.1)

Status:Linux Vakfı altında A2A'ya birleşme

Problem:Ajanlar tam denetim, seans devamlılığı ve yörenin takip edilmesi ile nasıl iletişim kurarlar?

ACP'dir.enterprise protocolBirçok özetin iddia ettiği aksine, ACP'nin yaptığı notJSON-LD kullanın. Bu açık API'den açık bir REST/JSON API'dir.TrajectoryMetadata: her ajan cevabı, onu üreten akıl yürütme adımlarının ve araç çağrılarının ayrıntılı bir günlük taşıyabilir.

sequenceDiagram
    participant Client
    participant ACP as ACP Agent
    participant Audit as Audit Log

    Client->>ACP: POST /runs (mode: sync)
    ACP->>ACP: Process request...
    ACP->>Audit: Log trajectory:<br/>reasoning + tool calls
    ACP-->>Client: Response + TrajectoryMetadata
    Note over Audit: Every step recorded:<br/>tool_name, tool_input,<br/>tool_output, reasoning

#### AKC'de bulunan Ajan Discovery

ACP dört keşif yöntemini tanımlar:

graph LR
    A[Agent Discovery] --> B["Runtime<br/>GET /agents"]
    A --> C["Open<br/>.well-known/agent.yml"]
    A --> D["Registry<br/>Centralized catalog"]
    A --> E["Embedded<br/>Container labels"]

    style B fill:#dbeafe,stroke:#2563eb
    style C fill:#d1fae5,stroke:#059669
    style D fill:#fef3c7,stroke:#d97706
    style E fill:#f3e8ff,stroke:#7c3aed

• Evet .AgentManifestA2A'nın ajan kartından daha basit:

jsonCopy{
  "name": "summarizer",
  "description": "Summarizes documents with source citations",
  "input_content_types": ["text/plain", "application/pdf"],
  "output_content_types": ["text/plain", "application/json"],
  "metadata": {
    "tags": ["summarization", "RAG"],
    "framework": "BeeAI",
    "capabilities": [
      {
        "name": "Document Summarization",
        "description": "Condenses long documents into key points"
      }
    ],
    "recommended_models": ["llama3.3:70b-instruct-fp16"],
    "license": "Apache-2.0",
    "programming_language": "Python"
  }
}

#### Yaşam Dönemi

ACP, "Taşlar" yerine "Runs" kullanır.

stateDiagram-v2
    [*] --> created
    created --> in_progress
    in_progress --> completed: success
    in_progress --> failed: error
    in_progress --> awaiting: needs input
    awaiting --> in_progress: client resumes
    in_progress --> cancelling: cancel request
    cancelling --> cancelled

    completed --> [*]
    failed --> [*]
    cancelled --> [*]

#### YoluMetadata (Audit Yolları)

Bu ACP'nin temel farkı. Her mesaj parçası, ajanın tam olarak ne yaptığını gösteren metadataları içerebilir:

jsonCopy{
  "role": "agent/researcher",
  "parts": [
    {
      "content_type": "text/plain",
      "content": "The weather in San Francisco is 72F and sunny.",
      "metadata": {
        "kind": "trajectory",
        "message": "I need to check the weather for this location",
        "tool_name": "weather_api",
        "tool_input": { "location": "San Francisco, CA" },
        "tool_output": { "temperature": 72, "condition": "sunny" }
      }
    }
  ]
}

Düzenlenmiş endüstriler için bu altın. Her cevap kanıtlanabilir bir mantık zinciri ile gelir: hangi araçlar çağrıldı, hangi girişler kullanıldı, hangi çıkışlar alındı.

ACP ayrıca CitationMetadataKaynak atıfı için:

jsonCopy{
  "kind": "citation",
  "start_index": 0,
  "end_index": 47,
  "url": "https:TOK0
  "title": "NWS San Francisco Forecast"
}

ANP (Agent Ağ Protokolü)

Created by:Açık kaynaklı topluluk (GaoWei Chang tarafından kurulmuştur)

Repo: github.com/agent-network-protocol/AgentNetworkProtocol

Problem:Farklı kuruluşların ajanları merkezi bir yetki olmadan nasıl birbirlerine güvenirler?

ANP'nin adı decentralized identity protocolW3C Merkezi Tanımlayıcıları (DID) ve uçtan sona şifreleme kullanarak güven oluşturur. A2A'nın aksine, bilinen uç noktaları üzerinden ajanları keşfetmek için, ANP ajanların kimliklerini kriptografik olarak kanıtlamalarını sağlar.

ANP üç katmanlı:

graph TB
    subgraph Layer3["Layer 3: Application Protocol"]
        AD[Agent Description Documents]
        DISC[Discovery endpoints]
    end
    subgraph Layer2["Layer 2: Meta-Protocol"]
        NEG[AI-powered protocol negotiation]
        CODE[Dynamic code generation]
    end
    subgraph Layer1["Layer 1: Identity & Secure Communication"]
        DID["did:wba (W3C DID)"]
        HPKE[HPKE E2EE - RFC 9180]
        SIG[Signature verification]
    end

    Layer3 --> Layer2
    Layer2 --> Layer1

    style Layer1 fill:#d1fae5,stroke:#059669
    style Layer2 fill:#dbeafe,stroke:#2563eb
    style Layer3 fill:#f3e8ff,stroke:#7c3aed

#### DID belgeleri (gerçek yapı)

ANP , adı verilen özel bir DID yöntemi kullanır .did:wba(Web Temel Ajan)did:wba:example.com:user:alicekarar verir https://example.com/user/alice/did.json- ...

jsonCopy{
  "@context": [
    "https:TOK0
    "https://w3id.org/security/suites/jws-2020/v1",
    "https:TOK2
  ],
  "id": "did:wba:example.com:user:alice",
  "verificationMethod": [
    {
      "id": "did:wba:example.com:user:alice#key-1",
      "type": "EcdsaSecp256k1VerificationKey2019",
      "controller": "did:wba:example.com:user:alice",
      "publicKeyJwk": {
        "crv": "secp256k1",
        "x": "NtngWpJUr-rlNNbs0u-Aa8e16OwSJu6UiFf0Rdo1oJ4",
        "y": "qN1jKupJlFsPFc1UkWinqljv4YE0mq_Ickwnjgasvmo",
        "kty": "EC"
      }
    },
    {
      "id": "did:wba:example.com:user:aliceTOK4
      "type": "X25519KeyAgreementKey2019",
      "controller": "did:wba:example.com:user:alice",
      "publicKeyMultibase": "z9hFgmPVfmBZwRvFEyniQDBkz9LmV7gDEqytWyGZLmDXE"
    }
  ],
  "authentication": [
    "did:wba:example.com:user:alice#key-1"
  ],
  "keyAgreement": [
    "did:wba:example.com:user:aliceTOK6
  ],
  "humanAuthorization": [
    "did:wba:example.com:user:alice#key-1"
  ],
  "service": [
    {
      "id": "did:wba:example.com:user:aliceTOK8
      "type": "AgentDescription",
      "serviceEndpoint": "https://example.com/agents/alice/ad.json"
    }
  ]
}

Dikkat edilmesi gereken önemli şeyler:

• Key separationİmza anahtarları (secp256k1) şifrelenme anahtarlarından (X25519) ayrıdır.
• humanAuthorizationBu anahtarlar kullanmadan önce açık bir insan onayına (biometrik, şifre, HSM) ihtiyaç duyar.
• keyAgreementHPKE uçtan uç şifreleme için anahtarlar kullanılır (RFC 9180).
• - Evet .serviceBölümde ajan tanımlama belgesine bağlantılar bulunmaktadır.

#### ANP'de Güven Nasıl Çalışır

ANP yapıyor.notGüvenin web-of-trust veya onaylama grafikini kullanın. Güven iki taraflı ve etkileşime göre doğrulanır:

sequenceDiagram
    participant A as Agent A
    participant Domain as Agent A's Domain
    participant B as Agent B

    A->>B: HTTP request + DID + signature
    B->>Domain: Fetch DID document (HTTPS)
    Domain-->>B: DID document + public key
    B->>B: Verify signature with public key
    B-->>A: Issue access token
    A->>B: Subsequent requests use token
    Note over A,B: Trust = TLS domain verification<br/>+ DID signature verification<br/>+ Principle of least trust

Güven üç kaynaktan gelir:

1. Domain-level TLSDID belgesinin ev sahibi doğrulanır
2. DID cryptographic signaturesajanın kimliğini doğrula
3. Principle of least trustSadece en az izinler verir.

İpuçlara dayalı güven yayımı ya da PageRank puanlaması yok.

#### Meta-Protokol müzakere

Bu ANP'nin en yeni özelliği. Farklı ekosistemlerden iki ajan buluştuğunda, önceden anlaşılmış veri biçimlerine ihtiyaçları yoktur.

jsonCopy{
  "action": "protocolNegotiation",
  "sequenceId": 0,
  "candidateProtocols": "I can communicate using:\n1. JSON-RPC with hotel booking schema\n2. REST with OpenAPI 3.1 spec\n3. Natural language over HTTP",
  "modificationSummary": "Initial proposal",
  "status": "negotiating"
}

sequenceDiagram
    participant A as Agent A
    participant B as Agent B

    A->>B: protocolNegotiation (candidateProtocols)
    B->>A: protocolNegotiation (counter-proposal)
    A->>B: protocolNegotiation (accepted)
    Note over A,B: Agents dynamically generate code<br/>to handle the agreed format.<br/>Max 10 rounds, then timeout.

Ajanlar bir biçim üzerinde anlaşıncaya kadar ileri-geri (maksimum 10 atış) giderler, sonra da onu yönetmek için dinamik bir kod oluştururlar.negotiating- Evet .rejected- Evet .accepted- Evet .timeout- Evet .

Bu, daha önce hiç görüşmemiş iki ajanın, ortak bir şema önceden tanımlamadan nasıl iletişim kuracağını anlayabilmeleri anlamına gelir.

Karşılaştırma (Düzeltilmiş)

Birlikte Nasıl Çalışırlar

Bu protokoller birbirini kapsaymaz. Gerçekçi bir işletme sistemi birden fazla kullanır:

graph TB
    subgraph org["Your Organization"]
        RA[Research Agent] <-->|A2A| CA[Coding Agent]
        RA -->|MCP| SS[Search Server]
        CA -->|MCP| GS[GitHub Server]
        AUDIT["All agent responses carry<br/>ACP TrajectoryMetadata"]
    end

    subgraph ext["External (DID verified via ANP)"]
        EA[External Agent]
        PA[Partner Agent]
    end

    RA <-->|ANP + A2A| EA
    CA <-->|ANP + A2A| PA

    style org fill:#f8fafc,stroke:#334155
    style ext fill:#fef2f2,stroke:#991b1b
    style AUDIT fill:#fef3c7,stroke:#d97706

• MCPHer ajanı aletlerine bağlar.
• A2A(İçi ve dış) ajanlar arasındaki işbirliğiyi ele alır.
• ACPDenetim edilebilirlik için cevapları trajektör metadatalarında sarar
• ANPKontrol etmediğiniz ajanlar için kimlik doğrulama sağlar.

Yapın

Adım 1: Temel Mesaj Türleri

Her çoklu ajan sistemi bir mesaj biçimi ile başlar. Gerçek protokollerin kullandığı harita türlerini tanımlarız:

typescriptCopyimport crypto from "node:crypto";

type MessageRole = "ROLE_USER" | "ROLE_AGENT";

type MessagePart =
  | { text: string }
  | { data: unknown; mediaType: string }
  | { url: string; filename: string; mediaType: string };

type TrajectoryEntry = {
  reasoning: string;
  toolName?: string;
  toolInput?: unknown;
  toolOutput?: unknown;
  timestamp: number;
};

type AgentMessage = {
  id: string;
  role: MessageRole;
  parts: MessagePart[];
  trajectory?: TrajectoryEntry[];
  replyTo?: string;
  timestamp: number;
};

function createMessage(
  role: MessageRole,
  parts: MessagePart[],
  replyTo?: string
): AgentMessage {
  return {
    id: crypto.randomUUID(),
    role,
    parts,
    replyTo,
    timestamp: Date.now(),
  };
}

function textMessage(role: MessageRole, text: string): AgentMessage {
  return createMessage(role, [{ text }]);
}

Not: MessagePartA2A 1.0'da olduğu gibi mevcut alan (text- Evet .dataveyaurl) bölümün ne olduğunu söylüyor; yok.kindEtiket.TrajectoryEntryAKT'in TrajectoryMetadata'sına eşleşen akıl zinciri yakalar.

Adım 2: A2A Ajan Kartı ve Kayıt

Gerçek A2A özelliklerine uyan bir ajan keşfi yapın:

typescriptCopytype Skill = {
  id: string;
  name: string;
  description: string;
  tags: string[];
  inputModes: string[];
  outputModes: string[];
};

type AgentInterface = {
  url: string;
  protocolBinding: string;
  protocolVersion: string;
};

type AgentCard = {
  name: string;
  description: string;
  version: string;
  supportedInterfaces: AgentInterface[];
  capabilities: {
    streaming: boolean;
    pushNotifications: boolean;
  };
  defaultInputModes: string[];
  defaultOutputModes: string[];
  skills: Skill[];
};

class AgentRegistry {
  private cards: Map<string, AgentCard> = new Map();

  register(card: AgentCard) {
    this.cards.set(card.name, card);
  }

  discoverBySkillTag(tag: string): AgentCard[] {
    return [...this.cards.values()].filter((card) =>
      card.skills.some((skill) => skill.tags.includes(tag))
    );
  }

  discoverByInputMode(mimeType: string): AgentCard[] {
    return [...this.cards.values()].filter(
      (card) =>
        card.defaultInputModes.includes(mimeType) ||
        card.skills.some((skill) => skill.inputModes.includes(mimeType))
    );
  }

  resolve(name: string): AgentCard | undefined {
    return this.cards.get(name);
  }

  listAll(): AgentCard[] {
    return [...this.cards.values()];
  }
}

Bu basit bir isim-ya da yetenek haritasından daha zengin. A2A özelliklerinin desteklediği gibi yetenek etiketleri, giriş MIME türleri veya isimle ajanları keşfedebilirsiniz.

Adım 3: A2A Görev Yaşam Dönemi

Tam görev durum makinesini oluştur:

typescriptCopytype TaskState =
  | "TASK_STATE_SUBMITTED"
  | "TASK_STATE_WORKING"
  | "TASK_STATE_INPUT_REQUIRED"
  | "TASK_STATE_AUTH_REQUIRED"
  | "TASK_STATE_COMPLETED"
  | "TASK_STATE_FAILED"
  | "TASK_STATE_CANCELED"
  | "TASK_STATE_REJECTED";

const TERMINAL_STATES: TaskState[] = [
  "TASK_STATE_COMPLETED",
  "TASK_STATE_FAILED",
  "TASK_STATE_CANCELED",
  "TASK_STATE_REJECTED",
];

type TaskStatus = {
  state: TaskState;
  message?: AgentMessage;
  timestamp: number;
};

type Artifact = {
  id: string;
  name: string;
  parts: MessagePart[];
};

type Task = {
  id: string;
  contextId: string;
  status: TaskStatus;
  artifacts: Artifact[];
  history: AgentMessage[];
};

type TaskEvent =
  | { statusUpdate: { taskId: string; status: TaskStatus } }
  | {
      artifactUpdate: {
        taskId: string;
        artifact: Artifact;
        append: boolean;
        lastChunk: boolean;
      };
    };

type TaskHandler = (
  task: Task,
  message: AgentMessage
) => AsyncGenerator<TaskEvent>;

class TaskManager {
  private tasks: Map<string, Task> = new Map();
  private handlers: Map<string, TaskHandler> = new Map();
  private listeners: Map<string, ((event: TaskEvent) => void)[]> = new Map();

  registerHandler(agentName: string, handler: TaskHandler) {
    this.handlers.set(agentName, handler);
  }

  subscribe(taskId: string, listener: (event: TaskEvent) => void) {
    const existing = this.listeners.get(taskId) ?? [];
    existing.push(listener);
    this.listeners.set(taskId, existing);
  }

  async sendMessage(
    agentName: string,
    message: AgentMessage,
    contextId?: string
  ): Promise<Task> {
    const handler = this.handlers.get(agentName);
    if (!handler) {
      const task = this.createTask(contextId);
      task.status = {
        state: "TASK_STATE_REJECTED",
        timestamp: Date.now(),
        message: textMessage("ROLE_AGENT", `No handler for ${agentName}`),
      };
      return task;
    }

    const task = this.createTask(contextId);
    task.history.push(message);
    task.status = { state: "TASK_STATE_SUBMITTED", timestamp: Date.now() };

    this.processTask(task, handler, message).catch((err) => {
      task.status = {
        state: "TASK_STATE_FAILED",
        timestamp: Date.now(),
        message: textMessage("ROLE_AGENT", String(err)),
      };
    });
    return task;
  }

  getTask(taskId: string): Task | undefined {
    return this.tasks.get(taskId);
  }

  cancelTask(taskId: string): boolean {
    const task = this.tasks.get(taskId);
    if (!task || TERMINAL_STATES.includes(task.status.state)) return false;
    task.status = { state: "TASK_STATE_CANCELED", timestamp: Date.now() };
    this.emit(taskId, {
      statusUpdate: { taskId, status: task.status },
    });
    return true;
  }

  private createTask(contextId?: string): Task {
    const task: Task = {
      id: crypto.randomUUID(),
      contextId: contextId ?? crypto.randomUUID(),
      status: { state: "TASK_STATE_SUBMITTED", timestamp: Date.now() },
      artifacts: [],
      history: [],
    };
    this.tasks.set(task.id, task);
    return task;
  }

  private async processTask(
    task: Task,
    handler: TaskHandler,
    message: AgentMessage
  ) {
    task.status = { state: "TASK_STATE_WORKING", timestamp: Date.now() };
    this.emit(task.id, {
      statusUpdate: { taskId: task.id, status: task.status },
    });

    try {
      for await (const event of handler(task, message)) {
        if (TERMINAL_STATES.includes(task.status.state)) break;

        if ("statusUpdate" in event) {
          task.status = event.statusUpdate.status;
        }
        if ("artifactUpdate" in event) {
          const update = event.artifactUpdate;
          const existing = task.artifacts.find(
            (a) => a.id === update.artifact.id
          );
          if (existing && update.append) {
            existing.parts.push(...update.artifact.parts);
          } else {
            task.artifacts.push(update.artifact);
          }
        }
        this.emit(task.id, event);
      }
    } catch (err) {
      task.status = {
        state: "TASK_STATE_FAILED",
        timestamp: Date.now(),
        message: textMessage("ROLE_AGENT", String(err)),
      };
      this.emit(task.id, {
        statusUpdate: { taskId: task.id, status: task.status },
      });
    }
  }

  private emit(taskId: string, event: TaskEvent) {
    for (const listener of this.listeners.get(taskId) ?? []) {
      listener(event);
    }
  }
}

Bu gerçek A2A görev yaşam döngüsünü uyguluyor: TASK_STATE_SUBMITTED- Evet .TASK_STATE_WORKING- Evet .TASK_STATE_INPUT_REQUIREDİşleyici asinkron jeneratörler.statusUpdateve artifactUpdateSSE akışı taşıyan olaylar aynı kaplamalarda.

4. Adım: AKT tarzı denetim yolu

Yolu izleme ile iletişim kurmak:

typescriptCopytype AuditEntry = {
  runId: string;
  agentName: string;
  input: AgentMessage[];
  output: AgentMessage[];
  trajectory: TrajectoryEntry[];
  status: "created" | "in-progress" | "completed" | "failed" | "awaiting";
  startedAt: number;
  completedAt?: number;
  sessionId?: string;
};

class AuditableRunner {
  private log: AuditEntry[] = [];
  private handlers: Map<
    string,
    (input: AgentMessage[]) => Promise<{
      output: AgentMessage[];
      trajectory: TrajectoryEntry[];
    }>
  > = new Map();

  registerAgent(
    name: string,
    handler: (input: AgentMessage[]) => Promise<{
      output: AgentMessage[];
      trajectory: TrajectoryEntry[];
    }>
  ) {
    this.handlers.set(name, handler);
  }

  async run(
    agentName: string,
    input: AgentMessage[],
    sessionId?: string
  ): Promise<AuditEntry> {
    const entry: AuditEntry = {
      runId: crypto.randomUUID(),
      agentName,
      input: structuredClone(input),
      output: [],
      trajectory: [],
      status: "created",
      startedAt: Date.now(),
      sessionId,
    };
    this.log.push(entry);

    const handler = this.handlers.get(agentName);
    if (!handler) {
      entry.status = "failed";
      return entry;
    }

    entry.status = "in-progress";
    try {
      const result = await handler(input);
      entry.output = structuredClone(result.output);
      entry.trajectory = structuredClone(result.trajectory);
      entry.status = "completed";
      entry.completedAt = Date.now();
    } catch (err) {
      entry.status = "failed";
      entry.trajectory.push({
        reasoning: `Error: ${String(err)}`,
        timestamp: Date.now(),
      });
      entry.completedAt = Date.now();
    }
    return entry;
  }

  getFullAuditLog(): AuditEntry[] {
    return structuredClone(this.log);
  }

  getAuditLogForAgent(agentName: string): AuditEntry[] {
    return structuredClone(
      this.log.filter((e) => e.agentName === agentName)
    );
  }

  getAuditLogForSession(sessionId: string): AuditEntry[] {
    return structuredClone(
      this.log.filter((e) => e.sessionId === sessionId)
    );
  }

  getTrajectoryForRun(runId: string): TrajectoryEntry[] {
    const entry = this.log.find((e) => e.runId === runId);
    return entry ? structuredClone(entry.trajectory) : [];
  }
}

Her ajan çalışması tam bir denetim girişini oluşturur: ne girdi, ne çıktı ve araç çağrılarının ve bunun arasında düşünme adımlarının tüm trajektörünü.

Adım 5: ANP-Stil Kimlik Doğrulama

DID tabanlı kimlik ve doğrulama oluşturmak:

typescriptCopytype VerificationMethod = {
  id: string;
  type: string;
  controller: string;
  publicKeyDer: string;
};

type DIDDocument = {
  id: string;
  verificationMethod: VerificationMethod[];
  authentication: string[];
  keyAgreement: string[];
  humanAuthorization: string[];
  service: { id: string; type: string; serviceEndpoint: string }[];
};

type AgentIdentity = {
  did: string;
  document: DIDDocument;
  privateKey: crypto.KeyObject;
  publicKey: crypto.KeyObject;
};

class IdentityRegistry {
  private documents: Map<string, DIDDocument> = new Map();

  publish(doc: DIDDocument) {
    this.documents.set(doc.id, doc);
  }

  resolve(did: string): DIDDocument | undefined {
    return this.documents.get(did);
  }

  verify(did: string, signature: string, payload: string): boolean {
    const doc = this.documents.get(did);
    if (!doc) return false;

    const authKeyIds = doc.authentication;
    const authKeys = doc.verificationMethod.filter((vm) =>
      authKeyIds.includes(vm.id)
    );

    for (const key of authKeys) {
      const publicKey = crypto.createPublicKey({
        key: Buffer.from(key.publicKeyDer, "base64"),
        format: "der",
        type: "spki",
      });
      const isValid = crypto.verify(
        null,
        Buffer.from(payload),
        publicKey,
        Buffer.from(signature, "hex")
      );
      if (isValid) return true;
    }
    return false;
  }

  requiresHumanAuth(did: string, operationKeyId: string): boolean {
    const doc = this.documents.get(did);
    if (!doc) return false;
    return doc.humanAuthorization.includes(operationKeyId);
  }
}

function createIdentity(domain: string, agentName: string): AgentIdentity {
  const did = `did:wba:${domain}:agent:${agentName}`;
  const { publicKey, privateKey } = crypto.generateKeyPairSync("ed25519");

  const publicKeyDer = publicKey
    .export({ format: "der", type: "spki" })
    .toString("base64");

  const keyId = `${did}#key-1`;
  const encKeyId = `${did}#key-x25519-1`;

  const document: DIDDocument = {
    id: did,
    verificationMethod: [
      {
        id: keyId,
        type: "Ed25519VerificationKey2020",
        controller: did,
        publicKeyDer,
      },
      {
        id: encKeyId,
        type: "X25519KeyAgreementKey2019",
        controller: did,
        publicKeyDer,
      },
    ],
    authentication: [keyId],
    keyAgreement: [encKeyId],
    humanAuthorization: [],
    service: [
      {
        id: `${did}#agent-description`,
        type: "AgentDescription",
        serviceEndpoint: `https://${domain}/agents/${agentName}/ad.json`,
      },
    ],
  };

  return { did, document, privateKey, publicKey };
}

function signPayload(identity: AgentIdentity, payload: string): string {
  return crypto
    .sign(null, Buffer.from(payload), identity.privateKey)
    .toString("hex");
}

Bu gerçek ANP kimlik modelini yansıtır: ajanlar ayrı kimlik doğrulama, anahtar anlaşma ve insan yetkisi anahtarları ile DID belgelerine sahiptir.IdentityRegistryDID çözünürlüğünü simüle eder (prodüksiyonda bu, ajanın alanına HTTP getirir).

Adım 6: Protokol Geçidi

Dört protokolü de tek bir sisteme bağlayın:

graph LR
    REQ[Incoming Request] --> ANP_V{ANP: Verify DID}
    ANP_V -->|Valid| A2A_D{A2A: Discover Agent}
    ANP_V -->|Invalid| REJECT[Reject]
    A2A_D -->|Found| ACP_A[ACP: Audit Run]
    A2A_D -->|Not Found| REJECT
    ACP_A --> A2A_T[A2A: Create Task]
    A2A_T --> RESULT[Task + Audit Entry]

    style ANP_V fill:#d1fae5,stroke:#059669
    style A2A_D fill:#dbeafe,stroke:#2563eb
    style ACP_A fill:#fef3c7,stroke:#d97706
    style A2A_T fill:#dbeafe,stroke:#2563eb

typescriptCopyclass ProtocolGateway {
  private registry: AgentRegistry;
  private taskManager: TaskManager;
  private auditRunner: AuditableRunner;
  private identityRegistry: IdentityRegistry;

  constructor(
    registry: AgentRegistry,
    taskManager: TaskManager,
    auditRunner: AuditableRunner,
    identityRegistry: IdentityRegistry
  ) {
    this.registry = registry;
    this.taskManager = taskManager;
    this.auditRunner = auditRunner;
    this.identityRegistry = identityRegistry;
  }

  async delegateTask(
    fromDid: string,
    signature: string,
    targetAgent: string,
    message: AgentMessage,
    sessionId?: string
  ): Promise<{ task: Task; audit: AuditEntry } | { error: string }> {
    if (!this.identityRegistry.verify(fromDid, signature, message.id)) {
      return { error: "Identity verification failed" };
    }

    const card = this.registry.resolve(targetAgent);
    if (!card) {
      return { error: `Agent ${targetAgent} not found in registry` };
    }

    const audit = await this.auditRunner.run(
      targetAgent,
      [message],
      sessionId
    );
    const task = await this.taskManager.sendMessage(targetAgent, message);

    return { task, audit };
  }

  discoverAndDelegate(
    fromDid: string,
    signature: string,
    skillTag: string,
    message: AgentMessage
  ): Promise<{ task: Task; audit: AuditEntry } | { error: string }> {
    const candidates = this.registry.discoverBySkillTag(skillTag);
    if (candidates.length === 0) {
      return Promise.resolve({
        error: `No agents found with skill tag: ${skillTag}`,
      });
    }
    return this.delegateTask(
      fromDid,
      signature,
      candidates[0].name,
      message
    );
  }
}

Kapı bir çağrıda dört şey yapar:

1. ANP: DID imzası ile arayanın kimliğini doğruluyor
2. A2A: Hedef ajanı keşfeder ve yeteneklerini kontrol eder
3. ACP: İcracılığı bir denetim izine çevirir ve bir yoldur
4. A2A: Tam yaşam döngüsü izleme ile bir görev oluşturur

7 . Adım: Her şeyi bir arada yapın

typescriptCopyasync function protocolDemo() {
  const registry = new AgentRegistry();
  registry.register({
    name: "researcher",
    description: "Searches and summarizes findings",
    version: "1.0.0",
    supportedInterfaces: [
      {
        url: "https:TOK0
        protocolBinding: "JSONRPC",
        protocolVersion: "1.0",
      },
    ],
    capabilities: { streaming: true, pushNotifications: false },
    defaultInputModes: ["text/plain"],
    defaultOutputModes: ["text/plain", "application/json"],
    skills: [
      {
        id: "web-research",
        name: "Web Research",
        description: "Searches the web",
        tags: ["research", "search", "summarization"],
        inputModes: ["text/plain"],
        outputModes: ["application/json"],
      },
    ],
  });
  registry.register({
    name: "coder",
    description: "Writes code from specs",
    version: "1.0.0",
    supportedInterfaces: [
      {
        url: "https://coder.local/a2a/v1",
        protocolBinding: "JSONRPC",
        protocolVersion: "1.0",
      },
    ],
    capabilities: { streaming: false, pushNotifications: false },
    defaultInputModes: ["text/plain", "application/json"],
    defaultOutputModes: ["text/plain"],
    skills: [
      {
        id: "code-gen",
        name: "Code Generation",
        description: "Generates code",
        tags: ["coding", "generation"],
        inputModes: ["text/plain", "application/json"],
        outputModes: ["text/plain"],
      },
    ],
  });

  const taskManager = new TaskManager();
  const auditRunner = new AuditableRunner();

  const researchTrajectory: TrajectoryEntry[] = [];

  taskManager.registerHandler(
    "researcher",
    async function* (task, message) {
      yield {
        statusUpdate: {
          taskId: task.id,
          status: {
            state: "TASK_STATE_WORKING" as const,
            timestamp: Date.now(),
          },
        },
      };

      researchTrajectory.push({
        reasoning: "Searching for React 19 documentation",
        toolName: "web_search",
        toolInput: { query: "React 19 compiler features" },
        toolOutput: {
          results: ["react.dev/blog/react-19", "github.com/react/react"],
        },
        timestamp: Date.now(),
      });

      researchTrajectory.push({
        reasoning: "Extracting key findings from search results",
        toolName: "doc_analysis",
        toolInput: { url: "react.dev/blog/react-19" },
        toolOutput: {
          summary:
            "React 19 compiler auto-memoizes, no manual useMemo needed",
        },
        timestamp: Date.now(),
      });

      yield {
        artifactUpdate: {
          taskId: task.id,
          artifact: {
            id: crypto.randomUUID(),
            name: "research-results",
            parts: [
              {
                data: {
                  findings: [
                    "React 19 compiler auto-memoizes components",
                    "No more manual useMemo/useCallback needed",
                    "Compiler runs at build time, not runtime",
                  ],
                  sources: ["react.dev/blog/react-19"],
                },
                mediaType: "application/json",
              },
            ],
          },
          append: false,
          lastChunk: true,
        },
      };

      yield {
        statusUpdate: {
          taskId: task.id,
          status: {
            state: "TASK_STATE_COMPLETED" as const,
            timestamp: Date.now(),
          },
        },
      };
    }
  );

  auditRunner.registerAgent("researcher", async () => ({
    output: [
      textMessage("ROLE_AGENT", "React 19 compiler auto-memoizes components"),
    ],
    trajectory: researchTrajectory,
  }));

  const identityRegistry = new IdentityRegistry();

  const coderIdentity = createIdentity("coder.local", "coder");
  const researcherIdentity = createIdentity("researcher.local", "researcher");

  identityRegistry.publish(coderIdentity.document);
  identityRegistry.publish(researcherIdentity.document);

  const gateway = new ProtocolGateway(
    registry,
    taskManager,
    auditRunner,
    identityRegistry
  );

  console.log("=== Protocol Demo ===\n");

  console.log("1. Agent Discovery (A2A)");
  const researchAgents = registry.discoverBySkillTag("research");
  console.log(
    `   Found ${researchAgents.length} agent(s):`,
    researchAgents.map((a) => a.name)
  );

  console.log("\n2. Identity Verification (ANP)");
  const message = textMessage("ROLE_USER", "Research React 19 compiler features");
  const signature = signPayload(coderIdentity, message.id);
  const verified = identityRegistry.verify(
    coderIdentity.did,
    signature,
    message.id
  );
  console.log(`   Coder DID: ${coderIdentity.did}`);
  console.log(`   Signature verified: ${verified}`);

  console.log("\n3. Task Delegation (A2A + ACP + ANP)");
  const result = await gateway.delegateTask(
    coderIdentity.did,
    signature,
    "researcher",
    message,
    "session-001"
  );

  if ("error" in result) {
    console.log(`   Error: ${result.error}`);
    return;
  }

  console.log(`   Task ID: ${result.task.id}`);
  console.log(`   Task state: ${result.task.status.state}`);
  console.log(`   Artifacts: ${result.task.artifacts.length}`);

  console.log("\n4. Audit Trail (ACP)");
  console.log(`   Run ID: ${result.audit.runId}`);
  console.log(`   Status: ${result.audit.status}`);
  console.log(`   Trajectory steps: ${result.audit.trajectory.length}`);
  for (const step of result.audit.trajectory) {
    console.log(`     - ${step.reasoning}`);
    if (step.toolName) {
      console.log(`       Tool: ${step.toolName}`);
    }
  }

  console.log("\n5. Full Audit Log");
  const fullLog = auditRunner.getFullAuditLog();
  console.log(`   Total runs: ${fullLog.length}`);
  for (const entry of fullLog) {
    const duration = entry.completedAt
      ? `${entry.completedAt - entry.startedAt}ms`
      : "in-progress";
    console.log(`   ${entry.agentName}: ${entry.status} (${duration})`);
  }
}

protocolDemo().catch((err) => {
  console.error("Protocol demo failed:", err);
  process.exitCode = 1;
});

Sorun Ne?

Protokoller mutlu yolları çözüyor.

Schema drift.A ajanı bir kart reklamı yayınlıyor .application/jsonBu, bir diğer diğer özelliktir. ama JSON şeması sürümler arasında değişir. Ajan B eski biçimi analiz eder ve çöp alır. Düzelt: sürüm becerilerinizi ve çıkış şemelerini. A2A spesifikasyonu destekler versionBu nedenle Ajan Kartlar'a.

State machine violations.Bir ajanı yöneten bir TASK_STATE_COMPLETEDBu işlem, daha fazla eser üretmeye çalışır. Görev değişmez. Kodunuz güncellemeleri sessiz bırakır veya atır.TaskManagerBu konuda bir karar verildi.breakTerminali durumlardan sonra.

Trust resolution failures.A ajanı B ajanının DID'ini doğrulamaya çalışıyor, ancak B ajanının alanı çökmüştür. DID belgesini alamazsınız. Açmayı başarısız mı ediyorsunuz (anlatılmamış ajanları kabul ediyor musunuz) veya kapatmayı başarısız mı ediyorsunuz (her şeyi reddediyorsunuz)? ANP en az güven ilkesine uygun olarak kapatmayı önerir.

Trajectory bloat.ACP yörüngesi kaydesi güçlü ama pahalıdır. Bir çalışmada 200 araç çağrısı yapan karmaşık bir ajan, büyük denetim girişleri üretir. Düzeltme: yapılandırılabilir sözcüklülik seviyelerinde kayıt yörüngesi. Uyumlulık için araç isimlerini ve IO'yu kaydedin, düzenlenmeyen iş yükleri için mantık adımlarını atın.

Discovery thundering herd.50 ajan tüm sorgu GET /agentsTTL ile cache Agent Kartları, aşamalı keşif aralıkları veya seçim yerine push tabanlı kayıt kullanın.

Kullan

Gerçek Uygulamalar

A2AGoogle'ın en olgun.official specEğer ajanlarınız dinamik keşif ve işbirliğine ihtiyaç duyarsanız buradan başlayın.

ACPA2A'ya birleşiyor. IBM'in BeeAI projectBu nedenle, A2A'nın kullanımı için A2A'nın kullanılması gereken araçlar ve araçlar için A2A'nın kullanılması gereken araçlar ve araçlar için A2A'nın kullanılması gereken araçlar ve araçlar için A2A'nın kullanılması gereken araçlar ve araçlar için A2A'nın kullanılması gereken araçlar ve araçlar için A2A'nın kullanılması gereken araçlar ve araçlar için A2A'nın kullanılması gereken araçlar için de A2A'nın kullanılması gerekmektedir.

ANPEn deneysel.community repoMeta-protokol müzakere konsepti gerçekten yeni.

MCPEğer ajanların araç kullanmasını istiyorsanız, MCP standarttır.

Doğru Protokolü Seçmek

graph TD
    START{Do agents need<br/>to use tools?}
    START -->|Yes| MCP_R[Use MCP]
    START -->|No| TALK{Do agents need to<br/>talk to each other?}
    TALK -->|No| NONE[You don't need<br/>a protocol]
    TALK -->|Yes| AUDIT{Need audit trails<br/>for compliance?}
    AUDIT -->|Yes| ACP_R[A2A + ACP<br/>trajectory patterns]
    AUDIT -->|No| ORG{All agents<br/>within your org?}
    ORG -->|Yes| A2A_R[A2A<br/>Agent Cards + Tasks]
    ORG -->|No| INFRA{Shared<br/>infrastructure?}
    INFRA -->|Yes| BROKER[A2A + message broker]
    INFRA -->|No| ANP_R[ANP + A2A<br/>DID verification]

    style MCP_R fill:#d1fae5,stroke:#059669
    style A2A_R fill:#dbeafe,stroke:#2563eb
    style ACP_R fill:#fef3c7,stroke:#d97706
    style ANP_R fill:#f3e8ff,stroke:#7c3aed
    style BROKER fill:#e0e7ff,stroke:#4338ca

Gönder

Bu ders şunları ortaya çıkarır:

• code/main.ts-- Dört protokol modelinin tamamı
• outputs/prompt-protocol-selector.md-- sisteminiz için protokoller seçmenize yardımcı olan bir istek.

Egzersizler

1. Multi-hop task delegation.TaskManagerBu nedenle bir ajan yöneticisi alt görevleri diğer ajanlara delegede edebilir. Araştırmacı bir görev alır, alt görevleri iki uzman ajanına "arşiv" ve "cümlelendirir", her ikisinin tamamlanmasını bekler, sonra sonuçları kendi eserlerine birleştirir.

1. Streaming audit trail.Değiştir AuditableRunnerTam sonuç beklemek yerine, ver AuditEntryTrajektör girişleri eklendiğinde gerçek zamanlı güncelleştirmeler.

1. DID rotation.Anahtar dönüşümünü ekle IdentityRegistryBir ajan , yeni bir DID belgesini güncelleştirilmiş anahtarlarla yayınlayıp bir previousDidVerifiyeciler, bir süre içinde hem mevcut hem de önceki anahtarın imzalarını kabul etmelidir.

1. Protocol negotiation.ANP'nin meta-protokolu kavramını uygula.protocolNegotiationİhtiyaclı biçimlerde mesajlar (örneğin, "JSON-RPC konuşabilirim" vs. "REST'i tercih ederim"). Maksimum 3 turdan sonra, bir biçim veya zaman kesimi konusunda anlaşırlar. Anlaşılmış biçim hangisini belirler TaskManagerveya AuditableRunner- Kullanıyorlar.

1. Rate-limited discovery.Bir ekleRateLimitedRegistryBu kartı aramaya göre, bir TTL ile kaydedilir ve bir saniye başına bir ajan için keşif sorgularını sınırlandırır.

Anahtar Terimler

Daha Fazla Okumak

• Google A2A specification-- resmi özellikler ve SDK'lar (v1.0.1, Linux Foundation)
• IBM/BeeAI ACP specification-- OpenAPI 3.1 özellikleri ajan çalışmalar ve yörüngeler için metadata
• Agent Network Protocol-- DID tabanlı kimlik, E2EE, meta-protokola müzakere
• Model Context Protocol docs-- Anthropic'in MCP özellikleri (Faz 13'te kapsamlı)
• W3C Decentralized Identifiers-- ANP'nin temelinde bulunan kimlik standardı
• RFC 9180 (HPKE)-- ANP'nin E2EE için kullandığı şifreleme sistemi
• FIPA Agent Communication Language- Modern ajan protokollerinin akademik öncü.

This free lesson is part of the AI Engineering from Scratch curriculum. Read the full explanation, run the lesson code, and verify the result in the interactive reader or from the repository source.

Browse the complete course catalog or open this lesson on GitHub.