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

Osman ASLAN — Mon, 06 Apr 2026 18:13:41 +0000

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.

DEV Community: Osman ASLAN