Skip to content
Technology/Agent2Agent Protocol

Agent2Agent Protocol

Exec x AI is A2A-ready. Talk to us agent-to-agent.

Exec x AI has implemented the Google Agent2Agent (A2A) open protocol. Any AI agent, orchestrator, or agentic platform can now discover Exec x AI's capabilities, query our knowledge, and integrate our expertise directly into multi-agent workflows — without a single line of custom integration code.

Declared skills

What Exec x AI's agent knows

Exec x AI's agent card declares five skills — hover over each card to learn about that area and connect directly with a Principal AI Consultant.

ai-strategy-advisory

AI Strategy Advisory

ai-strategyenterprise-airoadmapoperating-model

Example queries

What AI use cases should a pharmaceutical company prioritise?

How does Exec x AI structure an AI operating model?

Hover to learn more

AI Strategy Advisory

Exec x AI helps boards and executive teams build enterprise AI roadmaps grounded in business value — not technology for its own sake. We run structured use case prioritisation workshops, design AI operating models, and deliver proof of concepts in 30 days. Every engagement is cloud-agnostic (AWS, Azure, GCP) and model-agnostic.

ai-governance-compliance

AI Governance & Compliance

ai-governanceeu-ai-actiso-42001responsible-ai

Example queries

How do I comply with the EU AI Act?

What does a Responsible AI Office look like?

Hover to learn more

AI Governance & Compliance

Exec x AI designs AI governance frameworks aligned to the EU AI Act, ISO 42001, and sector-specific obligations. We build the structures that give boards visibility into AI risk, establish human oversight protocols, and produce the conformity documentation required for high-risk AI systems. Founded on the Asilomar AI Principles.

industry-use-cases

Industry AI Use Cases

use-casespharmaoil-gasagriculturemanufacturing

Example queries

What AI use cases are relevant for upstream oil and gas?

What ROI has been achieved from AI in heavy industry?

Hover to learn more

Industry AI Use Cases

Exec x AI serves seven industries — pharmaceuticals, upstream oil & gas, agriculture, heavy industry & mining, life sciences & biotech, power generation & manufacturing, and soft drinks & FMCG. Each industry page includes AI use cases with real AWS, Azure, and GCP ROI data from named enterprise deployments.

services-enquiry

Services & Engagement Enquiry

servicesenquiryengagementconsultingbook-call

Example queries

How does Exec x AI structure an engagement?

How do I book a discovery call with Exec x AI?

Hover to learn more

Services & Engagement Enquiry

Exec x AI engagements begin with a discovery call and rapid assessment. We deliver proof of concept in 30 days and measurable ROI in 12–18 weeks. All engagements are fixed-scope with clear deliverables. Exec x AI does not provide software development or managed infrastructure — we advise, govern, and oversee.

careers-information

Careers Information

careersjobshiringremoteai-relations

Example queries

What roles are open at Exec x AI?

Is Exec x AI hiring in the MENA region?

Hover to learn more

Careers Information

Exec x AI is a remote-first, internationally distributed team. Current open roles include AI Relations Managers across Europe, MENA, Africa, ANZ, and Central & Eastern Europe, and Regional Sales Directors in multiple regions. Use the compensation calculator to explore indicative package ranges before applying.

A2A v0.3

Protocol

JSON-RPC 2.0

Binding

None required

Auth

5 declared

Skills

What is A2A?

The open standard for agent-to-agent communication

Agent2Agent (A2A) is an open interoperability protocol developed by Google and supported by over 50 technology partners — including Salesforce, SAP, ServiceNow, Deloitte, and Accenture. It defines a standard way for AI agents to discover each other, communicate, and collaborate across organisational and platform boundaries.

Where MCP (Model Context Protocol) defines how agents connect to tools and data sources, A2A defines how agents connect to other agents — enabling true multi-agent architectures at enterprise scale.

Read the A2A specification on GitHub

Open protocol

Apache 2.0 licensed. No vendor lock-in. Any platform or framework can implement it.

Agent card discovery

Agents publish a machine-readable card at /.well-known/agent-card.json declaring their capabilities, skills, and endpoint.

JSON-RPC 2.0 transport

All communication uses the widely-supported JSON-RPC 2.0 standard over standard HTTPS — no special networking required.

Opaque agent compatibility

A2A is designed to work across opaque agent boundaries — one agent need not know the internal architecture of another.

Multi-agent pipelines

Agents can be composed into larger workflows — a procurement agent might query Exec x AI's governance agent as one step in a complex chain.

How it works

Three steps from discovery to response

The full A2A interaction lifecycle between an external agent and Exec x AI's endpoint — from automatic discovery through to a structured, machine-readable response

01
Discovery

Agent card discovery via /.well-known/

An external AI agent or orchestrator sends a GET request to https://www.execxai.com/.well-known/agent-card.json. The response is a machine-readable JSON document that declares Exec x AI's agent name, description, version, capabilities, and the five available skills — allowing the calling agent to understand exactly what it can ask.

02
Message

Send a message via JSON-RPC 2.0

The calling agent posts a JSON-RPC 2.0 SendMessage payload to the declared endpoint. The message contains a contextId (for multi-turn tracking) and one or more text parts — the natural-language query directed at Exec x AI's agent.

03
Response

Receive a structured agent response

Exec x AI's agent returns a JSON-RPC 2.0 result containing a message object. The message carries a unique messageId, the same contextId (for session continuity), and text parts with a substantive response about Exec x AI's capabilities, links, and recommended next steps.

Architecture overview

External AI Agent

LangGraph / CrewAI / custom

/.well-known/agent-card.json

GET — capability discovery

/a2a endpoint

POST — JSON-RPC 2.0 SendMessage

Exec x AI Agent

5 skills · text response

Integration guide

Connect to Exec x AI in four steps

No SDK. No API key. No registration. The A2A protocol runs over standard HTTPS — if your agent can make an HTTP request, it can talk to Exec x AI.

1

Fetch the agent card

curl -s https://www.execxai.com/.well-known/agent-card.json | jq .

Returns the full agent card. Inspect skills[], supportedInterfaces[], and capabilities before calling.

2

Send your first message (curl)

curl -X POST https://www.execxai.com/a2a \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": "1",
    "method": "SendMessage",
    "params": {
      "message": {
        "contextId": "test-session",
        "parts": [{ "kind": "text", "text": "What is Exec x AI?" }]
      }
    }
  }'

You will receive a JSON-RPC 2.0 result with a message object containing the agent's response.

3

Python integration

import httpx, uuid

response = httpx.post(
  "https://www.execxai.com/a2a",
  json={
    "jsonrpc": "2.0",
    "id": "req-1",
    "method": "SendMessage",
    "params": {
      "message": {
        "contextId": str(uuid.uuid4()),
        "parts": [{
          "kind": "text",
          "text": "What AI governance services does Exec x AI offer?"
        }]
      }
    }
  }
)

result = response.json()
text = result["result"]["message"]["parts"][0]["text"]
print(text)

No SDK required. Standard HTTP POST with JSON-RPC 2.0. Works with any HTTP client.

4

TypeScript / Node.js integration

const response = await fetch("https://www.execxai.com/a2a", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: "req-1",
    method: "SendMessage",
    params: {
      message: {
        contextId: crypto.randomUUID(),
        parts: [{ kind: "text", text: "Tell me about Exec x AI's AI strategy services" }]
      }
    }
  })
});

const { result } = await response.json();
const text = result.message.parts[0].text;
console.log(text);

Works in the browser (CORS-enabled), Node.js, Deno, and Bun. No API key required.

Request reference

Full request and response examples

Every interaction follows the JSON-RPC 2.0 specification. The schemas below are definitive — copy and adapt them directly.

01
Discovery

Agent card discovery via /.well-known/

An external AI agent or orchestrator sends a GET request to https://www.execxai.com/.well-known/agent-card.json. The response is a machine-readable JSON document that declares Exec x AI's agent name, description, version, capabilities, and the five available skills — allowing the calling agent to understand exactly what it can ask.

GET https://www.execxai.com/.well-known/agent-card.json

# Response (200 OK):
{
  "name": "Exec x AI Enterprise AI Consulting Agent",
  "version": "1.0.0",
  "supportedInterfaces": [
    {
      "url": "https://www.execxai.com/a2a",
      "protocolBinding": "JSONRPC",
      "protocolVersion": "0.3"
    }
  ],
  "skills": [
    { "id": "ai-strategy-advisory", ... },
    { "id": "ai-governance-compliance", ... },
    { "id": "industry-use-cases", ... },
    { "id": "services-enquiry", ... },
    { "id": "careers-information", ... }
  ]
}
02
Message

Send a message via JSON-RPC 2.0

The calling agent posts a JSON-RPC 2.0 SendMessage payload to the declared endpoint. The message contains a contextId (for multi-turn tracking) and one or more text parts — the natural-language query directed at Exec x AI's agent.

POST https://www.execxai.com/a2a
Content-Type: application/json

{
  "jsonrpc": "2.0",
  "id": "req-001",
  "method": "SendMessage",
  "params": {
    "message": {
      "contextId": "session-abc-123",
      "parts": [
        {
          "kind": "text",
          "text": "What AI governance frameworks does Exec x AI implement for pharmaceutical companies?"
        }
      ]
    }
  }
}
03
Response

Receive a structured agent response

Exec x AI's agent returns a JSON-RPC 2.0 result containing a message object. The message carries a unique messageId, the same contextId (for session continuity), and text parts with a substantive response about Exec x AI's capabilities, links, and recommended next steps.

HTTP/1.1 200 OK
Content-Type: application/json

{
  "jsonrpc": "2.0",
  "id": "req-001",
  "result": {
    "message": {
      "kind": "message",
      "messageId": "msg-7f3a-...",
      "role": "agent",
      "contextId": "session-abc-123",
      "parts": [
        {
          "kind": "text",
          "text": "Exec x AI provides AI governance framework design, EU AI Act compliance readiness, ISO 42001 alignment, and Responsible AI Office buildout. The firm is founded on the Asilomar AI Principles and deploys human-in-the-loop controls and audit trails into every AI workflow. Learn more: https://www.execxai.com/services/ai-governance"
        }
      ]
    }
  }
}

Why this matters

Why Exec x AI implemented A2A

The agentic web is being built now. Organisations that publish machine-readable interfaces today will be natively integrated into the AI pipelines of tomorrow.

Agentic interoperability

Any A2A-compatible AI agent or orchestration platform can discover, query, and interact with Exec x AI's agent card without custom integration work.

Multi-agent orchestration

Exec x AI's agent can be composed into multi-agent pipelines — for example, a procurement AI querying Exec x AI for governance advice as part of a larger workflow.

Standards-based trust

A2A uses JSON-RPC 2.0 over HTTPS. No proprietary SDKs, no vendor lock-in. Any platform implementing the open spec can connect.

Zero-integration discovery

AI systems automatically discover Exec x AI's capabilities via the agent card at /.well-known/agent-card.json — no manual registration required.

Public and unauthenticated

The agent card and JSON-RPC endpoint are fully public, CORS-enabled, and require no API keys. Any authorised AI agent can connect immediately.

Five declared skills

Exec x AI's agent exposes five queryable skills: AI strategy, AI governance, industry use cases, services enquiry, and careers information.

Use cases

Real-world integration scenarios

Exec x AI's A2A endpoint is already accessible to any agent platform that implements the open standard. Here are four scenarios where agentic organisations can benefit immediately.

Multi-agent AI orchestrator

A LangGraph or CrewAI orchestration pipeline needs to route user queries about enterprise AI governance to a domain expert. It discovers Exec x AI's agent card, sends a SendMessage, and returns Exec x AI's response inline — no human intervention required.

AI procurement intelligence agent

A procurement AI evaluating AI consulting vendors automatically queries Exec x AI's agent for service scope, engagement model, and industry coverage — populating a vendor comparison matrix without manual research.

Enterprise knowledge graph

An enterprise knowledge graph enrichment agent crawls A2A-compatible service providers and ingests their agent cards to build a structured directory of AI services available to the business.

AI assistant augmentation

A corporate AI assistant surfaces Exec x AI's expertise when employees ask governance or strategy questions — by calling Exec x AI's A2A endpoint as a tool and injecting the response into its answer.

Endpoints

GET/.well-known/agent-card.json

Agent card — capability discovery. Returns the full agent card JSON.

Open
POST/a2a

JSON-RPC 2.0 endpoint. Method: SendMessage. No auth required.

GET/a2a

Endpoint documentation. Returns human-readable endpoint metadata.

Open

Ready to connect your AI agents to Exec x AI?

The A2A endpoint is live and publicly accessible. Your agent can query Exec x AI right now. If you are building agentic workflows and want to discuss how Exec x AI's governance and strategy expertise can be embedded into your AI architecture, speak to a Principal Consultant.

or

Technical questions? hello@execxai.com · View agent card · A2A spec on GitHub