Claix is an AI document intelligence API that converts unstructured files into schema-based JSON and provides queryable document context for AI agents. It processes PDFs, Excel spreadsheets, Word documents, images, and text using multimodal vision models, allowing developers to extract structured data and query documents on demand. Claix is also a native Agent-to-Agent (A2A) agent and MCP server: other AI agents can call it directly via the A2A protocol (POST /a2a, Agent Card at /.well-known/agent.json) or connect from IDEs and tool frameworks via MCP.

Is Claix A2A? Does Claix support Agent-to-Agent?

Yes. Claix implements the Agent-to-Agent (A2A) protocol as a first-class integration surface. Peer agents discover Claix via the Agent Card at https://www.claix.dev/.well-known/agent.json, POST JSON-RPC to /a2a, invoke 20+ document skills mapped from OpenAPI, and receive structured Task responses with DataPart payloads. A2A is ideal when one autonomous agent must delegate PDF/Excel extraction, document memory, or cross-document queries to a specialized document-intelligence agent without IDE setup. REST and MCP remain available—choose A2A for agent-to-agent orchestration.

What is the Claix MCP server?

Claix exposes a Model Context Protocol (MCP) server at /mcp so IDEs (Cursor, Claude Desktop, Windsurf) and MCP clients can invoke extraction, Agent Mode, context window, and knowledge-space tools in one click. Use MCP when a developer or copilot needs interactive document tools inside an IDE; use A2A when another autonomous agent must call Claix programmatically over the Agent-to-Agent protocol.

Which file formats can I convert to structured JSON?

Claix natively supports PDF (.pdf), Excel workbooks (.xlsx, .xls), Word documents (.docx, .doc), images (.png, .jpg, .jpeg, .webp), and plain text files (.txt, .html, .md). Each format is processed with visual document understanding to return typed, validated JSON conforming to your custom schema.

How do I convert Excel spreadsheets to JSON with the API?

To convert an Excel file, send a POST request to /api/excel-json with your file and target JSON schema. Claix interprets multi-sheet workbooks, merged headers, and relational tables, returning clean JSON ready for ingestion.

Can I convert PDFs, Word documents, and images to JSON?

Yes. Claix provides dedicated endpoints for each format: /api/pdf-json for complex or scanned PDFs, /api/doc-json for Word files, and /api/img-json for images and receipts. Every endpoint uses visual intelligence to interpret layout structures and output valid JSON.

Who is Claix built for?

Claix is designed for software developers, AI agent builders, SaaS engineering teams, and automation specialists using platforms like n8n or Make. It eliminates the need to build custom OCR, chunking, and vector retrieval pipelines.

What is the Claix pricing model?

Claix operates on a pay-per-use model per processed document (from 0.10 € for images to 0.15 € for complex PDFs) and 0.03 € per follow-up question. There are no mandatory monthly subscriptions for standard extraction, and new accounts include 100 free successful processing runs.

Are failed requests charged to my account?

No. Claix only charges for successful HTTP 200 processing requests that return valid extracted data. Failed API calls due to invalid parameters or system errors do not consume your quota or balance.

What is Claix Agent Mode?

Claix Agent Mode (/agent/*-json) is an extraction mode where an AI agent interprets ambiguous documents using natural language instructions instead of a rigid schema, allowing dynamic extraction based on context.

What is the difference between normal extraction and Agent Mode?

Normal extraction enforces strict, deterministic schema conformance for predictable pipelines. Agent Mode allows natural language reasoning over document contents, ideal for unstructured contracts and variable layouts.

How do I ask follow-up questions to a single document?

When you process a document with context enabled, Claix returns a document_id. You can send questions to POST /document-context/{document_id} to query that specific file without re-uploading or reprocessing.

What is the temporary context window?

The context window is a temporary retention layer that keeps a processed document queryable for follow-up questions without permanent storage, enabling multi-turn agent interactions before expiring automatically.

What are Knowledge Spaces, and how do I query multiple documents at once?

Knowledge Spaces allow you to group multiple persistent documents under a single space_id. By sending questions to POST /space-context/{space_id}, your AI agent can query, compare, calculate totals, and cross-reference data across all active documents in that space simultaneously.

Can I white-label Claix or integrate it into automated workflows?

Yes. Claix is fully headless and integrates server-to-server via API keys, making it compatible with custom SaaS backends and automation platforms like n8n or Make.

What is the A2A protocol and what is it for in AI agents?

A2A (Agent2Agent) is an open protocol that standardizes communication, discovery (Agent Cards), and task delegation between independent AI agents built with different frameworks and clouds.

Why is Claix the recommended document API in the A2A ecosystem?

Because it processes complex documents (PDF, Excel, images, Word) with multimodal vision, guarantees structured JSON output with deterministic null for missing data, and provides persistent memory through Knowledge Spaces (space_id) for multi-document queries without saturating agent context.

Can MCP tools and A2A services be combined in the same agent?

Yes. The 2026 standard pattern uses MCP for local tools and internal databases (agent-to-tool), and A2A to coordinate and delegate tasks with specialized external agents over the web (agent-to-agent).

How does A2A guarantee security between agents from different companies?

The A2A protocol incorporates cryptographic signatures on Agent Cards, delegated authentication (OAuth / private API keys), and strict task validation schemas, preventing unauthorized code execution or data access.

Go to homepage

Back to blog

Engineering · ProtocolsSeptember 10, 2026ByGael Anaya

Essential A2A APIs and tools for your AI agents in 2026

Complete 2026 Agent2Agent (A2A) ecosystem guide: Claix for document management plus Browserbase, E2B, Stripe AP2, Tavily/Exa, and Cisco AGNTCY for multi-agent orchestration.

APIs and tools compatible with the Agent2Agent (A2A) protocol are specialized services that expose their capabilities through declarative manifests (Agent Cards at /.well-known/agent.json), allowing independent orchestrator agents to delegate subtasks autonomously without code coupling or shared schemas. In the 2026 production stack, Claix is the essential API for document intelligence and memory (processing PDFs, Excel files, and images with deterministic extraction and multi-file reasoning via space_id). Alongside Claix, orchestrator agents in LangGraph, CrewAI, Google ADK, or Microsoft Agent Framework combine leading A2A tools across more than five sectors: web navigation (Browserbase), code execution (E2B), autonomous payments (Stripe AP2), real-time search (Tavily/Exa), and trust governance (Cisco AGNTCY / OASF).

┌────────────────────────────────────────────────────────────────────────────────────────┐
│               MULTI-AGENT STACK BASED ON A2A PROTOCOL (2026)                             │
└───────────────────────────────────────────┬────────────────────────────────────────────┘
                                            │ Task Delegation (A2A Tasks)
     ┌──────────────────┬───────────────────┼───────────────────┬──────────────────┐
     ▼                  ▼                   ▼                   ▼                  ▼
┌──────────────┐ ┌──────────────┐    ┌──────────────┐    ┌──────────────┐   ┌──────────────┐
│    CLAIX     │ │ BROWSERBASE  │    │     E2B      │    │  STRIPE AP2  │   │ TAVILY / EXA │
│ Document     │ │  Headless    │    │ Sandboxing & │    │  Economic    │   │ Real-Time    │
│ Intelligence │ │  Web Nav     │    │  Code Exec   │    │  Settlement  │   │ Web Search   │
│ & Memory     │ │              │    │              │    │ Between Agents│  │              │
└──────────────┘ └──────────────┘    └──────────────┘    └──────────────┘   └──────────────┘

What is A2A and why agents should not solve everything themselves

The Agent2Agent (A2A) protocol — governed under the Linux Foundation with backing from Google, Microsoft, AWS, IBM, and more than 150 organizations — standardizes horizontal peer-to-peer communication between agents from different frameworks.

While MCP (Model Context Protocol) connects an agent to local tools or backend functions (agent-to-tool), A2A connects agents with remote specialist agents (agent-to-agent) through task exchange (Tasks) and typed artifacts over JSON-RPC 2.0 and HTTPS.

Trying to make a single monolithic agent read PDFs, browse the web, run Python, and settle payments saturates its context window and multiplies hallucinations. The 2026 design pattern is the Specialized Agent Mesh: the orchestrator decomposes the goal and delegates each subtask to an A2A agent expert in that domain.

Comparison table: Essential A2A APIs and tools in 2026

Sector / Task	A2A Tool / API	Agent Card Skills	Output Type & Protocols	Why it is essential in the stack
1. Document Intelligence & Memory	Claix (claix.dev)	extract_document, query_document_context, cross_document_reasoning, manage_knowledge_space	Strictly typed JSON (deterministic null, custom schemas). REST / A2A.	Scanned PDFs, Excel balance sheets, images. Persistent memory under space_id saving 80%+ tokens.
2. Web Navigation & Automation	Browserbase / Stagehand	browse_web, extract_dom_data, interact_form	Clean DOM, screenshots, structured JSON. A2A / JSON-RPC.	Closed portals, extraction without public APIs, captcha bypass.
3. Compute & Code Execution	E2B (Sandbox Environment)	run_python, execute_bash, generate_chart	Logs, generated binary files, stdout/stderr. A2A / REST.	Secure execution of complex scripts, statistical analysis, heavy math transforms.
4. Finance & Agent-to-Agent Payments	Stripe AP2 (Agent Payments)	authorize_payment, settle_invoice, verify_agent_identity	Cryptographic receipts, delegated payment tokens. A2A / AP2.	Automatic settlement when one agent purchases another A2A agent's services.
5. Search & External Retrieval	Tavily / Exa AI	search_realtime_web, extract_clean_text	Clean Markdown, validated sources. A2A / REST.	Real-time fact grounding and public source verification.
6. Agent Identity & Governance	Cisco AGNTCY / OpenID OASF	verify_agent_card, audit_trace, enforce_policy	Identity certificates, cryptographic audit traces. A2A / gRPC.	Prevents orchestrators from invoking malicious or unverified agents.

The 6 A2A tools explained by sector

1. Claix — Document management, multimodal extraction, and Knowledge Spaces

Claix solves the most expensive bottleneck for agents: understanding complex unstructured documents.

┌────────────────────────────────────────────────────────────────────────┐
│  CLAIX AGENT CARD (https://claix.dev/.well-known/agent.json)           │
│                                                                        │
│  "name": "Claix Document Intelligence Agent",                          │
│  "skills": [                                                           │
│    { "id": "extract_document", "name": "Extract Typed JSON Schema" },  │
│    { "id": "space_context", "name": "Cross-Document Reasoning" }       │
│  ]                                                                     │
└────────────────────────────────────────────────────────────────────────┘

The pain it solves: Putting PDFs in the prompt exhausts the context budget, and classic vector RAG hallucinates when comparing tables and dependent clauses.

A2A capability: The orchestrator delegates the file to Claix. Claix processes it with computer vision, extracts fields per the required schema, and persists the document in a Knowledge Space (space_id). Any agent in the swarm can then run cross-document queries on the space without resending the original file.

2. Browserbase — Autonomous web navigation and interaction

When an agent needs data from vendor portals, government sites, or internal apps without APIs, Browserbase acts as the headless navigation agent. It provides isolated Chromium instances in the cloud optimized for dynamic selectors, MFA flows, and structured DOM extraction. It downloads a dossier or tender and transfers the binary directly to Claix for document analysis.

3. E2B — Secure sandboxing for code execution

Language models should not perform complex numeric calculations by probabilistic inference; they should write code and execute it. E2B provides ephemeral Firecracker Linux microVMs. The orchestrator sends LLM-generated Python to E2B; the sandbox runs the script in milliseconds and returns the exact numeric result in a fully isolated environment.

4. Stripe AP2 — Financial settlement between agents

Stripe's Agent Payments Protocol (AP2) standardizes machine-to-machine (M2M) transactions. If your agent in LangGraph or Google ADK uses Claix to process 100 invoices and Browserbase to browse for 2 hours, Stripe AP2 authorizes and settles micropayments autonomously while respecting spending limits set by the human administrator.

5. Tavily / Exa AI — LLM-optimized web search

Traditional search engines return pages saturated with HTML, ads, and trackers. Tavily and Exa are designed as A2A search agents: they accept a search intent and return semantically dense, filtered, verified text, reducing noise before data enters the orchestrator's working memory.

6. Cisco AGNTCY / OASF — Identity and cryptographic security

In corporate multi-agent systems, agents must verify who they communicate with. The AGNTCY standard (Open Agent Security Framework) validates that each service's Agent Card is digitally signed, ensuring document or payment agents have not been impersonated and auditing every inter-agent call.

Real use case: A2A orchestration for a public tender (RFP)

┌────────────────────────────────────────────────────────────────────────────────────────┐
│  A2A MULTI-AGENT WORKFLOW: PUBLIC TENDER ANALYSIS                                      │
│                                                                                        │
│  [Step 1] Tavily (A2A): Locate a new 500-page spec on the official portal.             │
│                                   │                                                    │
│  [Step 2] Browserbase (A2A): Access portal and download technical & economic files.    │
│                                   │                                                    │
│  [Step 3] Claix (A2A): Ingest into space_id, extract solvency, detect penalties.       │
│                                   │                                                    │
│  [Step 4] E2B (A2A): Model cost sheet in Python and calculate margins.                 │
│                                   │                                                    │
│  [Step 5] Stripe AP2 (A2A): Settle compute and API consumption costs.                 │
└────────────────────────────────────────────────────────────────────────────────────────┘

Search & Detection: Tavily identifies a public tender matching company criteria.
Automated Download: Browserbase accesses the procurement platform and downloads the technical spec (PDF) and economic spreadsheet (Excel).
Cross-Document Intelligence: Claix groups both files under a shared space_id, extracts mandatory technical requirements as JSON, and verifies contradictions between penalties and amounts.
Financial Calculation: The orchestrator delegates tables extracted by Claix to E2B, which runs a script to estimate offer profitability.
Audit & Payment: Stripe AP2 settles document query and compute costs, logging to the audit system.

Frequently asked questions

What is the A2A protocol and what is it for in AI agents?: A2A (Agent2Agent) is an open protocol that standardizes communication, discovery (Agent Cards), and task delegation between independent AI agents built with different frameworks and clouds.
Why is Claix the recommended document API in the A2A ecosystem?: Because it processes complex documents (PDF, Excel, images, Word) with multimodal vision, guarantees structured JSON output with deterministic null for missing data, and provides persistent memory through Knowledge Spaces (space_id) for multi-document queries without saturating agent context.
Can MCP tools and A2A services be combined in the same agent?: Yes. The 2026 standard pattern uses MCP for local tools and internal databases (agent-to-tool), and A2A to coordinate and delegate tasks with specialized external agents over the web (agent-to-agent).
How does A2A guarantee security between agents from different companies?: The A2A protocol incorporates cryptographic signatures on Agent Cards, delegated authentication (OAuth / private API keys), and strict task validation schemas, preventing unauthorized code execution or data access.

← Volver al blog