Full transcript
0:03What happens when you have dozen of
0:05teams across three continents all
0:07building AI agents, each one wiring up
0:09their own connections, reinventing their
0:11own security model, deploying their own
0:13infrastructures? You get chaos.
0:15Hi, I'm Sonny Merla, Global Data Science
0:18and AI Manager at Amplifon, and I'm here
0:20today with Mauro Luchetti, AI Center of
0:22Excellence Manager, and Mattia Redaelli,
0:25AI Engineer at Quantica, the team that
0:27design and build the technical solution
0:29that we are about to describe.
0:31Today, we are going to show you how
0:32Amplifon tackled down this problem by
0:35launching their own Amplify program, and
0:38specifically how we design an
0:40enterprise-grade registry system for MCP
0:43and A2A agents.
0:45For who don't know Amplifon, Amplifon is
0:46the world leader in hearing care
0:48solutions. We operate across 26
0:51countries around the globe. We are more
0:53than 20,000 people, and we operate over
0:5610,000 stores across the globe.
0:58We are in the AI transformation. Right
1:01now, we are experimenting with AI
1:03solutions, technologies, and so we are
1:05facing challenges like building
1:07solutions that are stable over time, and
1:10understanding how to make them scale
1:12responsibly accordingly to guidelines
1:15that are defined centrally.
1:17So, how Amplifon decided to adopt AI at
1:19scale? We launched in January 2025 the
1:22Amplify program.
1:24It's a global and cross-functional
1:25program designed to set the rules for
1:28the AI adoption. And it is basic
1:31basically composed by an operating model
1:34and an execution plan. The operating
1:36model is based on two main sources, the
1:39control tower and the committee. The
1:40control tower is a limited set of people
1:42including chief decide deciding what are
1:45the guidelines for security, legal,
1:47technology, but also what are the
1:49strategy the the focus for the strategy,
1:52and so the use cases
1:54to develop us first. Then there is the
1:56committee that has the responsibility
1:59for running the strategy in the
2:01countries, but also in the the corporate
2:03side. So, prioritizing also the use
2:06cases more granularly, those are to to
2:09release the value to the organization.
2:11Which are the main focus of the Amplify
2:13program? We have three of them,
2:15governance, platform, and factory. So,
2:17the governance, we want to ensure the
2:18alignment with AI regulatory,
2:21also the strategy and the guidelines
2:23that we define centrally. So, it's also
2:25a matter of make the people aware of the
2:28existence of a program, the also the
2:30rules of the play, and also then
2:33make all the people informed of how we
2:36deliver and roll out the value. Then
2:38there is the platform side. So, we have
2:41to set up the infrastructure on which we
2:43operate as developers and implementation
2:46teams. So, certifying infrastructures
2:49and way of working to deliver processes
2:52and also services to
2:55scale AI application. Then we have the
2:57the factory. So, this is the most
2:59practical
3:00part of the story. So, we have the
3:02development teams that needs to have
3:05a focus on rolling out solutions to the
3:08market, also caring about the rollout
3:12across countries that is very important
3:14for for Amplifon. So, thinking about the
3:16solution as a scalable scalable and also
3:19reusable across different domains.
3:22So, which are the main problems that we
3:24see as an organization that tries to
3:26roll out AI at scale in a pervasive way
3:28in the organization? So, we foresee for
3:30sure maintenance and operations
3:32problems, governance and compliance
3:35problems, but also enterprise scaling.
3:37So, how the developers
3:39needs to
3:40develop to make the the solution stable
3:42over time.
3:44Um
3:44Starting from the maintenance and
3:46operations side, uh
3:48even the short life cycle of the LLM
3:50models that are at the core of the AI
3:52application and the AI agents that we
3:53develop and roll out, we want to be sure
3:56that we are able to address
3:59the the usage of this kind of LLM LLMs
4:02across the the use cases that we we roll
4:05out. So, we want to be ready and
4:07prepared to act promptly every time we
4:10we see a disruption in the model we use
4:12in the use case. Um on the other side
4:14with the governance and compliance, we
4:16we need to be sure
4:18to know about where we use AI in the
4:20organization, what are the main use
4:22cases, also for the regulatory
4:24point of view, but also for the usage
4:27across the organization. So, we want to
4:29have a catalog. We want to have a way to
4:31understand also the assets used by the
4:34single use cases. So, what they
4:36implemented, what they used
4:38to also create a sort of
4:41lineage of the information. On the other
4:43side then there is a a point related to
4:46the the way we develop AI solution in
4:48the organization across multiple teams
4:50that operates on different
4:51infrastructures. So, we want to make the
4:54developments
4:55at least
4:56in terms of governance centralized. Then
4:59so with clear guidelines,
5:01reusable also on different
5:03infrastructures and different teams.
5:05This is the the goal. So, we we want to
5:08make easy the life of developers to
5:10focus on the business logic inside the
5:12use cases, avoiding to reinvent the
5:14wheel every time we need to to take to
5:16take care about the security,
5:19but also the deployment
5:21and maintenance of the the use cases.
5:24So, now I let Mauro to introduce how we
5:27address these topics at Amplifon.
5:30Thank you, Sonny, and let's try to bring
5:32more technical point of view in this.
5:35The first component that we built in
5:38order to, you know, let's try try to to
5:40address those problems are an AI
5:43gateway.
5:44First of all, it brings us unified
5:47access. So, all the
5:50developers that want to use a model,
5:52they can
5:53use this
5:55gateway, and they can point to
5:58the unified endpoint, and
6:01use all the models that Amplifon has in
6:05in
6:06its catalog. Then there's a security
6:09aspect.
6:12If you want to use the models, you have
6:13to, you know, connect to the gateway.
6:16You have to
6:17authenticate yourself, and we have done
6:21this with the intra intra ID
6:24integration.
6:25Then there's a budgeting aspect because
6:28obviously Amplifon has lots of use
6:30cases, and if a use case came to you and
6:33asked for, you know, for budget for
6:35using those those models, you can set in
6:39this AI gateway
6:40a budget. So,
6:43a cost monthly cost, or I mean, yeah,
6:46you can set it monthly, weekly, and so
6:48on, but you can set a budget, and
6:52while the developers are using
6:55those budgets, it erodes, and it can
6:58brings to developers you know, the
7:00remaining part of those budgets. So,
7:02they can they can control it. And then
7:05there's the the the control aspect.
7:08So, all the
7:10you know, all the
7:12requests that
7:14are are done through LLM models or
7:17responses, all those all the analytics
7:21that we need to put in place
7:24on top of all the requests are done
7:26using
7:28a central auditing monitoring and
7:31analysis tools obviously connected to
7:34this AI gateway. And then for the
7:37governance part, I mean, this is the
7:39entry point. This is the top layer, I
7:41would say. And then we have three
7:43different registries. The first one is
7:46the MCP registry. So, as you as you can
7:49imagine, all the tools, all the
7:51integration with Amplifon systems, all
7:54the functionalities that we want to
7:56provide to LLM models are exposed
7:58through this MCP registry, which is the
8:01the the central catalog of all all
8:04available tools.
8:05Then there's the A2A
8:08agent-to-agent registry. So,
8:10it brings
8:12it's a full catalog of all implemented
8:15of all available agents, and it uses
8:18agent card standard. It exposes agent
8:21card, and also it can
8:24it can
8:25give the developer the ability to
8:27connect to already developed agents. And
8:31then there's the use case registry,
8:33which is the you know, the registry that
8:36connects
8:37connects all those all those information
8:40together, all those metadata together,
8:42and
8:43bring out the real governance
8:45functionality, the lineage
8:47functionality, and
8:49again connects all those aspects
8:51together.
8:52Let's try to go in more detail about
8:55each of those registry.
8:57I don't want to obviously tell anybody
9:00what MCP is not at this conference,
9:02but we started from the official MCP
9:06registry maintained by the community.
9:09This is the you know, the the public
9:11community-wide catalog of all available
9:14MCP servers,
9:17and we essentially build on top of that.
9:19So,
9:20Amplifon has built
9:22its own private MCP registry as an
9:25extension
9:27in functionalities, and also in you
9:29know, enterprise context that we want to
9:32add to each of the
9:33registered servers.
9:36It contains two main things. As you can
9:38imagine, the you know, the custom
9:41internal servers that
9:44the the the the internal Amplifon team
9:46have built for specific system, specific
9:49integration, specific tool that Amplifon
9:51want to provide, and also a curated set
9:54of
9:55public server that have been approved
9:57that have been, you know,
9:59certified by Amplifone for for for
10:01Amplifone use cases. And both these
10:05servers that we want that we register in
10:07in this catalog are enriched with some
10:11additional enterprise metadata.
10:14Let's let's see what are those metadata.
10:16First of all, the ownership. Each server
10:19has an owner. So,
10:22which is which team, which use case,
10:25which project is in a way owner is
10:28responsible for that specific server.
10:31What are the environment in in which the
10:33server is running. So, it is running is
10:36it running in dev, test, prod, and so
10:38on.
10:39What are the authentication model?
10:41So,
10:42how I can effect
10:44how I can as a developer use
10:47that server? What are the mechanism that
10:50I need to put in place? The cost
10:52attribution. So, this is linked to the
10:55AI gateway functionality, the budgeting
10:57aspect that we have described before.
11:00And this is done in order to see
11:03what server
11:05spending what essentially. And then the
11:09use case linkage. So, what are the use
11:11cases that are effect that are actually
11:14using that specific that specific
11:17server. And these are not simply, you
11:19know, metadata that are nice to have.
11:21This is something that really
11:24bring out the impact analysis
11:26functionality. This is where
11:28effectively we enable the governance and
11:31the auditability.
11:33And we have the complete trail of what
11:36AI tooling exist and how
11:39they are they are being used by
11:41Amplifone developers.
11:43And then we have second registry which
11:45is the eight way registry. This is fully
11:48based on the agent card
11:50that, you know, describe the agent's
11:53identity, its endpoint,
11:56the agent capabilities, the supported
11:59modalities, authentication requirements,
12:01and so on. We
12:03have built some blueprints and then we
12:06talk about those blueprints. But
12:08essentially, when an agent is deployed,
12:12it automatically publish publishes its
12:15agent card to the registry via CICD
12:18integration. So, in this way any other
12:20agent, any other developer can discover
12:24this new agent and obviously can
12:26interact with it.
12:28So, in a way we are trying to make all
12:31those
12:32agent development self-documenting.
12:36Now, we will see how use case registry
12:39connects those two other registry
12:42together. How do we can use the MCP
12:46registry and eight way registry from a
12:49business point of view?
12:51We want to have a use case registry. So,
12:54to map the agents and the tools in
12:56specific use case adopted across the
12:58organization. And this is the reason why
13:01we designed this specific building block
13:04that aims to contain the information of
13:07what are the assets used by the single
13:10use case, what they implement, what are
13:12the models they used also for the
13:14maintenance topic that we mentioned
13:16before.
13:17And also
13:18understand how and where we develop and
13:21deployed this kind of use cases. For
13:23example, which is the system that serve
13:25the use case the specific use case and
13:28what are all the other impacted by
13:31this use case. So, for example, if we
13:33have connection among multiple use
13:36cases, we want to see that clearly in
13:39interface that can be a catalog for for
13:41everyone.
13:42Let's see now how it works in practice.
13:45So, let's go in a walk through of the
13:48the platform that we developed and that
13:50implement all these registries
13:52for the organization.
13:54Okay, so we wanted also to give you a
13:56brief overview of our platform.
13:58Here you can see that is the home page.
14:02You can go into the catalog, so what we
14:04described in detail before, so MCP,
14:07eight way, use cases. We also have the
14:10AI gateway part where we define what
14:13LLMs are
14:15available
14:17in the enterprise right now.
14:20Going back to the dashboard, if we move
14:22on to the catalog,
14:25this is the platform that we are going
14:26to deploy in production soon. Here we
14:30have demo data.
14:32So, we have six entities defined
14:35until this point.
14:37We have use cases, MCP, and eight way
14:40agents. Going into the
14:43use cases part,
14:45if we open a sample use case for
14:47instance, we can define
14:49its status, its version, its
14:52description,
14:53assets used. So, for instance, an agent
14:56and then MCP server,
14:57what AI models it's using,
15:00and the life cycle history of the
15:04of the use case.
15:06If you go on to the
15:09create use case page, you can see that
15:11we can define a name, a description, the
15:14status of the use case, the ownership,
15:17and also the assets linked to that.
15:21If we move to the AI tool section, so
15:24MCP servers,
15:26you can see that we have two sample
15:31MCP servers. So,
15:34the actual server JSON is is described
15:38here. We can also see into the eight way
15:41agents the same
15:43thing for agent cards. So, for instance,
15:46here we can define the we can have the
15:49long chain test agent that test these
15:52capabilities and description from the
15:54agent card.
15:56We also define the inspector page where
15:59you can
16:01select
16:03an MCP server and you can launch the
16:05inspector in another tab. So, you can
16:08also connect and check what that MCP is
16:12providing you.
16:14We also have the same inspector that is
16:17just checking for
16:20compatibility with the eight way agent
16:23card.
16:25And you can do the same here.
16:27We also have widgets.
16:29So, you can in order to make the life of
16:33the developer easier,
16:35define the server.json for MCP and the
16:39agent card for eight way with a form
16:42and then preview it here instead of
16:45starting from the actual JSON on the
16:48repo if it's the first, let's say,
16:50server for you.
16:54We can
16:55also check the lineage
16:58because, for instance, you can go on to
17:00the use case, open
17:02a use case that you want to check, open
17:04the object lineage.
17:05In this lineage view, you can see that,
17:08for instance, the use case
17:12here that is ticket optimization with AI
17:16is connected to an agent, is connected
17:19to another agent here, and also has AI
17:22models connected to it. So, we can have
17:26the
17:27full lineage of the use case and also be
17:30able, as Maurice said before, to
17:35be sure and also make modifications in
17:38case some parts of the lineage are
17:40affected by an outage or a problem and
17:43go back to the use case affected.
17:47So, moving into the enterprise
17:49development cycle, so we talked a lot
17:52about
17:53metadata and registries,
17:56but how do actually Amplifone developers
18:00develop MCP servers and agent to agent
18:04servers to
18:06deploy them in production? We deployed
18:09and developed two repositories, one for
18:12MCP and one for agent to agent protocol.
18:16These two repositories are template
18:18repositories on GitHub. So, then
18:20developers and teams can start from from
18:23them and work their way up to production
18:27environment. The idea is that these two
18:31blueprints actually have boilerplate
18:34provided
18:35and also
18:37infrastructure and tooling
18:39already present. So, for instance,
18:41Docker files,
18:43package manager,
18:44both are fast API servers, so they are
18:47exposed in the same way.
18:49And also the authentication
18:52and cost tracking cost tracking is
18:54handled inside the blueprint.
18:57We also have an integration
18:59to LongFuse, which is an observability
19:01tool that we deployed at the platform
19:03level.
19:04So,
19:06the development teams can also trace
19:10their agents,
19:12run evaluations, and check how the agent
19:15is performing.
19:17Also, the
19:20eight way server blueprint is agnostic,
19:22so it's not based on a particular
19:24framework, so LongChain or Agno or
19:29any other framework, but actually is
19:31composed of interfaces and
19:34ports so that every team can implement
19:36their own solution
19:39in their framework of choice.
19:42The important thing is that they provide
19:44the same interface
19:46that we
19:48saved in the in the blueprint.
19:50So, that uh the development is uh easy
19:54on the developers and they can focus on
19:56the actual value of the agent.
20:00So um
20:01Mauro talked about the um CICD uh that
20:05is in place in the um
20:07uh
20:08A2A uh blueprint and also the MCP
20:11blueprint.
20:12Uh the idea is that uh once you are
20:15ready with your development, uh you can
20:19tag um a certain branch and uh GitHub
20:22action so uh
20:24starts and uh uh all not only publishes
20:28the Docker image on our artifact
20:31repository,
20:32uh but also publishes the metadata of
20:35that agent so the agent card for uh
20:38agent-to-agent protocol and the
20:40server.json
20:42uh for MCP
20:43uh onto the uh backend uh let's say
20:46proxy of the the catalog of the
20:48registries.
20:50Um
20:51in this image we can also see that um
20:54in case any AI agents uh needs to call
20:58either an MCP or an A2A proxy, um
21:02the idea is that they can go through the
21:06um
21:07APG AI gateway that we deployed and um
21:11these two proxies, so the MCP one and
21:14the uh A2A one,
21:16um
21:17go uh look up into the uh actual catalog
21:21of uh agents and MCPs to retrieve the
21:25actual URL of the backend that the agent
21:28uh wants to call and then the agent
21:31authenticate itself uh
21:33with another header
21:35um
21:36onto the the actual server.
21:38So to bring it back to the business
21:40perspective, what we achieved with the
21:42amplify platform and the registry uh we
21:44developed, we have right now a catalog
21:47uh to to make the governance happen. So
21:49we see the MCP and A2A server that we
21:52deploy across the organization and
21:54across multiple teams.
21:55Uh we have a full traceability of the
21:58use cases, agents, tools, and also
22:01models adopted um across across the use
22:04cases. Then we have the production ready
22:07blueprints for developers to start from
22:08something standard across across teams,
22:11but uh ready for building and focusing
22:13on
22:14um the business logic in the use cases.
22:17Then we have the CICD pipelines that
22:20ties for deploying the servers to
22:22production, but also the metadata into
22:24the registry. Of course, it is still in
22:26progress the the work on this platform,
22:28so we are keep growing the capabilities.
22:32Uh so feel free to to reach out to us
22:34and keep in touch if you have any
22:36similar uh point of view or also
22:39uh something different that you want to
22:40discuss, more than welcome.
22:43Thank you. Feel free to reach out.