One Registry to Rule them All - Sonny Merla, Mauro Luchetti, & Mattia Redaelli, Quantyca

What happens when you have dozen of teams across three continents all building AI agents, each one wiring up their own connections, reinventing their own security model, deploying their own infrastructures?

You get chaos. Hi, I'm Sonny Merla, Global Data Science and AI Manager at Amplifon, and I'm here today with Mauro Luchetti, AI Center of Ex-Excellence Manager, and Mattia Redaelli, AI Engineer at Quantyca, the team that design and build the technical solution that we are about to describe.

Today, we are going to show you how Amplifon tackled down this problem by launching their own Amplify program, and specifically how we design an enterprise-grade registry system for MCP and the A2A agents.

For who don't know Amplifon, Amplifon is the world leader, uh, in hearing care solutions. Um, we operate across twenty-six countries around the globe. We are, uh, more than twenty thousand people, and we operate over ten thousand stores across the globe.

Uh, we are in the AI transformation right now. We are experimenting with AI solutions, technologies, and so we are facing challenges like building solutions that are stable over time and understanding how to make them scale responsibly accordingly to guidelines that are defined centrally.

So how Amplifon decided to adopt AI at scale? We launched in January 2025, the AmplifAI program. Uh, it's a global and cross-functional program designed to, uh, set the rules for the AI adoption, and it is basic-basically composed by, uh, an operating model and an execution plan.

The operating model is based on two main souls, the control tower and the committee. The control tower is a limited set of people, including chief, deci-deciding what are the guidelines for security, legal, technology, but also, uh, what are the strategy, the, the focus for the strategy, and so the use cases, uh, to developers first.

Then there is the committee, uh, that has the responsibility for running the strategy in the countries, but also in the, the corporate side. So prioritizing also the use cases more granularly, also to, to release the value to the organization.

Which are the main focus of the AmplifAI program? We have three of them: governance, platform, and factory. So the governance, we want to ensure the alignment with the AI regulatory, also the strategy and the guidelines that we define centrally.

So it's also a matter of make the people aware of the existence of a program, the also the rules of the play, and also then, uh, make all the people informed of how we deliver and roll out the value.

Then there is the platform side. So we have, uh, to set up the infrastructure on which we operate as developers and implementation teams. So certifying infrastructures and way of working to deliver processes and also services to, um, scale AI application.

Then we have the, the factory. So this is the most practical, uh, part of the story. So we have the development teams that needs to have, uh, a focus on rolling out solutions to the market.

Also caring about the, uh, rollout across countries that is very important for, for Amplifon. So thinking about the solution as scalable, scalable and also reusable across different domains. So which are the main problems that we see as an organization that tries to roll out AI at scale in a pervasive way in the organization?

So we foresee for sure, uh, maintenance and operations, uh, problems, uh, governance and compliance problems, but also enterprise scaling, so how the developers, uh, needs to, uh, develop to make the, the solution stable over time.

Um, starting from the maintenance and operations side, uh, even the short life cycle of the LLM models that are at the core of the AI application and the AI agents that we develop and roll out, we want to be sure that we are able to address, um, the, the usage of these kind of LLE-LLMs across the, the

use cases that we, we roll out. So we want to be ready and prepared to act promptly every time we, we see a disruption in the model we use in the use case.

Um, on the other side, with the governance and compliance view, we need to be sure, uh, to know about where we use AI in the organization, what are the main use cases, also for the regulatory point of view, but also for the usage, um, across the organization.

So we want to have a catalog. We want to have a way to understand also the assets used by the single, uh, use cases. So what they implemented, what they used, um, to also create a sort of, um, lineage of the information.

On the other side then, there is a, a point, uh, related to the, the way we develop AI solution in the organization across multiple teams that operates on different infrastructures.

So we want to make the developments, uh, at least in terms of governance, centralized. Then so with clear guidelines, uh, reusable also on different infrastructures and different teams. This is the, the goal.

So we, we want to make easy the life of developers to focus on the business logic inside the use cases, avoiding to reinvent the wheel every time we need to, to take, to take care about the security, uh, but also the deployment, uh, and maintenance of the, the use cases.

So now I let Mauro to introduce how we address these topics, uh, at Amplifon.

Thank you, Sonny. And, uh, let's try to bring a more technical point of view in this. Uh, the first component, uh, that we built, uh, in order to, uh, you know, let's try, uh, try to, to address those problems are, uh, an AI gateway.

Um, first of all, it brings us, uh, unified access. Uh, so all the, uh, developers that want to use a model, uh, they can, uh, use this, uh, gateway, and, uh, they can point to, uh, the unified endpoint and, uh, use, uh, all the models that Amplifon has, uh, in, uh, uh, in, uh, its catalog.

Uh, then there's a security aspect. Um, uh, if you want to use the models, you have to, uh, you know, connect to the gateway. You have to, uh, authenticate yourself and, uh, we have done this, uh, with the intra-Entra ID, uh, integration.

Uh, then there's, uh, a budgeting aspect because, uh, obviously Amplifon has lots of use cases. And if a use case came to you and asked for, you know, for budget for using those, uh, those model, uh, you can set in this AI gateway, uh, a budget.

So, uh, um, a, a cost, a monthly cost or, I mean, you can set it monthly, weekly and so on, but you can set a budget and, uh, while the developers are using, uh, those budget, it erodes and it can, uh, brings to developers, uh, you know, the remaining part of those budget, so they can, they can

control it. And then there's the, uh, the, the control aspect. Uh, so all the, the, uh, you know, all the, um, uh, requests that, uh, um, are, are done through, uh, LLM models or responses, all the, the, all the analytics, uh, that we need to put in place, uh, um, on top of all the requests are done

using, uh, a central auditing, monitoring and analysis tools obviously connected to this AI gateway. And then for the, uh, governance part, I mean, this is the entry point. This is the top layer, I would say.

And then we have three different, uh, registries. Uh, the first one is the MCP registry. So as you, as you can, uh, imagine, all the tools, all the integration with Amplifon systems, uh, all the functionalities that we want to provide to LLM models are exposed through this MCP registry, uh, which is the, the, the central catalog of

all, all, uh, available tools. Uh, then there's the, uh, eight-way, uh, Agent2Agent registry. So, uh, it brings-- Uh, it's a full catalog of full, uh, implemented, uh, full available, uh, agents, and it uses agent card, uh, standard.

It exposes agent card and also, uh, it can, um, it can, uh, give the developer the ability to connect to, uh, already, uh, developed, uh, agents. And then there's the use-case registry, which is the, uh, you know, the registry that connects the-- connect all those, uh, all those, uh, information together, all those metadata together, and, uh, bring

out the real governance functionality, the lineage functionality, and, uh, again, connects all those aspect, uh, together. Let's try to go, uh, in more detail about each of those registry.

Um, I don't want to, uh, obviously, uh, tell anybody what MCP is, not at this conference. Uh, but we started from the, uh, official MCP registry, uh, maintained by the community.

Uh, this is the, you know, the, the public community-wide catalog of all available MCP servers. Um, and, uh, we essentially build on top of that. So, uh, Amplifon has built, uh, its own, uh, private MCP registry as an extension, um, in functionalities and also in, uh, you know, enterprise context that we want to add to each of

the, uh, registered, uh, servers. Um, it contains two main things, uh, as you can imagine. The, uh, you know, the custom internal servers that, uh, the, the, the internal Amplifon team have built for specific systems, specific integration, specific tool that Amplifon want to provide.

And also a curated set of, uh, public server that have been approved, that have been, you know, um, certified by Amplifon, uh, for, for, for Amplifon use cases. And, uh, both these servers that we want, that we registered in, in, in this catalog are enriched with some additional, uh, enterprise metadata.

Uh, let's, let's see what are those metadata. Uh, first of all, the ownership. Uh, each server has an owner. Uh, so which is-- Which team, uh, which use case, which project is in a way, uh, owner is responsible for that specific server.

Um, what are the environment in, in which the server is running? So it is running, is it running in dev, test, prod, and so on? Uh, what are the authentication model?

Uh, so, um, how I can effect-- Uh, how I can, as a developer, use, uh, that server? What are the, uh, mechanism that I, uh, need to put in place?

Um, the cost attribution. So, uh, this is linked to the AI gateway functionality, the budgeting aspect that, that we have described before. And, uh, uh, this is done in order to see, uh, what server, uh, is, is spending what, essentially.

And, uh, then the, uh, use case linkage. So, uh, what are the use cases that are, uh, effect-- That are actually using that specific, that specific server? And these are not, uh, simply, you know, metadata that are nice to have.

This is something that really, uh, bring out the impact analysis functionality. This is where, uh, effectively we enable the governance and the auditability, uh, and we have the complete trail of

What AI tooling exists and how, uh, they're, they're being, uh, used by, uh, Amplifon developers. And then we have a second registry, which is the A2A registry. Uh, this is fully based on the agent card, um, that, you know, describe the agent's identity, uh, its endpoint, um, uh, the agent capabilities, the supported, uh, modalities, authentication requirements, and

so on. Um, we, um, have built some blueprints, and then we talk, uh, about those blueprints. But essentially, when an agent is deployed, um, it automatically publish, uh, publishes its agent card to the registry via CI/CD, uh, integration.

So, uh, in this way, any other agent, any other, uh, developer can discover this new agent and obviously can interact with it. Um, so in a way, we, uh, are trying to make, uh, all those, uh, agent development self-documenting.

Now we will see how use-case registry connects those two other registry together.

So how do we can use, uh, the MCP registry and A2A registry from a business point of view? We want to have a use-case registry, so to map the agents and the tools in specific use case adopted across the organization.

And this is the reason why we designed, uh, this specific building block that aims to contain the information of, uh, what are the assets used by the single, uh, use case, what they implement, what are the models they used also for the maintenance topic that we mentioned before, and also, uh, understand how, uh, and where we develop

and deploy these kind of use cases. For example, which is the system that serve the use case and specific use case, uh, and what are all the other impacted by, uh, this use case.

So for example, if we have connection among multiple, uh, use cases, we want to see that clearly in an interface that can be a catalog for, for everyone. Well, let's see now how it works in practice.

So, uh, let's go in a walkthrough of the, the platform that we developed and that implement all these registries, uh, for the organization.

Okay, so we wanted also to give you a brief overview of our platform. Uh, here you can see that is the, uh, home page. Uh, you can go into the catalog, so what we described, uh, in detail before, so MCP, A2A, and use cases.

Uh, we also have the, uh, AI gateway part where we define, uh, what LLMs are, um, available, um, in the enterprise, uh, right now. Um, going back to the dashboard, if we move on to the catalog, um, this is the platform that we are going to, uh, deploy in production soon.

Uh, here we have, uh, demo data. Um, so we have six entities defined, um, until this point. Um, we have use cases, MCP, and A2A agents. Um, going into the, uh, use cases part, if we open a sample use case, for instance, we can define, uh, its status, uh, its version, its description, uh, uh, assets

used, so for instance, an agent and an MCP server, uh, what AI models it's using, uh, and the life cycle history of the, uh, of the use case.

Uh, if we go onto the, um, create use case page, uh, you can see that we can define a name, a description, uh, the status of the use case, the ownership, uh, and also the assets linked to that.

Um, if we move to the AI tools section, so MCP servers, um, you can see that we have two sample, um, MCP servers. So, um, the actual, uh, server JSON is, is described here.

Uh, we can also see into the, uh, A2A agents the same, uh, thing for, uh, agent cards. So for instance, uh, here we can define the... We can have the, uh, LangChain test agent that has, uh, these, uh, capabilities and description from the agent card.

Um, we also define the inspector page where you can, um, select, uh, an MCP server, and you can launch, uh, the inspector in another tab, so you can also connect and, uh, check what that MCP is, uh, providing you.

Uh, we also have the same inspector, uh, that is just checking for, um, uh, compatibility with the, uh, A2A, uh, agent card, and you can do the same here.

Uh, we also have wizards, uh, so you can, um, in order to make the life of the developer easier, um, define the server.json for MCP and the agent card for A2A with a form, uh, and then preview it, uh, here instead of starting from, uh, the actual JSON on the repo if it's the first, uh, let's say,

server for you. Um, we can, uh, also check the lineage, uh, because for instance, you can go onto the use case, open, uh, a use case that you want to check, open the object lineage.

In this lineage view, you can see that, for instance, the use case, um, uh, here that is ticket optimization with AI, uh, is connected to an agent, is connected to another agent here, and also has AI models connected to it.

Uh, so we can have the, uh, full lineage of the use case and also be able, as Mauro said before, to, um,

be sure and also, uh, make modifications in case some parts of the lineage are affected by an outage or a problem, and, uh, go back to the use case affected.

So, uh, moving into the enterprise development cycle. So, uh, we talked a lot about, uh, metadata and registries, uh, but how do actually, uh, Amplifon developers, uh, develop, uh, MCP servers and Agent2Agent servers to, uh, deploy them in production?

Uh, we deployed and developed two repositories, uh, one for MCP and one for Agent2Agent protocol. Uh, these two repositories are template repositories on GitHub, so then, uh, developers and teams can start from, from them and, uh, work their way up to a production, uh, environment.

Um, the idea is that these two blueprints actually have, uh, boilerplates, uh, provided, uh, and also, uh, infrastructure and tooling, uh, already present. So for instance, Docker files, uh, package manager, um, both are gFast API servers, so they are exposed in the same way, um, and also the authentication, uh, and cost rat- cost tracking

is handled inside the, the blueprint. We also have an integration, uh, to Langfuse, uh, which is an observability tool, uh, that we deployed at the platform level. Uh, so the, uh, development teams, uh, can also trace their agents, uh, run evaluations, uh, and check, uh, how the agent is performing.

Um, also the, um, A2A server blueprint is agnostic, so it's not based on a particular framework, so LangChain or Agno or, um, any other framework. But actually it's composed of interfaces and, uh, ports, uh, so that every team can implement their own solution, um, in, uh, their framework of choice.

Um, the important thing is that they provide the same interface, uh, that we, uh, saved in the, in the blueprint so that, uh, the development is, uh, easy on the developers and they can focus on the actual value of the agent.

Oh, um, Mauro talked about the, um, CI/CD, uh, that is in place in the, um, uh, A2A, uh, blueprint and also the MCP blueprint. Uh, the idea is that, uh, once you are ready with, uh, your, uh, development, uh, you can tag, uh, a certain branch and, uh, GitHub Actions.

So, um, starts and, uh, uh, all-- not only publishes the Docker image on our artifact repository, uh, but also publishes the metadata, uh, of that agent, so the agent card for, uh, Agent2Agent protocol and the server.json, uh, for MCP, uh, onto the, uh, backend, uh, let's say proxy of the, the

catalog of the registries. Um, in this image, we can also see that, um, in case an AI agent, uh, needs to call, uh, either an MCP or an A2A proxy, um, the idea is that they can go through the, um, Apigee AI gateway that we deployed.

And, uh, these two proxies, so the MCP one and the, uh, A2A one, um, go, uh, look up into the, uh, actual catalog of, uh, agents and MCPs to retrieve the actual URL of the backend that the agent, uh, wants to call, and then the agents authenticate itself, uh, with another header,

um, onto the, the actual server.

So to bring it back to the business perspective, uh, what we achieved with the AmplifAI platform and the registry, uh, we developed. We have right now a catalog, uh, to, to make the governance happen.

So we see the MCP and A2A server that we deploy across the organization and across multiple teams. Uh, we have a full traceability of the use cases, agents, tools, and also models adopted, um, across, across the use cases.

Then we have the production-ready blueprints for developers to start from something standard across, across teams, but, uh, ready for building and focusing on, um, the business logic in the use cases.

Then we have the CI/CD pipelines standardized for deploying the service to production, but also the metadata into the registry. Of course, it is still in progress, the, the, the work on this platform, so we are keep growing the capabilities.

Uh, so feel free to, to reach out to us and keep in touch if you have any similar, uh, point of view or also, uh, something different that you want to discuss, more than welcome.

Thank you. Feel free to reach out.