{
  "slug": "credential-propagation-across-agent-hops",
  "title": "Credential Propagation Across Agent Hops: Exchange, Audience and Depth",
  "description": "How to carry authority through a chain of delegating agents: why forwarding a token fails, per-hop RFC 8693 exchange with act and may_act, RFC 8707 audience binding, a worked sequence and a failure walk-through.",
  "kind": "sub",
  "order": 6,
  "target_query": "how to propagate credentials across multi-agent delegation chains",
  "secondary_queries": [],
  "tags": [
    "a2a",
    "delegation",
    "oauth",
    "token-exchange",
    "multi-agent",
    "security",
    "identity"
  ],
  "published": "2026-11-04",
  "updated": "2026-11-04",
  "words": 1361,
  "estimated_tokens": 1810,
  "premium": false,
  "rights": {
    "access": "free",
    "note": "Editorial guides are always free and never part of the licensed corpus.",
    "license": "https://changegamer.ai/license.xml",
    "pricing": "https://changegamer.ai/api/pricing.json",
    "payment": "https://changegamer.ai/api/payment.json"
  },
  "license": "https://changegamer.ai/license.xml",
  "citation": "ChangeGamer (2026-11-04). Credential Propagation Across Agent Hops: Exchange, Audience and Depth. ChangeGamer. https://changegamer.ai/articles/credential-propagation-across-agent-hops (updated 2026-11-04).",
  "bibtex": "@misc{changegamer_credential_propagation_across_agent_hops, title = {Credential Propagation Across Agent Hops: Exchange, Audience and Depth}, publisher = {ChangeGamer}, year = {2026}, url = {https://changegamer.ai/articles/credential-propagation-across-agent-hops}, note = {Updated 2026-11-04}}",
  "canonical": "https://changegamer.ai/articles/credential-propagation-across-agent-hops",
  "markdown": "https://changegamer.ai/articles/credential-propagation-across-agent-hops.md",
  "takeaways": [
    "To propagate credentials across a multi-agent delegation chain, each agent should exchange the token it received for a new, narrower token aimed only at the next hop, using RFC 8693 token exchange, and never forward the token it was given.",
    "Binding each hop token to the next service with the RFC 8707 resource parameter means a resource server that checks the aud claim rejects a token captured mid-chain when it is replayed against any other downstream service.",
    "Depth caps and 5 to 15 minute token lifetimes are builder guidance from the ChangeGamer delegation-chains reference, not requirements of RFC 8693, so they must be enforced as policy in your own authorization server.",
    "The nested act claim records who acted, but RFC 8693 does not verify it cryptographically, so a resource server should log the full chain for audit and not treat it as proof by itself.",
    "The IETF actor-chain drafts that aim to make chains verifiable were still individual Internet-Drafts as of June 2026, so they are signals to watch and not specifications to build against."
  ],
  "outline": [
    {
      "depth": 2,
      "text": "Why does forwarding a token fail?",
      "anchor": "why-does-forwarding-a-token-fail",
      "url": "https://changegamer.ai/articles/credential-propagation-across-agent-hops#why-does-forwarding-a-token-fail"
    },
    {
      "depth": 2,
      "text": "How does per-hop token exchange work?",
      "anchor": "how-does-per-hop-token-exchange-work",
      "url": "https://changegamer.ai/articles/credential-propagation-across-agent-hops#how-does-per-hop-token-exchange-work"
    },
    {
      "depth": 2,
      "text": "What does a worked hop-by-hop sequence look like? (reasoning)",
      "anchor": "what-does-a-worked-hop-by-hop-sequence-look-like-reasoning",
      "url": "https://changegamer.ai/articles/credential-propagation-across-agent-hops#what-does-a-worked-hop-by-hop-sequence-look-like-reasoning"
    },
    {
      "depth": 2,
      "text": "How deep and how long should a chain live?",
      "anchor": "how-deep-and-how-long-should-a-chain-live",
      "url": "https://changegamer.ai/articles/credential-propagation-across-agent-hops#how-deep-and-how-long-should-a-chain-live"
    },
    {
      "depth": 2,
      "text": "Why must the resource server log the whole act chain?",
      "anchor": "why-must-the-resource-server-log-the-whole-act-chain",
      "url": "https://changegamer.ai/articles/credential-propagation-across-agent-hops#why-must-the-resource-server-log-the-whole-act-chain"
    },
    {
      "depth": 2,
      "text": "What happens when a hop is compromised? (reasoning)",
      "anchor": "what-happens-when-a-hop-is-compromised-reasoning",
      "url": "https://changegamer.ai/articles/credential-propagation-across-agent-hops#what-happens-when-a-hop-is-compromised-reasoning"
    },
    {
      "depth": 2,
      "text": "Are there standards for verifiable actor chains?",
      "anchor": "are-there-standards-for-verifiable-actor-chains",
      "url": "https://changegamer.ai/articles/credential-propagation-across-agent-hops#are-there-standards-for-verifiable-actor-chains"
    },
    {
      "depth": 2,
      "text": "How does this map onto A2A? (inference)",
      "anchor": "how-does-this-map-onto-a2a-inference",
      "url": "https://changegamer.ai/articles/credential-propagation-across-agent-hops#how-does-this-map-onto-a2a-inference"
    },
    {
      "depth": 2,
      "text": "Does ChangeGamer run a delegation chain?",
      "anchor": "does-changegamer-run-a-delegation-chain",
      "url": "https://changegamer.ai/articles/credential-propagation-across-agent-hops#does-changegamer-run-a-delegation-chain"
    }
  ],
  "faq": [
    {
      "question": "Why can an agent not just forward the user token to the next agent?",
      "answer": "A forwarded token carries the user authority with its original audience and scope, so any agent or service that captures it can replay it elsewhere. That is the confused-deputy flaw repeated across hops. Each agent should instead obtain a fresh token for the next hop only."
    },
    {
      "question": "What is the difference between the act and may_act claims?",
      "answer": "The act claim records which party is currently acting for the token subject and can nest to show earlier actors, while may_act in the subject token names a party the issuer pre-approves to act. One describes the actors so far; the other authorizes the next one."
    },
    {
      "question": "How many hops should a delegation chain allow?",
      "answer": "No RFC fixes a number, so the cap is your own policy. The ChangeGamer delegation-chains reference recommends enforcing a maximum depth at the authorization server and rejecting exchanges that would exceed it. Pick the smallest depth your real workflows need."
    },
    {
      "question": "Does A2A define how credentials move between agents?",
      "answer": "The A2A reference in the ChangeGamer corpus describes security schemes declared on the Agent Card, not a token exchange between hops. Layering OAuth token exchange on top of A2A calls is therefore an inference from OAuth practice, not specified A2A behaviour."
    }
  ],
  "body": "Propagate credentials across a delegation chain by minting a new, narrower token at every hop instead of passing one token along. The [agent delegation chains reference](/resources/agent-delegation-chains) (updated 2 October 2026) states the contract. The [A2A pillar](/articles/a2a-protocol-in-practice) names the mechanisms; this article adds what neither does, which is a worked sequence and a failure walk-through. Both are reasoning from the reference, labelled as such.\n\n## Why does forwarding a token fail?\n\nForwarding fails because a token keeps its original audience and authority at every hop, so whoever holds it can use it anywhere the issuer is trusted. The reference calls this the confused-deputy flaw replayed across hops: a token captured at hop two works against any other service that trusts the same authorization server.\n\nForwarding also destroys the record (reasoning). A token passed through unchanged says nothing about which agents handled it, so the resource server sees only the original authority. The [agent identity reference](/resources/agent-identity-authentication) (updated 17 July 2026) draws the underlying line: workload identity is what an agent is, delegated authority is permission to act for someone, and it names conflating them as the root cause of most agent auth mistakes. Forwarding one credential for both is that conflation (reasoning). Handing over a user's own token is also the anti-pattern described in the [A2A authentication schemes article](/articles/a2a-authentication-schemes).\n\n## How does per-hop token exchange work?\n\nEach hop presents the token it holds to the authorization server and receives a new token for the next hop. The mechanism is RFC 8693 (January 2020), with grant type `urn:ietf:params:oauth:grant-type:token-exchange`.\n\nTwo claims carry the delegation story, per the reference:\n\n| Claim | Where | Role |\n|---|---|---|\n| `act` | In the issued token | Names the party now acting; nests so each hop appends itself |\n| `may_act` | In the subject token | The issuer pre-approves which party may act next |\n\nAudience comes from RFC 8707 (February 2020). The exchange request names the next service in the `resource` parameter, and the issued token's `aud` matches that service only. A token minted for service B should be refused by service C.\n\n## What does a worked hop-by-hop sequence look like? (reasoning)\n\nThe sequence below is an illustration built from the reference's mechanisms, not a transcript of any product. Take a user, an orchestrator agent, a research sub-agent and a tool API.\n\n1. **Hop 0.** The user authorizes the orchestrator. The authorization server issues token T0 with `sub` the user, `aud` the orchestrator, and a `may_act` naming the orchestrator, the party the issuer allows to act next.\n2. **Hop 1.** The orchestrator exchanges T0 with `resource` set to the sub-agent. Token T1 has `aud` the sub-agent, `sub` still the user, and `act` naming the orchestrator. In this illustration the issuer also puts a `may_act` naming the sub-agent on T1, so the same check can run at hop 2.\n3. **Hop 2.** The sub-agent exchanges T1 with `resource` set to the tool API. Token T2 has `aud` the tool API, `sub` the user, and `act` naming the sub-agent with the orchestrator nested inside.\n4. **Resource server.** The tool API accepts T2 only because its own identifier is in `aud`, then logs `sub` and the full nested `act` chain with the request.\n\nAt each exchange the authorization server can apply the policy the reference recommends: reject if `may_act` does not name the caller, reject if the chain would exceed the depth cap, and issue a lifetime of minutes. The scope on each new token should be the same or narrower, never wider; that narrowing is the point of the exchange.\n\n## How deep and how long should a chain live?\n\nCap depth and keep lifetimes short, but treat both as your own policy. The reference recommends deciding the maximum hop count in authorization-server configuration and rejecting exchanges that exceed it, and it gives 5 to 15 minutes per step to limit the damage if one token leaks. It states that no current RFC mandates either; this is builder guidance, not standard.\n\nA practical reading, as inference: set the depth to the deepest chain your real workflows need and no further, because every extra hop is another place a token can be captured. A short lifetime also means a long-running task needs a fresh exchange at each step, so budget for exchange latency and failure.\n\n## Why must the resource server log the whole act chain?\n\nThe resource server should log the full `act` chain because the reference calls it the only audit artifact linking the original user delegation to every downstream agent action. Without it, an investigation can see that the tool API was called but not by whom on whose behalf.\n\nDo not read more into the claim than the standard gives. RFC 8693 checks only the immediately preceding hop, and earlier actors in `act` are informational. The claim is a useful record, not proof that the history is untampered, so pair the log with the authorization server's own exchange records. The [audit trails article](/articles/audit-trails-for-ai-agents) covers keeping such records.\n\n## What happens when a hop is compromised? (reasoning)\n\nA compromised hop is contained by audience, lifetime and exchange policy working together. Walk through the same chain with the sub-agent breached after it receives T1.\n\n- **Replay against another service.** The attacker tries T1 against the tool API. Its `aud` is the sub-agent, so the tool API refuses it.\n- **Replay against a sibling.** The attacker, after the sub-agent's own exchange produces T2, tries T2 against a different tool. The audience does not match, so it is refused.\n- **Asking for more.** The attacker exchanges T1 for a token whose audience is a service the authorization server's policy does not permit for that actor. The authorization server refuses, if it enforces that policy; `may_act` only covers which actor may exchange.\n- **Inserting a hop.** The attacker tries to extend the chain past the depth cap. The server rejects the exchange.\n- **What remains.** Until T1 or T2 expires, the attacker can still act as the sub-agent against the tool API. Short lifetimes bound that window; they do not remove it.\n\nThe walk-through shows why forwarding is worse: a single forwarded token would have no audience boundary and no cap.\n\n## Are there standards for verifiable actor chains?\n\nTwo drafts target the gap, and as of June 2026 both were individual Internet-Drafts with no working-group RFC standing, per the reference. Verify the current revision on the IETF Datatracker before building to either.\n\n| Draft | State in the reference | Adds |\n|---|---|---|\n| draft-mw-spice-actor-chain | Rev -05, April 2026; resubmitted as draft-mw-oauth-actor-chain-00 | Verified profiles with sender-constrained tokens and a signature over the chain, aimed at chain-splicing |\n| draft-oauth-ai-agents-on-behalf-of-user | Rev -02, August 2025 | `requested_actor` and `actor_token` parameters on the authorization-code flow, for per-agent user consent |\n\nThe reference advises tracking the OAuth working group draft, not the original SPICE-space document. As of June 2026 the reference calls such drafts directional signals, not stable specifications, so treat neither as a settled dependency and verify the current revision.\n\n## How does this map onto A2A? (inference)\n\nA2A carries the authentication step; token exchange between hops is an OAuth practice you layer on top. The [A2A reference](/resources/a2a-protocol) describes security schemes declared on the Agent Card, and does not describe an exchange between hops, so treat everything here as inference.\n\nIn practice that suggests the following: a receiving agent reads the card's declared scheme, satisfies it with a token minted for that agent's audience, and then performs its own exchange before calling onward. The [A2A pillar](/articles/a2a-protocol-in-practice) and the [scheme-selection article](/articles/a2a-authentication-schemes) cover the card side. For the single-hop OAuth foundations, see [how AI agents prove identity and delegated authority](/articles/agent-identity-and-authentication-for-ai-agents), and for storage and rotation, [credential hygiene for AI agents](/articles/credential-hygiene-for-ai-agents).\n\n## Does ChangeGamer run a delegation chain?\n\nNo cross-service delegation chain. As of 4 November 2026, the only first-hand artefacts are that ChangeGamer's six `.claude/agents` definitions are in-process delegation, with no network hop or token exchange, and that the BACKLOG entry of 16 September 2026 records a deliberate decision not to publish A2A discovery documents because the site speaks MCP. Everything above is reasoning from the reference, not operating experience.",
  "cluster": {
    "id": "a2a-in-practice",
    "title": "A2A in practice: agent-to-agent interoperability",
    "description": "How to build, secure and run agent-to-agent delegation with the A2A protocol — when A2A beats in-process subagents, Agent Cards, task lifecycle, bindings, authentication, credential propagation across hops, discovery and trust, v0.3 to v1.0 migration, framework support and failure handling — not MCP tool serving (mcp-in-practice) and not single-agent identity (agent-identity-and-authentication-for-ai-agents).",
    "status": "complete",
    "pillar": {
      "slug": "a2a-protocol-in-practice",
      "title": "The A2A Protocol in Practice: Agent Cards, Tasks, Auth and When You Need It",
      "description": "A practical guide to the A2A (Agent2Agent) protocol: what it standardizes, when it beats in-process subagents, how Agent Cards, task states, bindings and authentication work, how credentials cross agent hops, and how to launch it.",
      "kind": "pillar",
      "order": 0,
      "html": "https://changegamer.ai/articles/a2a-protocol-in-practice",
      "markdown": "https://changegamer.ai/articles/a2a-protocol-in-practice.md",
      "json": "https://changegamer.ai/api/articles/a2a-protocol-in-practice.json"
    },
    "articles": [
      {
        "slug": "do-you-need-a2a",
        "title": "Do You Need A2A for a Multi-Agent System? A Decision Rule",
        "description": "A decision rule for choosing between in-process subagents and the A2A protocol: start with one agent, add more only for a named failure, and cross the network with A2A only when a remote party, framework or trust boundary demands it.",
        "kind": "sub",
        "order": 1,
        "html": "https://changegamer.ai/articles/do-you-need-a2a",
        "markdown": "https://changegamer.ai/articles/do-you-need-a2a.md",
        "json": "https://changegamer.ai/api/articles/do-you-need-a2a.json"
      },
      {
        "slug": "a2a-agent-card-design",
        "title": "Designing an Agent Card: What Goes in the Public Card and What Waits",
        "description": "How to design an A2A Agent Card: the field groups, the well-known path, optional signing, and a rule for splitting what the public card advertises from what an authenticated client fetches in the extended card.",
        "kind": "sub",
        "order": 2,
        "html": "https://changegamer.ai/articles/a2a-agent-card-design",
        "markdown": "https://changegamer.ai/articles/a2a-agent-card-design.md",
        "json": "https://changegamer.ai/api/articles/a2a-agent-card-design.json"
      },
      {
        "slug": "a2a-task-lifecycle",
        "title": "A2A Task States and Operations: What Each State Means for an Orchestrator",
        "description": "The eight A2A task states, the eleven operations that act on tasks, the difference between interrupted and terminal states, and an inference-labelled handler matrix for an orchestrator.",
        "kind": "sub",
        "order": 3,
        "html": "https://changegamer.ai/articles/a2a-task-lifecycle",
        "markdown": "https://changegamer.ai/articles/a2a-task-lifecycle.md",
        "json": "https://changegamer.ai/api/articles/a2a-task-lifecycle.json"
      },
      {
        "slug": "a2a-bindings-json-rpc-grpc-rest",
        "title": "A2A JSON-RPC vs gRPC vs REST: What Differs Between the Three Bindings",
        "description": "The three A2A protocol bindings (JSON-RPC, gRPC, HTTP+JSON/REST): what the specification keeps identical, what differs on the wire, and an inference-labelled guide to picking one.",
        "kind": "sub",
        "order": 4,
        "html": "https://changegamer.ai/articles/a2a-bindings-json-rpc-grpc-rest",
        "markdown": "https://changegamer.ai/articles/a2a-bindings-json-rpc-grpc-rest.md",
        "json": "https://changegamer.ai/api/articles/a2a-bindings-json-rpc-grpc-rest.json"
      },
      {
        "slug": "a2a-authentication-schemes",
        "title": "A2A Authentication Schemes: Which to Declare in Your Agent Card",
        "description": "The five security scheme families an A2A Agent Card can declare (API key, HTTP auth, OAuth 2.0, OpenID Connect, mutual TLS), an inference-labelled rule for choosing one, and how a client handles auth-required tasks.",
        "kind": "sub",
        "order": 5,
        "html": "https://changegamer.ai/articles/a2a-authentication-schemes",
        "markdown": "https://changegamer.ai/articles/a2a-authentication-schemes.md",
        "json": "https://changegamer.ai/api/articles/a2a-authentication-schemes.json"
      },
      {
        "slug": "credential-propagation-across-agent-hops",
        "title": "Credential Propagation Across Agent Hops: Exchange, Audience and Depth",
        "description": "How to carry authority through a chain of delegating agents: why forwarding a token fails, per-hop RFC 8693 exchange with act and may_act, RFC 8707 audience binding, a worked sequence and a failure walk-through.",
        "kind": "sub",
        "order": 6,
        "html": "https://changegamer.ai/articles/credential-propagation-across-agent-hops",
        "markdown": "https://changegamer.ai/articles/credential-propagation-across-agent-hops.md",
        "json": "https://changegamer.ai/api/articles/credential-propagation-across-agent-hops.json"
      },
      {
        "slug": "trusting-a-remote-agent",
        "title": "How to Verify a Remote A2A Agent Before Delegating",
        "description": "What a signed Agent Card proves and does not, how domain, key and ERC-8004 identity differ, where Web Bot Auth fits, and why card text and returned artifacts are untrusted input, ending in an ordered checklist.",
        "kind": "sub",
        "order": 7,
        "html": "https://changegamer.ai/articles/trusting-a-remote-agent",
        "markdown": "https://changegamer.ai/articles/trusting-a-remote-agent.md",
        "json": "https://changegamer.ai/api/articles/trusting-a-remote-agent.json"
      },
      {
        "slug": "a2a-agent-discovery-without-a-registry",
        "title": "How Do Agents Discover A2A Agents Without a Standard Registry?",
        "description": "The three discovery strategies in the A2A documentation, why the spec prescribes no registry API, what vendor registries fill the gap, and how to choose between a well-known URI, a registry and direct configuration.",
        "kind": "sub",
        "order": 8,
        "html": "https://changegamer.ai/articles/a2a-agent-discovery-without-a-registry",
        "markdown": "https://changegamer.ai/articles/a2a-agent-discovery-without-a-registry.md",
        "json": "https://changegamer.ai/api/articles/a2a-agent-discovery-without-a-registry.json"
      },
      {
        "slug": "a2a-v0-3-to-v1-0-migration",
        "title": "Migrate A2A v0.3 to v1.0: An Ordered Checklist for Clients and Servers",
        "description": "An ordered checklist for moving an A2A client or server from v0.3 to v1.0: the A2A-Version header rule, method names, Part shape, a runnable grep check, and symptom-to-cause pointers.",
        "kind": "sub",
        "order": 9,
        "html": "https://changegamer.ai/articles/a2a-v0-3-to-v1-0-migration",
        "markdown": "https://changegamer.ai/articles/a2a-v0-3-to-v1-0-migration.md",
        "json": "https://changegamer.ai/api/articles/a2a-v0-3-to-v1-0-migration.json"
      },
      {
        "slug": "agent-frameworks-with-a2a-support",
        "title": "Does Your Agent Framework Really Support A2A? How to Read the Claim and What to Test",
        "description": "Which agent frameworks list A2A support, what native, add-on, platform-gated and unrecorded mean, a short test checklist to run before you rely on it, and how that differs from the protocol's own SDKs.",
        "kind": "sub",
        "order": 10,
        "html": "https://changegamer.ai/articles/agent-frameworks-with-a2a-support",
        "markdown": "https://changegamer.ai/articles/agent-frameworks-with-a2a-support.md",
        "json": "https://changegamer.ai/api/articles/agent-frameworks-with-a2a-support.json"
      },
      {
        "slug": "failure-handling-across-agent-boundaries",
        "title": "Failed or Rejected Remote A2A Task: Retry, Degrade or Surface?",
        "description": "How to decide what happens after a remote A2A task ends badly: the side-effects test that splits failed into retry or surface, why rejected is not a retry case, why input-required is not a failure, and a structured result for the caller.",
        "kind": "sub",
        "order": 11,
        "html": "https://changegamer.ai/articles/failure-handling-across-agent-boundaries",
        "markdown": "https://changegamer.ai/articles/failure-handling-across-agent-boundaries.md",
        "json": "https://changegamer.ai/api/articles/failure-handling-across-agent-boundaries.json"
      },
      {
        "slug": "a2a-production-launch-checklist",
        "title": "A2A Production Launch Checklist: Gates to Pass Before You Ship",
        "description": "A go/no-go checklist for launching A2A agent-to-agent delegation, one line per gate, each pointing to the article that owns the detail: need, card, states, binding, auth, trust, versioning, failure.",
        "kind": "sub",
        "order": 12,
        "html": "https://changegamer.ai/articles/a2a-production-launch-checklist",
        "markdown": "https://changegamer.ai/articles/a2a-production-launch-checklist.md",
        "json": "https://changegamer.ai/api/articles/a2a-production-launch-checklist.json"
      }
    ]
  },
  "navigation": {
    "pillar": {
      "slug": "a2a-protocol-in-practice",
      "title": "The A2A Protocol in Practice: Agent Cards, Tasks, Auth and When You Need It",
      "description": "A practical guide to the A2A (Agent2Agent) protocol: what it standardizes, when it beats in-process subagents, how Agent Cards, task states, bindings and authentication work, how credentials cross agent hops, and how to launch it.",
      "kind": "pillar",
      "order": 0,
      "html": "https://changegamer.ai/articles/a2a-protocol-in-practice",
      "markdown": "https://changegamer.ai/articles/a2a-protocol-in-practice.md",
      "json": "https://changegamer.ai/api/articles/a2a-protocol-in-practice.json"
    },
    "previous": {
      "slug": "a2a-authentication-schemes",
      "title": "A2A Authentication Schemes: Which to Declare in Your Agent Card",
      "description": "The five security scheme families an A2A Agent Card can declare (API key, HTTP auth, OAuth 2.0, OpenID Connect, mutual TLS), an inference-labelled rule for choosing one, and how a client handles auth-required tasks.",
      "kind": "sub",
      "order": 5,
      "html": "https://changegamer.ai/articles/a2a-authentication-schemes",
      "markdown": "https://changegamer.ai/articles/a2a-authentication-schemes.md",
      "json": "https://changegamer.ai/api/articles/a2a-authentication-schemes.json"
    },
    "next": {
      "slug": "trusting-a-remote-agent",
      "title": "How to Verify a Remote A2A Agent Before Delegating",
      "description": "What a signed Agent Card proves and does not, how domain, key and ERC-8004 identity differ, where Web Bot Auth fits, and why card text and returned artifacts are untrusted input, ending in an ordered checklist.",
      "kind": "sub",
      "order": 7,
      "html": "https://changegamer.ai/articles/trusting-a-remote-agent",
      "markdown": "https://changegamer.ai/articles/trusting-a-remote-agent.md",
      "json": "https://changegamer.ai/api/articles/trusting-a-remote-agent.json"
    }
  },
  "resources": [
    {
      "slug": "agent-delegation-chains",
      "html": "https://changegamer.ai/resources/agent-delegation-chains",
      "markdown": "https://changegamer.ai/resources/agent-delegation-chains.md",
      "json": "https://changegamer.ai/api/resources/agent-delegation-chains.json"
    },
    {
      "slug": "agent-identity-authentication",
      "html": "https://changegamer.ai/resources/agent-identity-authentication",
      "markdown": "https://changegamer.ai/resources/agent-identity-authentication.md",
      "json": "https://changegamer.ai/api/resources/agent-identity-authentication.json"
    },
    {
      "slug": "a2a-protocol",
      "html": "https://changegamer.ai/resources/a2a-protocol",
      "markdown": "https://changegamer.ai/resources/a2a-protocol.md",
      "json": "https://changegamer.ai/api/resources/a2a-protocol.json"
    }
  ]
}