Nexarion

Universal interoperability runtime between MCP tools and A2A agents.

Dynamic agent discovery · Runtime schema translation · Streaming bridge · Auth interoperability

Live Web Dashboard Demo

---

Problem

The AI agent ecosystem is fragmenting into two incompatible standards:

• MCP (Anthropic) — tools connect to agents, but agents can't talk to other agents
• A2A (Google/Linux Foundation) — agents talk to agents, but not to MCP tools

There is no universal bridge. Developers must choose sides or write bespoke integrations.

Solution

Nexarion is an agent interoperability runtime — a runtime layer that dynamically bridges MCP and A2A.

┌─────────────────────────────────────────────────────────────────┐
│                       MCP CLIENTS                               │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐      │
│  │ Claude   │  │ Cursor   │  │ VS Code  │  │ Zed      │ ...   │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘      │
│       │             │             │             │              │
│       └─────────────┴──────┬──────┴─────────────┘              │
│                            │  tools/list, tools/call            │
└────────────────────────────┼────────────────────────────────────┘
                             │  stdio / HTTP / SSE
                             ▼
┌─────────────────────────────────────────────────────────────────┐
│                       NEXARION RUNTIME                          │
│  ┌──────────────┐  ┌────────────────┐  ┌───────────────────┐   │
│  │ Discovery    │  │ Translator     │  │ Router            │   │
│  │ Agent Cards  │→ │ MCP ↔ A2A      │→ │ Auth passthrough  │   │
│  │ /.well-known │  │ Schema mapping │  │ Rate limiting     │   │
│  └──────────────┘  └────────────────┘  └───────────────────┘   │
└────────────────────────────┼────────────────────────────────────┘
                             │  message/send, task/submit
                             ▼
┌─────────────────────────────────────────────────────────────────┐
│                       A2A AGENTS                                │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐      │
│  │ Weather  │  │ Code     │  │ Research │  │ Custom   │ ...   │
│  │ Agent    │  │ Agent    │  │ Agent    │  │ Agent    │      │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘      │
└─────────────────────────────────────────────────────────────────┘

Killer Feature: Dynamic Tool Synthesis

1. A2A agent detected at https://weather.agent.ai
2. GET /.well-known/agent-card.json
3. Agent Card parsed → skills extracted
4. Each skill auto-converted to MCP tool with inputSchema
5. Instantly usable in Claude Desktop / Cursor / VS Code

No configuration. No manual mapping. Just discover and use.

Protocol Mapping

Nexarion translates between MCP and A2A in real-time:

MCP Concept	Nexarion	A2A Concept
tools/list	→ Agent Card skills	GET /.well-known/agent-card.json
tools/call	→ message/send	POST /jsonrpc with message/send
Tool inputSchema	→ Skill parameters	Skill description + tags
Text response	← Task result	message.parts[].text
Tool error	← Task failure	status.state = failed

Real Protocol Example

MCP Request (from Claude):

{
  "method": "tools/call",
  "params": {
    "name": "a2a_weather_agent_forecast",
    "arguments": { "message": "Weather in Paris tomorrow?" }
  }
}

Nexarion translates to A2A:

{
  "jsonrpc": "2.0",
  "method": "message/send",
  "params": {
    "message": {
      "role": "user",
      "parts": [{ "type": "text", "text": "Weather in Paris tomorrow?" }]
    },
    "configuration": { "blocking": false }
  },
  "id": "1718400000000"
}

A2A Response translated back to MCP:

{
  "content": [
    {
      "type": "text",
      "text": "Paris: Partly cloudy, 22°C, 15% chance of rain."
    }
  ]
}

Why Nexarion?

	MCP Only	A2A Only	Nexarion
Agent ↔ Tool	✅	❌	✅
Agent ↔ Agent	❌	✅	✅
Auto-Discovery	❌	✅	✅
Dynamic Schema	❌	Partial	✅
Cross-Protocol	❌	❌	✅
Claude Desktop	✅	❌	✅
Streaming	✅	✅	✅
Self-Hosted	✅	✅	✅

Features

• Dynamic Tool Synthesis — Each A2A skill auto-converts to MCP tool with inputSchema
• Bidirectional Translation — Real-time MCP ↔ A2A protocol message translation
• HTTP + Stdio + SSE — Local stdio (Claude Desktop) or remote HTTP server
• Plugin Middleware — beforeTranslate/afterTranslate/onError hooks
• Capability Auth — Fine-grained access control per agent/skill/client
• Webhook Events — Push notifications on translation completion/failure
• MCP Resources & Prompts — Agents auto-exposed as resources + prompt templates
• Hot-Reload — Config changes trigger automatic agent rediscovery
• SDK — Build A2A agents in 50 lines with nexarion-sdk
• CLI — discover, tools, call, agents, stats, serve, init, validate
• SSE Streaming — Real-time A2A SSE event parsing, stream-to-MCP conversion
• SQLite Registry — Persistent agent directory with search and health checks
• VS Code Extension — Live agent list via HTTP, TreeView, status bar, health check
• Web Dashboard — Agent list, tool test console, SSE live, event log, auto-refresh

Quick Start

npm install nexarion-core nexarion-server

# Start the MCP ↔ A2A bridge server on port 3000
npx nexarioncli serve --transport http --port 3000

CLI Usage

Nexarion provides a complete CLI interface (nexarioncli) for managing the interoperability bridge:

• List Bridged Agent Status:

  npx nexarioncli agents

• List Active MCP Tools:

  npx nexarioncli tools

• Query Live Bridge Statistics:

  npx nexarioncli stats

• Validate an Agent Card (Example):

  npx nexarioncli validate https://weather.agent.ai

• Discover a New Agent Dynamically:

  npx nexarioncli discover https://agent.example.com

• Direct Tool Invocation:

  npx nexarioncli call a2a_weather_agent_forecast '{"message":"Weather in Paris?"}'

Premium Web Dashboard

When running the bridge in HTTP mode (npx nexarioncli serve --transport http --port 3000), Nexarion automatically hosts a dark glassmorphic Web Dashboard directly at http://localhost:3000!

Live Demo URL: https://nexarion-web.vercel.app/

Features:

• Responsive Dark-Glass UI: Harmonious colors, Outfit modern typography, and smooth micro-animations.
• Auto-Discovery Feed: Connected agents registry synced via SSE.
• Tool Test Console: Real-time schema inspector and testing client that executes tool calls and translates payloads.
• Real-time Metrics: Visual counters tracking active agents, exposed tools, translations count, errors, and uptime.
• Auto-Polling: Option to automatically fetch and refresh server states every 5 seconds.

Claude Desktop Integration

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "nexarion": {
      "command": "npx",
      "args": ["nexarioncli", "serve"]
    }
  }
}

See examples/claude-desktop/ for full setup.

Packages

Package	Description
nexarion-core	Core bridge engine — discovery, translation, routing, auth, plugins
nexarion-server	MCP server — stdio + HTTP, SSE, JSON-RPC, graceful shutdown
nexarion-sdk	Agent builder SDK — create A2A agents in 50 lines
nexarion-registry	Agent directory — search, health-check, verification
nexarioncli	CLI — discover, tools, call, agents, stats, serve, init, validate
nexarion-web	Web dashboard — live fetch + SSE, agent monitoring
nexarion-vscode	VS Code extension — sidebar, TreeView, command palette

Tests

102 tests across 5 packages, 20 test files. Run with:

pnpm test

Contributing

git clone https://github.com/vahapogut/nexarion.git
cd nexarion
pnpm install
pnpm build
pnpm test
pnpm lint

License

Apache-2.0. Built by IPEC Labs.