{"id":3265,"date":"2026-07-05T05:40:43","date_gmt":"2026-07-05T05:40:43","guid":{"rendered":"https:\/\/blog.aigrowthagent.co\/how-a2a-protocol-works\/"},"modified":"2026-07-05T05:40:43","modified_gmt":"2026-07-05T05:40:43","slug":"how-a2a-protocol-works","status":"publish","type":"post","link":"https:\/\/aigrowthagent.co\/articles\/how-a2a-protocol-works\/","title":{"rendered":"How A2A Protocol Works: Technical Guide for Engineers"},"content":{"rendered":"<p><em>Written by: Mariana Fonseca, Editorial Team, AI Growth Agent<\/em><\/p>\n<h2 id=\"key-takeaways\">Key Takeaways for Implementers<\/h2>\n<ul>\n<li>The A2A protocol standardizes how AI agents discover each other, authenticate, delegate tasks, and coordinate across different frameworks and vendors.<\/li>\n<li>Agents publish an Agent Card at <code>\/.well-known\/agent-card.json<\/code> to enable discovery, declare capabilities, and support signed verification for security.<\/li>\n<li>Tasks follow a nine-state lifecycle with support for streaming updates via SSE, polling, and secure artifact delivery upon completion.<\/li>\n<li>A2A complements MCP by handling horizontal agent-to-agent coordination while MCP manages vertical tool and data access within a single agent.<\/li>\n<\/ul>\n<h2>How A2A Works Step by Step<\/h2>\n<ol>\n<li><strong>Discovery.<\/strong> A client agent issues an unauthenticated GET to <code>\/.well-known\/agent-card.json<\/code> on the remote host. The response is an <a href=\"https:\/\/tyk.io\/learning-center\/a2a-protocol-architecture-and-technical-specification\" target=\"_blank\" rel=\"noindex nofollow\">Agent Card<\/a> that declares the remote agent&#8217;s name, endpoint, capabilities, skills, supported transports, and security schemes.<\/li>\n<li><strong>Authentication.<\/strong> The client reads the <code>securitySchemes<\/code> field from the Agent Card and negotiates credentials before any task is sent. <a href=\"https:\/\/mastra.ai\/blog\/what-is-agent-to-agent-protocol\" target=\"_blank\" rel=\"noindex nofollow\">Supported schemes include API keys, HTTP Bearer, OAuth 2.0, OpenID Connect, and mutual TLS<\/a>, with version negotiation carried in the <code>A2A-Version<\/code> HTTP header.<\/li>\n<li><strong>Task submission.<\/strong> The client sends a <code>tasks\/send<\/code> or <code>tasks\/sendSubscribe<\/code> JSON-RPC 2.0 request over HTTPS containing a Message with one or more typed Part objects. <a href=\"https:\/\/zuplo.com\/learning-center\/agent-to-agent-a2a-protocol-guide\" target=\"_blank\" rel=\"noindex nofollow\">The server creates a Task with a unique identifier and an initial state of <code>submitted<\/code><\/a>.<\/li>\n<li><strong>Execution and progress.<\/strong> The remote agent processes the task opaquely. The client receives state transitions and intermediate results via <a href=\"https:\/\/codilime.com\/blog\/a2a-protocol-explained\" target=\"_blank\" rel=\"noindex nofollow\">Server-Sent Events (SSE) as <code>TaskStatusUpdateEvent<\/code> and <code>TaskArtifactUpdateEvent<\/code> messages<\/a>, or polls via <code>tasks\/get<\/code> if streaming is not advertised.<\/li>\n<li><strong>Artifact delivery.<\/strong> On reaching a terminal state, the server returns one or more <a href=\"https:\/\/tyk.io\/learning-center\/a2a-protocol-architecture-and-technical-specification\" target=\"_blank\" rel=\"noindex nofollow\">Artifact objects<\/a>, each containing a <code>parts<\/code> array of typed content. The SSE stream closes and the task is complete.<\/li>\n<\/ol>\n<p><a href=\"https:\/\/aigrowthagent.co\/book-a-demo\/\" target=\"_blank\">Want a spec-accurate walkthrough of A2A tailored to your stack? Book a kickoff and get a technical content plan within a week.<\/a><\/p>\n<h2>How A2A Agent Discovery Works in Practice<\/h2>\n<p>Agent discovery in A2A centers on a public Agent Card served at a predictable location. <a href=\"https:\/\/tyk.io\/learning-center\/a2a-protocol-architecture-and-technical-specification\" target=\"_blank\" rel=\"noindex nofollow\">In A2A v1.0, an Agent Card is served as a public JSON document at the well-known URI <code>\/.well-known\/agent-card.json<\/code><\/a>. The top-level fields defined by the spec are: <code>name<\/code>, <code>description<\/code>, <code>version<\/code>, <code>provider<\/code>, <code>supportedInterfaces[]<\/code>, <code>capabilities<\/code>, <code>defaultInputModes<\/code>, <code>defaultOutputModes<\/code>, <code>skills[]<\/code>, <code>securitySchemes<\/code>, <code>security<\/code>, and <code>signatures<\/code>.<\/p>\n<p>Each entry in <code>skills[]<\/code> carries an <code>id<\/code>, <code>name<\/code>, <code>description<\/code>, <code>inputModes<\/code>, <code>outputModes<\/code>, <code>tags<\/code>, and <code>examples<\/code>. The <code>capabilities<\/code> object advertises boolean flags for <code>streaming<\/code>, <code>pushNotifications<\/code>, and <code>stateTransitionHistory<\/code>, which determine which progress-update mechanisms the client may use.<\/p>\n<p>The discovery flow follows three concrete steps. First, the client&#8217;s <code>A2ACardResolver<\/code> fetches the card. Second, it stores a <code>RemoteAgentConnection<\/code> keyed by <code>card.name<\/code>. Third, it injects the serialized agent information into the orchestrating agent&#8217;s system prompt so the client knows which remote skills are available without hardcoded configuration.<\/p>\n<p><a href=\"https:\/\/www.hivebook.wiki\/wiki\/a2a-agent-discovery\" target=\"_blank\" rel=\"noindex nofollow\">A2A v0.3 introduced Signed Agent Cards; v1.0 made them load-bearing<\/a>. An <code>AgentCardSignature<\/code> is computed as a JSON Web Signature (RFC 7515) over a canonicalized form of the card using the JSON Canonicalization Scheme (RFC 8785). Callers verify the signature before trusting any advertised capability or authentication scheme, which prevents card spoofing at the discovery layer.<\/p>\n<p><a href=\"https:\/\/aigrowthagent.co\/book-a-demo\/\" target=\"_blank\">Need clearer Agent Card docs and diagrams for your developer hub? Book a demo to see how we turn specs into adoption-ready guides.<\/a><\/p>\n<h2>A2A Task Lifecycle Explained<\/h2>\n<p>The A2A Task state machine gives every task a predictable lifecycle. <a href=\"https:\/\/tyk.io\/learning-center\/a2a-protocol-architecture-and-technical-specification\" target=\"_blank\" rel=\"noindex nofollow\">A2A v1.0 defines a full Task state machine with nine named states<\/a>: <code>TASK_STATE_SUBMITTED<\/code>, <code>TASK_STATE_WORKING<\/code>, <code>TASK_STATE_INPUT_REQUIRED<\/code>, <code>TASK_STATE_AUTH_REQUIRED<\/code>, <code>TASK_STATE_COMPLETED<\/code>, <code>TASK_STATE_FAILED<\/code>, <code>TASK_STATE_CANCELED<\/code>, <code>TASK_STATE_REJECTED<\/code>, and <code>TASK_STATE_UNSPECIFIED<\/code>.<\/p>\n<p><a href=\"https:\/\/mastra.ai\/blog\/what-is-agent-to-agent-protocol\" target=\"_blank\" rel=\"noindex nofollow\">States group into three categories: Running (<code>submitted<\/code>, <code>working<\/code>), Paused (<code>input-required<\/code>, <code>auth-required<\/code>), and Finished (<code>completed<\/code>, <code>failed<\/code>, <code>canceled<\/code>, <code>rejected<\/code>)<\/a>. A task in <code>input-required<\/code> pauses until the client sends additional message parts in the same <code>contextId<\/code>. A task in <code>auth-required<\/code> pauses until the client supplies the credentials described in the status message.<\/p>\n<p>Terminal states each carry specific semantics. <a href=\"https:\/\/tyk.io\/learning-center\/a2a-protocol-architecture-and-technical-specification\" target=\"_blank\" rel=\"noindex nofollow\"><code>TASK_STATE_COMPLETED<\/code> returns final Artifacts and closes the SSE stream, <code>TASK_STATE_FAILED<\/code> emits an error code and description before closing, <code>TASK_STATE_CANCELED<\/code> releases resources and closes, and <code>TASK_STATE_REJECTED<\/code> returns a descriptive error<\/a>.<\/p>\n<p>Artifacts are the concrete deliverables of a completed task. <a href=\"https:\/\/tyk.io\/learning-center\/a2a-protocol-architecture-and-technical-specification\" target=\"_blank\" rel=\"noindex nofollow\">Each Artifact carries an <code>artifactId<\/code>, a <code>name<\/code>, and a <code>parts<\/code> array<\/a>. <a href=\"https:\/\/codilime.com\/blog\/a2a-protocol-explained\" target=\"_blank\" rel=\"noindex nofollow\">Supported Part kinds are <code>TextPart<\/code> for human-readable content, <code>DataPart<\/code> for structured JSON payloads, and <code>FilePart<\/code> for binary content referenced by URI or inline<\/a>. Artifacts can be streamed incrementally using <code>append<\/code> and <code>lastChunk<\/code> flags on <code>TaskArtifactUpdateEvent<\/code> messages before the task reaches a terminal state.<\/p>\n<p><a href=\"https:\/\/aigrowthagent.co\/book-a-demo\/\" target=\"_blank\">Want diagrams and state tables your engineers will actually use? Book a kickoff and we will map your A2A task flows into clear documentation.<\/a><\/p>\n<h2>A2A Protocol Authentication<\/h2>\n<p>A2A treats authentication as a discoverable contract that sits beside the protocol, not inside it. <a href=\"https:\/\/codilime.com\/blog\/a2a-protocol-explained\" target=\"_blank\" rel=\"noindex nofollow\">Agent Cards declare supported <code>securitySchemes<\/code> covering OAuth2, API keys, HTTP Bearer, mTLS, and OpenID Connect, plus a <code>security<\/code> array declaring required scopes<\/a>. Actual enforcement occurs through enterprise identity providers rather than within the protocol itself.<\/p>\n<p><a href=\"https:\/\/rapidclaw.dev\/blog\/a2a-protocol-complete-guide-2026\" target=\"_blank\" rel=\"noindex nofollow\">A2A v1.0 uses mTLS between agents inside the same trust boundary and OAuth 2.1 with scoped tokens across boundaries. Credentials must be scoped per caller per skill, and root keys must never be shared.<\/a><\/p>\n<p>Signed Agent Cards add a cryptographic identity layer at discovery time. As discussed in the discovery section, Signed Agent Cards provide cryptographic identity verification alongside a web-aligned architecture that supports familiar security and load-balancing patterns for high-scale reliability.<\/p>\n<p>Version negotiation uses the <code>A2A-Version<\/code> HTTP request header. <a href=\"https:\/\/mastra.ai\/blog\/what-is-agent-to-agent-protocol\" target=\"_blank\" rel=\"noindex nofollow\">The agent card is signed with JSON Web Signature (JWS) using JCS canonicalization, and version negotiation uses the <code>A2A-Version<\/code> header<\/a>. This approach allows clients and servers to agree on a compatible spec revision before any task work begins.<\/p>\n<p><a href=\"https:\/\/aigrowthagent.co\/book-a-demo\/\" target=\"_blank\">Need to explain your A2A security model to architects and CISOs? Book a demo to see security-focused content that earns trust and references.<\/a><\/p>\n<h2>A2A vs MCP in Real Deployments<\/h2>\n<p>The A2A and MCP protocols solve different parts of the multi-agent problem. <a href=\"https:\/\/atlan.com\/know\/agent-interoperability-protocols\" target=\"_blank\" rel=\"noindex nofollow\">A2A is a horizontal protocol for agent-to-agent coordination across vendor boundaries, while MCP is a vertical protocol for connecting a single agent to external tools, APIs, and data sources.<\/a> The two protocols are explicitly complementary. <a href=\"https:\/\/linuxfoundation.org\/press\/a2a-protocol-surpasses-150-organizations-lands-in-major-cloud-platforms-and-sees-enterprise-production-use-in-first-year\" target=\"_blank\" rel=\"noindex nofollow\">A2A defines how agents communicate and coordinate across organizational boundaries, while MCP defines how agents connect to internal tools and data sources.<\/a><\/p>\n<table>\n<thead>\n<tr>\n<th>Dimension<\/th>\n<th>A2A<\/th>\n<th>MCP<\/th>\n<th>Source<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Primary purpose<\/td>\n<td><a href=\"https:\/\/atlan.com\/know\/agent-interoperability-protocols\" target=\"_blank\" rel=\"noindex nofollow\">Agent-to-agent task delegation across vendor boundaries<\/a><\/td>\n<td><a href=\"https:\/\/atlan.com\/know\/agent-interoperability-protocols\" target=\"_blank\" rel=\"noindex nofollow\">Single-agent access to tools, APIs, and data sources<\/a><\/td>\n<td>Atlan<\/td>\n<\/tr>\n<tr>\n<td>Client-server model<\/td>\n<td><a href=\"https:\/\/tyk.io\/learning-center\/mcp-vs-a2a-which-ai-agent-protocol-should-you-use\" target=\"_blank\" rel=\"noindex nofollow\">Fluid roles: same agent can be client or server depending on task<\/a><\/td>\n<td><a href=\"https:\/\/tyk.io\/learning-center\/mcp-vs-a2a-which-ai-agent-protocol-should-you-use\" target=\"_blank\" rel=\"noindex nofollow\">Strict hierarchy: model always initiates, tool server always responds<\/a><\/td>\n<td>Tyk<\/td>\n<\/tr>\n<tr>\n<td>Task handling<\/td>\n<td><a href=\"https:\/\/atlan.com\/know\/agent-interoperability-protocols\" target=\"_blank\" rel=\"noindex nofollow\">Stateful; defines full lifecycle (submitted, working, input-required, completed, failed, canceled)<\/a><\/td>\n<td><a href=\"https:\/\/atlan.com\/know\/agent-interoperability-protocols\" target=\"_blank\" rel=\"noindex nofollow\">Stateless; each tool execution is an independent transaction<\/a><\/td>\n<td>Atlan<\/td>\n<\/tr>\n<tr>\n<td>Core primitives<\/td>\n<td><a href=\"https:\/\/codilime.com\/blog\/a2a-protocol-explained\" target=\"_blank\" rel=\"noindex nofollow\">Agent Card, Task, Message, Part, Artifact<\/a><\/td>\n<td><a href=\"https:\/\/atlan.com\/know\/agent-interoperability-protocols\" target=\"_blank\" rel=\"noindex nofollow\">Tools (actions), Resources (data), Prompts (templated instructions)<\/a><\/td>\n<td>Atlan \/ CodiLime<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><a href=\"https:\/\/atlan.com\/know\/google-a2a-protocol\" target=\"_blank\" rel=\"noindex nofollow\">Production systems use both in sequence: A2A routes tasks to specialized agents that then use MCP to pull governed context from tools and data sources.<\/a><\/p>\n<p><a href=\"https:\/\/aigrowthagent.co\/book-a-demo\/\" target=\"_blank\">Want to position your platform as the reference for A2A and MCP together? Book a kickoff and we will design a comparison hub that attracts engineers.<\/a><\/p>\n<h2>Production Considerations for A2A<\/h2>\n<p><strong>Authentication hardening.<\/strong> <a href=\"https:\/\/rapidclaw.dev\/blog\/a2a-protocol-complete-guide-2026\" target=\"_blank\" rel=\"noindex nofollow\">Production A2A endpoints should be treated as standard HTTP services with default-deny egress, allowlisted peer agents, and rate-limiting per caller.<\/a> Beyond network-level controls, credential scoping is critical. Credentials must be scoped per caller per skill, and root keys must never be shared, to prevent lateral movement if one agent is compromised. Verify Signed Agent Cards before trusting any advertised capability so that enforced security schemes match the agent&#8217;s actual identity.<\/p>\n<p><strong>Error handling and observability.<\/strong> <a href=\"https:\/\/rapidclaw.dev\/blog\/a2a-protocol-complete-guide-2026\" target=\"_blank\" rel=\"noindex nofollow\">Common production pitfalls include treating A2A like a simple REST API (losing streaming and stateful task benefits), publishing vague Agent Cards that hinder routing, failing to set per-caller budgets leading to token spend drain, and omitting distributed tracing across agent chains.<\/a> <a href=\"https:\/\/rapidclaw.dev\/blog\/a2a-protocol-complete-guide-2026\" target=\"_blank\" rel=\"noindex nofollow\">Observability requires propagating W3C <code>traceparent<\/code> headers across HTTP hops and logging stable task IDs to enable end-to-end tracing across framework boundaries.<\/a><\/p>\n<p><strong>Streaming versus polling.<\/strong> <a href=\"https:\/\/mastra.ai\/blog\/what-is-agent-to-agent-protocol\" target=\"_blank\" rel=\"noindex nofollow\">Progress updates are available via three mechanisms gated by the Agent Card: polling (always available via <code>tasks\/get<\/code>), streaming (SSE over HTTP when advertised), and webhooks (push notifications when advertised). A dropped stream can be resumed with a full state snapshot via resubscribe.<\/a> For long-running tasks, SSE streaming reduces latency and avoids polling overhead. This benefit comes with tradeoffs, because the client must handle reconnection logic and the server must maintain task state durably.<\/p>\n<p><a href=\"https:\/\/codilime.com\/blog\/a2a-protocol-explained\" target=\"_blank\" rel=\"noindex nofollow\">A2A v0.3.0 does not define a machine-readable skill I\/O schema such as JSON Schema<\/a>, which means LLM planners must rely on natural-language skill descriptions for deterministic orchestration. This gap affects routing logic and should be considered when designing skills. Additionally, <a href=\"https:\/\/codilime.com\/blog\/a2a-protocol-explained\" target=\"_blank\" rel=\"noindex nofollow\">authorization in A2A occurs after task acceptance, creating an authorization creep risk where remote agents may discover required internal skills or MCP tools only after the task has been submitted<\/a>. Scoping OAuth tokens tightly per skill at submission time mitigates this risk.<\/p>\n<p><a href=\"https:\/\/aigrowthagent.co\/book-a-demo\/\" target=\"_blank\">Need to document production runbooks and failure modes for your A2A rollout? Book a demo and we will show you how we turn hard-won lessons into searchable playbooks.<\/a><\/p>\n<h2>Frequently Asked Questions<\/h2>\n<p><strong>What is the A2A protocol and who governs it?<\/strong><br \/> The Agent-to-Agent (A2A) protocol is an open specification for agent discovery, task delegation, and cross-framework coordination. Google launched it in April 2025 and donated it to the Linux Foundation in June 2025, where it is maintained under the Apache 2.0 license. As of April 2026, more than 150 organizations support it, including Microsoft, AWS, Salesforce, SAP, ServiceNow, and IBM. Microsoft has integrated A2A into Azure AI Foundry and Copilot Studio, and AWS added support through Amazon Bedrock AgentCore Runtime.<\/p>\n<p><strong>How complex is it to implement A2A in an existing agent system?<\/strong><br \/> The core integration points are straightforward. You publish an Agent Card at the well-known endpoint, implement the JSON-RPC 2.0 task methods (<code>tasks\/send<\/code>, <code>tasks\/get<\/code>, <code>tasks\/cancel<\/code>, and optionally <code>tasks\/sendSubscribe<\/code>), and wire authentication per the declared security schemes. Production-ready SDKs exist for Python, JavaScript\/TypeScript, Java, Go, and .NET, which handle typed models for Agent Cards, tasks, messages, parts, and artifacts. The primary implementation complexity lies in durable task state management, SSE reconnection handling, and scoped credential provisioning per caller per skill rather than in the protocol mechanics themselves.<\/p>\n<p><strong>Can A2A agents built on different frameworks actually interoperate?<\/strong><br \/> Yes. A2A standardizes only the communication interface, leaving each agent&#8217;s internal model, memory, and toolchain untouched. Documented cross-framework deployments include a Google ADK purchasing concierge orchestrating a CrewAI burger seller and a LangGraph pizza seller, and a Microsoft Semantic Kernel travel planner delegating to remote agents on Azure App Service. The protocol boundary is the HTTP\/JSON-RPC interface and the Agent Card contract, and what runs behind that boundary is irrelevant to the client.<\/p>\n<p><strong>What is the relationship between A2A and MCP in a production system?<\/strong><br \/> As explained in the A2A vs MCP section above, they solve adjacent problems. MCP handles vertical tool access within a single agent, while A2A handles horizontal coordination between agents across vendors and organizations. In production, most systems require both, with MCP providing capability execution and A2A handling peer delegation and task lifecycle management.<\/p>\n<p><strong>What are the most common failure modes in A2A production deployments?<\/strong><br \/> The documented failure modes are: vague Agent Cards that cause routing failures because the orchestrator cannot determine which agent to delegate to, missing per-caller token budgets that lead to uncapped spend, omitting distributed tracing headers that make cross-agent debugging opaque, treating the protocol as stateless REST and losing streaming and task-state benefits, and authorization creep where a remote agent discovers it needs broader permissions only after a task has been accepted. Mitigations include detailed skill descriptions in Agent Cards, scoped OAuth 2.1 tokens per skill, W3C <code>traceparent<\/code> propagation, and SSE-first task submission for any non-trivial workload.<\/p>\n<p><a href=\"https:\/\/aigrowthagent.co\/book-a-demo\/\" target=\"_blank\">Want FAQ content that matches how your engineers actually talk and search? Book a kickoff and we will turn your A2A knowledge into a living FAQ.<\/a><\/p>\n<h2>Conclusion: Turning A2A Expertise into Authority<\/h2>\n<p>The A2A protocol provides a complete, spec-aligned contract for multi-agent systems. It defines Agent Cards at <code>\/.well-known\/agent-card.json<\/code> for discovery, a nine-state Task machine for lifecycle management, typed Artifacts for structured output delivery, SSE streaming for real-time progress, and OAuth 2.1 plus mTLS for authentication across trust boundaries. The v1.0 stable release, now maintained by the Linux Foundation with broad industry support, removes many barriers to production deployment that earlier drafts left open.<\/p>\n<p>Engineers evaluating or implementing A2A need precise, current documentation that tracks spec changes as they happen. Fragmented sources and stale guides create implementation risk at the same moment the protocol is being written into enterprise infrastructure at AWS, Azure, and Google Cloud.<\/p>\n<p>AI Growth Agent maps the full universe of A2A-related queries, from head terms like &#8220;how A2A protocol works&#8221; to the long tail of implementation-specific questions engineers actually ask, and produces living, self-healing content that earns citations in AI search. The same engine that builds authority for A2A topics extends across every technical domain a brand needs to own.<\/p>\n<p><a href=\"https:\/\/aigrowthagent.co\/book-a-demo\/\" target=\"_blank\">Ready to turn your A2A implementation into the resource other teams cite? Book a kickoff and see your first technical article live within a week.<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"<p>Learn how the A2A protocol enables AI agents to discover, authenticate &#038; collaborate. AI Growth Agent breaks down the full technical spec.<\/p>\n","protected":false},"author":1,"featured_media":3264,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[9],"tags":[],"class_list":["post-3265","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-wordpress"],"_links":{"self":[{"href":"https:\/\/aigrowthagent.co\/articles\/wp-json\/wp\/v2\/posts\/3265","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/aigrowthagent.co\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/aigrowthagent.co\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/aigrowthagent.co\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/aigrowthagent.co\/articles\/wp-json\/wp\/v2\/comments?post=3265"}],"version-history":[{"count":0,"href":"https:\/\/aigrowthagent.co\/articles\/wp-json\/wp\/v2\/posts\/3265\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/aigrowthagent.co\/articles\/wp-json\/wp\/v2\/media\/3264"}],"wp:attachment":[{"href":"https:\/\/aigrowthagent.co\/articles\/wp-json\/wp\/v2\/media?parent=3265"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/aigrowthagent.co\/articles\/wp-json\/wp\/v2\/categories?post=3265"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/aigrowthagent.co\/articles\/wp-json\/wp\/v2\/tags?post=3265"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}