What is the A2A (Agent2Agent) protocol?

A2A is the open protocol that lets agents built on different frameworks call each other. Agents publish an Agent Card describing their skills, and other agents read that card to decide whether and how to invoke them.

How do I make my existing agent A2A compliant?

Run super a2a adapt --entrypoint : --framework . SuperOptiX reads your agent's structure, derives its skills, and writes an A2A Agent Card plus a conformant server. Your agent code is not modified.

Which agent frameworks does SuperOptiX support for A2A?

Eight: DSPy, CrewAI, the OpenAI Agents SDK, Pydantic AI, Google ADK, the Claude Agent SDK, DeepAgents and the Microsoft Agent Framework. Adaptation works on agents written directly against those libraries, whether or not SuperOptiX built them.

How conformant is the SuperOptiX A2A implementation?

It records zero failures against the official A2A Technology Compatibility Kit. Every requirement the TCK exercises against the conformance harness passes: 73 of 73 at MUST, 7 of 7 at SHOULD, 4 of 4 at MAY. The TCK also prints a headline percentage of 77.7% at MUST, which counts 25 requirements it cannot exercise here, covering authentication, TLS, Agent Card signing and gRPC.

How do I make my agent more discoverable to other agents?

Optimize the Agent Card text. SuperOptiX scores discovery rate, invocation rate and confusion rate over a query set, then uses GEPA to rewrite skill names, descriptions and tags against that score. Agent behaviour is unchanged.

Is SuperOptiX free and open source?

Yes, under the MIT License. The A2A implementation, the adapt command, the conformance suite, the routing optimizer, the SuperSpec compiler and all eight framework integrations are in the open source package. Install with uv tool install superoptix.

Is there a live A2A agent I can call?

Yes. A SuperOptiX agent runs at https://a2a.superoptix.ai on Google Cloud Run, with its Agent Card published at https://superoptix.ai/.well-known/agent-card.json.

Who builds SuperOptiX?

Superagentic AI, which builds agentic AI infrastructure and offers support and custom engineering engagements.

A2A · MCP · 8 FRAMEWORKS · ANY MODEL · OPEN SOURCEa2a.superoptix.ai

SuperOptiX

AGENT-TO-AGENT (A2A) INTEROPERABILITY AND QUALITY

OPTIMIZATIONLAYERfor teams that ship quality agents

Agent-to-agent communication, without framework lock-in. Improve the quality of the agents you already run, make them callable by any other agent, and get them discovered.

install

$curl -fsSL https://superoptix.ai/install.sh | sh

A2A Agents Build Agents Agent Quality

by Superagentic AI

Agent CardLive

"name": "SuperOptiX"

"protocolVersion": "1.0"

"preferredTransport": "JSONRPC"

"url": "https://a2a.superoptix.ai"

Skills

•Framework A2A Readiness
•Agent Card Review

A2A 1.0A2A 0.3HTTP+JSON

Call the live agent

Evaluation-first·Quality-gated·Optimization-core·Multi-agent orchestration

Eight frameworks, one specification

ADAPT · SERVE · MEASURE · OPTIMIZE

The Agent Building Factory

Once declared, automatic pipelines. Write once, compile everywhere, optimize every layer.

Declare Agent

Write your agent as a SuperSpec YAML specification. Define behavior, tools, and goals once.

Compile Across Frameworks

Generate native pipelines for DSPy, OpenAI, Claude SDK, CrewAI, Google ADK, Pydantic AI, DeepAgents, or Microsoft.

Evaluate and Record

Run the BDD specification, then write an Agent Quality Record stating what was measured, what the agent was permitted to do, and who accepted the result.

Optimize and Get Discovered

GEPA optimizes across prompts, RAG, memory and context. Measure how often other agents route to yours, then improve the Agent Card until they do.

You do context engineering.
SuperOptiX does agent engineering.

Super CLI Docs

A2A 1.0, zero TCK failures

Give an Agent You Already Run an A2A Interface

One command reads your agent, derives the skills a calling agent would route on, and writes an Agent Card and a conformant server. Your code is not modified.

Adapt an Existing Agent

Point super a2a adapt at an agent you already run. SuperOptiX reads its structure and writes an A2A 1.0 Agent Card and server. Your code is not modified.

A2A v1 Support

SuperOptiX now supports core A2A v1 interoperability so agents built with SuperOptiX can be exposed over A2A and can also call external A2A agents.

Explore A2A support

Verified Conformance

Zero failures against the official Technology Compatibility Kit, 73 of 73 MUST requirements exercised on the conformance harness. A live agent runs at a2a.superoptix.ai with its Agent Card published on this domain.

8 Framework Support

Native generation flows across DSPy, Pydantic AI, Google ADK, OpenAI Agents SDK, DeepAgents, CrewAI, Claude Agent SDK, and Microsoft Agent Framework.

DSPyOpenAIClaude SDKCrewAIGoogle ADKPydantic AIDeepAgentsMicrosoft

Minimal Pipelines

Generated pipelines across all supported frameworks are now significantly simpler. The default output is readable and runnable, without heavy runtime scaffolding.

Explicit Optimize Path

Optimization and evaluation logic now lives behind --optimize, so base pipelines stay focused and clean.

Quick Start

$curl -fsSL https://superoptix.ai/install.sh | sh

$super init swe

$cd swe

$super agent pull developer

$super agent compile developer --framework dspy

$super agent run developer --framework dspy --goal "Design a migration strategy"

# Optional optimization path

$super agent compile developer --framework dspy --optimize

$super agent optimize developer --framework dspy --auto light

The unsolved problem

Agent optimization is unsolved

Frameworks compete on how an agent is assembled. What happens after it runs is usually left to hand-tuning, with prompts edited by feel and nothing measuring whether the change helped.

We optimize at every layer

Optimization at each layer is what moves an agent from a demo to something worth running in production. SuperOptiX treats that as the whole product, combining published optimizers with our own, across any framework you already run.

Prompt

Instructions evolve against a scored task set rather than being edited by hand until they look right.

Context

What the agent is given to read, selected and structured so the useful material survives the window.

Pipeline

The steps between input and answer, tuned end to end instead of one component at a time.

Model

Hyperparameters and configuration, moved with the rest of the stack rather than pinned at defaults.

Production-Ready Agents

From Base Pipeline to Production

Most teams adapt an agent they already run. Starting fresh is the other road: write one specification and compile it to native code on any of the eight frameworks.

Traditional Approach

Framework glue code everywhere

Provider-specific logic duplicated

Manual prompt tweaking is endless

Heavy runtime scaffolding

SuperOptiX Approach

Define intent once in SuperSpec YAML

Generate framework-native pipelines

Optimize with GEPA when ready

Keep code ownership and readability

Framework Comparison

Area	Other Frameworks	SuperOptiX
Pipeline Output	Heavy runtime scaffolding	Minimal, framework-native code
Framework Lock-in	Rewrite for each framework	One spec, 8 frameworks
Optimization	Manual or framework-specific	Explicit --optimize path with GEPA
Code Ownership	Framework abstractions hide logic	Readable, native pipelines you own

Agent Quality Record

Record the Release Decision

An evaluation reports what passed today. Six months later, when somebody asks what was checked before the agent went live, the answer has to be reconstructed from memory.

One flag writes it down instead: the scenarios the agent was measured against, what it was permitted to do, the measures the run produced, and who accepted the result. The output follows SuperGauge, an open format any implementation can read.

How the record works

Emit a record

$super agent evaluate developer --gauge-out record.yaml

subject:
  agent: developer
  authority: {sandbox: docker, egress: deny-by-default}
task_set:
  manifest_digest: sha256:7d02...
  held_out: 2
  sealed: true
measures:
  - {id: task.completion, value: 0.83, n: 8}
decision:
  verdict: hold

Framework Agnostic

Build Once. Deploy Anywhere.

SuperOptiX compiles a single SuperSpec YAML into framework-native agent pipelines across 8 frameworks. Stay close to each framework's native programming model.