I built a2a-mesh: a TypeScript runtime for A2A-based agent communication

Over the last 6 months, I’ve been building a2a-mesh in nights and weekends.

It started from a simple frustration:

Why do we keep rebuilding the same infrastructure in every agent project?

When you try to make agents built with different frameworks work together, the business logic may be different, but the infrastructure work tends to repeat:

• protocol glue
• auth
• retries
• streaming
• service discovery
• observability
• operational controls

That repetition is what led me to build a2a-mesh.

The problem

In practice, cross-framework agent communication is rarely just “connect A to B”.

You usually end up stitching together transport logic, compatibility layers, middleware, tracing, error handling, and deployment concerns.

That gets messy fast, especially if you want something that is:

• reusable
• observable
• secure
• maintainable
• production-oriented

What is a2a-mesh?

a2a-mesh is an open-source TypeScript runtime/platform for A2A-based agent-to-agent communication.

My goal is to provide a reusable foundation for teams building multi-agent systems in TypeScript, especially when interoperability and operations start to matter.

Current scope includes:

• core TypeScript runtime and client/server building blocks
• adapters for OpenAI, Anthropic, LangChain, Google ADK, LlamaIndex, and CrewAI
• MCP ↔ A2A bridge
• retry/backoff and circuit breaker patterns
• JWT auth and SSRF protection
• OpenTelemetry tracing
• service registry and control plane UI
• project scaffolding for faster setup

A minimal example

The intended experience is to make agent setup feel lightweight, while keeping the operational layers available when needed.

class MyAgent extends OpenAIAdapter {
  constructor() {
    super(card, { model: "gpt-4o", client: openai });
  }
}

new MyAgent().start(3001);

Of course, the real value is not just in starting an agent process.

It’s in everything around it:
how agents connect, how failures are handled, how requests are traced, how services are discovered, and how the system stays maintainable as it grows.

What I wanted from the project

I wanted this project to feel useful in two ways:

1. As a real developer tool

Something people can actually try in their own agent systems.

2. As infrastructure that scales with complexity

Not just a demo layer, but a foundation that can support:

• multiple agents
• multiple frameworks
• operational visibility
• safer defaults
• cleaner extension points

Design goals

The project is shaped around a few principles:

• practical interoperability
• TypeScript-first developer experience
• operational visibility
• modular architecture
• extensibility over lock-in

Why open source?

Because the ecosystem is still evolving, and this kind of infrastructure gets better when people can inspect it, challenge it, and improve it in public.

I also wanted the repo to be more than a package dump:
documentation, examples, adapters, registry/control-plane direction, and contributor-friendliness all matter.

Current status

The repo is now live, and I’m actively looking for feedback on:

• onboarding and setup clarity
• adapter ergonomics
• MCP bridge workflows
• registry/control plane usefulness
• docs quality
• real-world gaps

Repo

GitHub: github.com/oaslananka/a2a-mesh

If you try it, I’d genuinely love to hear:

• what worked well
• what felt confusing
• what you’d want next
• which integrations or adapters matter most to you

Feedback, issues, and contributions are very welcome.