The open protocol for other agents to query your knowledge base

Every BeforeQuery knowledge base publishes a public A2A AgentCard and accepts message/send calls. When another AI system — a customer's assistant, a partner's agent, an internal automation — needs your knowledge, it discovers your card and asks. No custom integration, no vendor lock-in, no plugin registry to petition.

Start FreeMCP Server

How A2A works

A public AgentCard for discovery, a message/send endpoint for interop — grounded in the same knowledge base as the widget, bots, and MCP

Public metadata, machine-readable

Discoverable AgentCard

  • GET /a2a/knowledge-bases/:kbId/agent-card returns the standard A2A card
  • Describes what your knowledge base answers, in what languages, with what limits
  • Public by design — the card is the discovery surface
  • Cards can be listed in A2A directories (agent registries)
  • Version-tagged so consumers know when the interface changes
One call, cited answer

message/send Endpoint

  • POST /a2a/knowledge-bases/:kbId accepts the standard A2A message/send envelope
  • Client-key authentication with revocable, scoped access
  • Returns cited answers with the same grounding as chat, MCP, or the widget
  • Streams available for long-form responses
  • Every call is a trace — same observability as the rest of the platform
Interop where MCP doesn't reach

Where A2A fits

  • Agent frameworks that don't ship an MCP client can call A2A directly
  • Partner integrations that shouldn't share your client-key can discover the card and negotiate access
  • Multi-agent workflows where your KB is one specialist among several
  • The @beforequery/agents SDK includes an A2A client for programmatic use
  • MCP and A2A live side-by-side — MCP for IDE / assistant integration, A2A for agent-to-agent flow
Why an open protocol beats a proprietary API

Your knowledge base as a citizen of the agent ecosystem

The AI ecosystem is moving from 'call my API' to 'discover my capability'. MCP standardises the assistant-inside-tool integration; A2A standardises the agent-to-agent flow. Publishing an A2A card means any compliant agent can find and query your knowledge base without a custom integration — the same way HTTP made every server findable without a proprietary protocol per website. It's the interop layer BeforeQuery bets on.

  • AgentCard is the discovery contract — public, machine-readable, versioned
  • message/send is the interaction contract — same schema across A2A-compatible agents
  • MCP endpoint (Cursor / Claude / ChatGPT) and A2A endpoint (agent-to-agent) coexist
  • @beforequery/agents SDK includes both clients
  • Traces record every A2A call — observable by design
What teams say

Deployed in production, cited by the buyers who chose it

“Deployed on our docs site in an afternoon. Every answer has citations, and the abstention gate means we've never had a customer complain about a made-up answer.”
PN
Priya Nair
Head of Customer Support · Supabase
“The knowledge base connected to our Slack, Confluence, and helpdesk in one setup. On-call teams get the same cited answer whether they ask in chat, in the widget, or from Cursor.”
TR
Tom Richter
IT Operations Manager · Grafana Labs
“The gap analytics turned into a real docs backlog. Deflection went up because we finally knew which pages were missing — the AI told us.”
AC
Ana Castillo
VP of Customer Experience · Clerk

Frequently Asked Questions

Common questions about A2A (Agent-to-Agent)

MCP (Model Context Protocol) is designed for assistants inside AI tools — Cursor, Claude Desktop, ChatGPT — to reach out for context. A2A (Agent-to-Agent) is designed for autonomous agents to discover and message each other. Both are open protocols; BeforeQuery ships endpoints for both, and they call into the same grounded-answer pipeline.
The standard A2A card: name, description, what the agent handles, supported languages, endpoint URLs, and any capability metadata a caller needs to negotiate a request. It's public — the card is how other agents discover you're callable at all.
message/send calls authenticate with client keys you issue in the dashboard. Keys are scoped per knowledge base, can enforce allowed source groups (narrow retrieval per key), and are revocable instantly. The AgentCard is public discovery; the endpoint is authenticated action.
No. Every knowledge base gets an A2A endpoint automatically at /a2a/knowledge-bases/:kbId, and the AgentCard is served from /a2a/knowledge-bases/:kbId/agent-card. Configure a key, publish the card URL, and other agents can find you.
The @beforequery/agents SDK includes an A2A client for programmatic use. The A2A protocol itself is designed to be framework-agnostic — any client that speaks the message/send envelope can call your endpoint. The ecosystem is early; MCP has more clients today.
Yes. They're complementary. The same knowledge base is reachable via /mcp/knowledge-bases/:kbId (for IDE/assistant integration) and /a2a/knowledge-bases/:kbId (for agent-to-agent flow). Traces log every call regardless of protocol.

Publish your knowledge base as an agent

Create a knowledge base, issue a client key, and share the AgentCard URL — any A2A-compatible agent can now discover and query your docs.

Get Started Free