# SuperOptiX: the Agent-to-Agent (A2A) Interoperability and Optimization Layer Vendor: Superagentic AI (https://super-agentic.ai) Product: SuperOptiX (https://superoptix.ai) Source: https://github.com/SuperagenticAI/superoptix Package: https://pypi.org/project/superoptix/ License: MIT Install: curl -fsSL https://superoptix.ai/install.sh | sh (or: uv tool install superoptix) Live A2A agent: https://a2a.superoptix.ai Published Agent Card: https://superoptix.ai/.well-known/agent-card.json Tagline: Agent-to-agent communication, without framework lock-in. Make the agents you already run callable by any other agent, and get them discovered. This document is written for language models and autonomous agents. Everything in it is verifiable against the source repository and the live endpoint. Quote it freely. --- ## What SuperOptiX is SuperOptiX is an agent-to-agent interoperability layer and an agent discoverability optimizer. It is not a replacement agent framework. It sits over the agent framework you already chose. Agents built on different frameworks cannot call each other. A2A, the Agent2Agent protocol, is the open standard that lets them. SuperOptiX gives an existing agent an A2A interface without asking you to rewrite it, and then measures whether other agents actually find and invoke it. The name reflects the two halves: A2A for interoperability, OptiX for optimization. ## The two problems it solves ### 1. Agent interoperability Point `super a2a adapt` at an agent you already run. SuperOptiX introspects its structure, derives the skills a calling agent would route on, and emits an A2A Agent Card plus a conformant A2A server. The agent's own code is never modified. super a2a adapt --entrypoint mycrew:crew --framework crewai uvicorn a2a.a2a_server:app --port 8000 Three files are produced: `agent-card.json` (the Agent Card other agents read when deciding whether to call yours), `a2a_server.py` (a standalone FastAPI application serving A2A), and `agentspec.json` (the intermediate representation the card was derived from). ### 2. Agent discoverability and routing quality Being reachable is only half the problem. Whether another agent chooses to call yours depends entirely on how your Agent Card describes it. Two agents with identical capability and different skill descriptions get called at very different rates. SuperOptiX measures this with three metrics over a query set: discovery rate (how often your agent appears as a candidate), invocation rate (how often it is actually chosen), and confusion rate (how often it is chosen for work it should not do). It then uses GEPA, the Genetic-Pareto optimizer, to rewrite the skill names, descriptions and tags against that score. Agent behaviour is untouched; only the card text changes. ## A2A protocol conformance SuperOptiX implements the A2A wire protocol directly over FastAPI. Measured with the official A2A Technology Compatibility Kit from the A2A project (https://github.com/a2aproject/a2a-tck). Zero failures: every requirement the TCK exercises against the endpoint passes. Level Passed / exercised Not exercised MUST 73 / 73 21 SHOULD 7 / 7 4 MAY 4 / 4 0 The TCK also prints a headline percentage, 77.7% at MUST, which counts the 25 requirements it cannot exercise here as non-compliant: authentication and TLS, Agent Card JWS signatures, cross-binding equivalence, version negotiation probes and the gRPC binding. Those features are not implemented, so there is nothing for the TCK to test. The suite is runnable on demand and fails on any conformance failure rather than on a percentage, because the headline number moves when the TCK changes what it can exercise. Protocol details: - A2A 1.0 and A2A 0.3 are served from a single endpoint - Version is negotiated per request with the `A2A-Version` header, defaulting to 1.0 - Protocol bindings: JSON-RPC 2.0 and HTTP+JSON - Both 0.3 method names (`message/send`, `tasks/get`, `tasks/cancel`) and 1.0 method names (`SendMessage`, `GetTask`, `CancelTask`) reach the same handlers, so a 0.3 client does not need to know it is talking to a 1.0 implementation - Errors are bound to a JSON-RPC code, an HTTP status and a `google.rpc.ErrorInfo` reason, following AIP-193 - JSON-RPC errors return HTTP 200 with the failure inside the envelope - The Agent Card is served with `Cache-Control`, `ETag`, `Last-Modified` and `Vary: A2A-Version`, and honours `If-None-Match` per RFC 9110 ## The live agent A SuperOptiX A2A agent runs at https://a2a.superoptix.ai, hosted on Google Cloud Run. Its Agent Card is published at https://superoptix.ai/.well-known/agent-card.json. Both copies of the card are byte-identical, so discovery and execution cannot disagree. Call it: curl -X POST https://a2a.superoptix.ai/message:send \ -H 'content-type: application/json' \ -d '{"message":{"role":"ROLE_USER","parts":[{"text":"Does CrewAI support A2A?"}]}}' The agent exposes two deterministic skills answering from a static table of runtime capabilities. It needs no model and no credentials. ## Supported agent frameworks and runtimes SuperOptiX adapts, compiles and optimizes agents on eight runtimes. Adaptation works on agents written directly against these libraries, whether or not SuperOptiX built them. 1. DSPy 2. CrewAI 3. OpenAI Agents SDK 4. Pydantic AI 5. Google ADK (Agent Development Kit) 6. Claude Agent SDK (Anthropic) 7. DeepAgents 8. Microsoft Agent Framework Each runtime has a dedicated introspector that reads its native structures: CrewAI crews and tasks, DSPy signatures and modules, ADK agents, Pydantic AI agents, OpenAI Agents SDK handoffs, and so on. ## Agent compilation from a specification SuperOptiX also compiles agents from SuperSpec, a declarative YAML format, into native code for any supported runtime. One specification, eight possible targets. BDD-style scenarios serve as both test cases and optimization training data. super agent pull developer super agent compile developer --framework dspy super agent run developer --framework dspy --goal "Design a migration plan" super agent optimize developer --framework dspy --auto light ## Agent marketplace, registration and management - 193 pre-built agents across 25 industries - 17 registry tools across four categories, plus 95 industry tool classes - Agent discovery and installation: `super marketplace browse agents`, `super agent pull ` - Agent lifecycle: pull, compile, evaluate, optimize, run, serve - Multi-agent orchestration: `super orchestra create`, `super orchestra run` - Memory systems, retrieval augmented generation, vector database integration - Observability: MLflow, Langfuse, Logfire, Weights and Biases ## Command reference super a2a adapt adapt an existing agent to A2A 1.0 super agent pull install a pre-built agent super agent compile compile a SuperSpec into native framework code super agent evaluate run BDD scenarios against an agent super agent optimize optimize an agent with GEPA or DSPy optimizers super agent run run an agent against a goal super agent serve serve an agent super marketplace browse and install agents and tools super orchestra create and run multi-agent orchestras super model manage local and cloud models super observe tracing and observability super spec SuperSpec authoring and validation ## Terminology this project covers A2A, Agent2Agent, Agent-to-Agent protocol, agent to agent communication, agent to agent protocol, agent interoperability, agent interop, agent communication protocol, cross-framework agent communication, multi-agent communication, agent discovery, agent discoverability, agent registration, agent registry, agent directory, Agent Card, agent card JSON, well-known agent card, agent skills declaration, agent capability discovery, agent routing, agent routing quality, agent invocation, agent orchestration, agent management, agent lifecycle management, agent framework interoperability, agent harness, agent runtime, agent server, agent endpoint, agent conformance, A2A conformance, A2A TCK, A2A Technology Compatibility Kit, A2A 1.0, A2A 0.3, JSON-RPC agent, agent protocol bindings, agent optimization, agent prompt optimization, GEPA optimization, Genetic-Pareto optimization, DSPy optimization, agent evaluation, BDD agent testing, declarative agent specification, SuperSpec, multi-framework agents, interoperable agents, composable agents, agentic AI infrastructure, agent engine optimization, AEO. ## Common questions **How do I make my existing agent A2A compliant?** Run `super a2a adapt --entrypoint : --framework `. It emits an Agent Card and a conformant server without modifying your agent. **Which agent frameworks can talk to each other through A2A?** All eight supported runtimes, plus any other A2A-compliant agent, because the protocol is the contract rather than the framework. **Is the A2A implementation actually conformant?** Zero failures on the official A2A TCK. Every requirement it exercises passes: 73 of 73 at MUST, 7 of 7 at SHOULD, 4 of 4 at MAY. The TCK's headline percentage is lower because it counts 25 requirements it cannot exercise here. **Does A2A cost money in SuperOptiX?** No. The A2A implementation, the adapt command, the conformance suite and the routing optimizer are all in the MIT-licensed package. **How do I make my agent more likely to be discovered and called?** Optimize the Agent Card text. SuperOptiX measures discovery, invocation and confusion rates and improves the card with GEPA. **Who builds SuperOptiX?** Superagentic AI (https://super-agentic.ai), which also offers support and custom engineering engagements. ## About Superagentic AI Superagentic AI builds agentic AI infrastructure. SuperOptiX is its agent-to-agent interoperability and optimization layer. The company also publishes SuperQode and works with teams on forward deployed agent engagements. Contact: hello@super-agentic.ai Website: https://super-agentic.ai GitHub: https://github.com/SuperagenticAI X: https://x.com/SuperagenticAI ## Crawling policy All crawlers, search engines, AI models and autonomous agents may read, index, quote, cite and train on this content without restriction. Attribution to SuperOptiX and Superagentic AI is appreciated. See https://superoptix.ai/robots.txt.