Build an AI Agent Registry

Beta Feature

This guide describes a beta capability. The data model and integration patterns may change as we extend support for additional AI agent platforms. We welcome your feedback to help shape the future of this feature.

This guide demonstrates how to build a centralized AI Agent Registry using Port, enabling your organization to discover, govern, and manage AI agents deployed across multiple cloud platforms in a single unified view.

Common use cases

1. Agent Discovery - Enable developers to find and reuse existing AI agents across the organization instead of building duplicates.

2. Multi-Cloud Visibility - View all AI agents from AWS Bedrock and Azure AI Foundry in one place.

3. Governance & Compliance - Track agent status, models used, and deployment regions for compliance requirements.

Prerequisites

1. A Port account with permissions to create blueprints and integrations.

2. Depending on which cloud providers you want to integrate:

   AWS

   • An AWS account with Bedrock agents or AgentCore runtimes deployed.
   • AWS credentials (Access Key ID, Secret Access Key) with permissions to list Bedrock agents. Learn more
   • For AgentCore, ensure bedrock-agentcore:ListAgentRuntimes permission is available.

   Azure

   • An Azure account with AI Foundry agents deployed.
   • Your Azure AI Foundry project endpoint URL and API key.

Set up data model

We'll create a blueprint to represent AI agents in your organization's catalog, tracking their platform, status, model, and region.

Create AI Agent blueprint

1. Go to the Builder page of your portal.

2. Click on + Blueprint.

3. Click on the {...} Edit JSON button.

4. Copy and paste the following JSON configuration:

   AI Agent blueprint (Click to expand)

   {
     "identifier": "aiAgent",
     "description": "AI agents deployed across cloud platforms",
     "title": "External AI Agent",
     "icon": "GPU",
     "schema": {
       "properties": {
         "description": {
           "title": "Description",
           "type": "string",
           "description": "What this agent does"
         },
         "platform": {
           "title": "Platform",
           "type": "string",
           "enum": ["aws-bedrock", "aws-agentcore", "azure-foundry"],
           "enumColors": {
             "aws-bedrock": "orange",
             "aws-agentcore": "orange",
             "azure-foundry": "blue"
           },
           "description": "Cloud platform where the agent is deployed"
         },
         "status": {
           "title": "Status",
           "type": "string",
           "enum": ["CREATING", "PREPARING", "PREPARED", "NOT_PREPARED", "ACTIVE", "DELETING", "FAILED", "VERSIONING", "UPDATING"],
           "enumColors": {
             "CREATING": "yellow",
             "PREPARING": "yellow",
             "PREPARED": "green",
             "NOT_PREPARED": "red",
             "ACTIVE": "green",
             "DELETING": "pink",
             "FAILED": "red",
             "VERSIONING": "yellow",
             "UPDATING": "yellow"
           },
           "description": "Current deployment status"
         },
         "model": {
           "title": "Model",
           "type": "string",
           "description": "Foundation model used by the agent"
         },
         "region": {
           "title": "Region",
           "type": "string",
           "description": "Cloud region where agent is deployed"
         },
         "createdAt": {
           "title": "Created At",
           "type": "string",
           "format": "date-time",
           "description": "When the agent was created"
         },
         "updatedAt": {
           "title": "Updated At",
           "type": "string",
           "format": "date-time",
           "description": "When the agent was last updated"
         }
       },
       "required": ["platform"]
     },
     "mirrorProperties": {},
     "calculationProperties": {},
     "relations": {}
   }

5. Click Create to save the blueprint.

Connect your cloud providers

Now that we have our data model, let's configure integrations to automatically discover AI agents from your cloud platforms.

AWS Bedrock & AgentCore

Ingest AWS Bedrock and AgentCore agents

Port's AWS integration can discover Bedrock agents and AgentCore runtimes using the Cloud Control API.

1. If you haven't already, install the AWS integration.

2. Add the following resource configurations to your AWS integration to ingest Bedrock agents:

   AWS Bedrock Agent mapping (Click to expand)

   resources:
     - kind: AWS::Bedrock::Agent
       selector:
         query: "true"
         useGetResourceAPI: true
       port:
         entity:
           mappings:
             identifier: .Properties.AgentId
             title: .Properties.AgentName
             blueprint: '"aiAgent"'
             properties:
               description: .Properties.Description
               platform: '"aws-bedrock"'
               status: .Properties.AgentStatus
               model: .Properties.FoundationModel
               region: .__Region
               createdAt: .Properties.CreatedAt
               updatedAt: .Properties.UpdatedAt

3. To also ingest AgentCore runtimes, add this configuration:

   AWS AgentCore Runtime mapping (Click to expand)

   resources:
     - kind: AWS::BedrockAgentCore::Runtime
       selector:
         query: "true"
         useGetResourceAPI: true
       port:
         entity:
           mappings:
             identifier: .Properties.AgentRuntimeId
             title: .Properties.AgentRuntimeName
             blueprint: '"aiAgent"'
             properties:
               description: .Properties.Description
               platform: '"aws-agentcore"'
               status: .Properties.AgentRuntimeStatus
               region: .__Region
               createdAt: .Properties.CreatedAt
               updatedAt: .Properties.LastUpdatedAt

4. Click Resync to start discovering your AWS agents.

Azure AI Foundry

Ingest Azure AI Foundry agents

Use Port's Ocean Custom Integration to pull agents from Azure AI Foundry's REST API. You can install it as Hosted by Port or self-hosted (Helm or Docker).

The steps below use Hosted by Port.

Find your Azure AI Foundry credentials

Before configuring the integration, you'll need your Base URL and API Key from Azure.

How to find your Base URL and API Key (Click to expand)

Base URL:

Your Base URL follows this pattern:

https://<RESOURCE_NAME>.services.ai.azure.com/api/projects/<PROJECT_NAME>

To find these values:

1. Open the Azure AI Foundry portal and navigate to your project.
2. Look at your browser's URL - it contains both values:

   https://ai.azure.com/build/overview?wsid=/subscriptions/.../resourceGroups/.../providers/Microsoft.MachineLearningServices/workspaces/<PROJECT_NAME>&tid=...

3. Your RESOURCE_NAME is the Azure AI Services resource linked to your project (visible in the Azure portal under your resource group).

API Key:

1. Go to the Azure portal and navigate to your Azure AI Services resource.
2. The URL will look like: https://portal.azure.com/#@.../resource/subscriptions/.../resourceGroups/<RG>/providers/Microsoft.CognitiveServices/accounts/<RESOURCE_NAME>/...
3. Find the keys section (the exact UI label may vary) and copy one of your API keys.
4. If you can't see the keys, ensure you have Owner, Contributor, or Cognitive Services Contributor role on the resource.

For more details, see Microsoft's documentation on Foundry endpoints.

Configure the integration

1. Go to the Data sources page.

2. Click + Data source and select Custom.

3. Under Select your installation method, choose Hosted by Port.

4. Configure the integration settings:

   Setting	Value
   Base URL	https://<RESOURCE_NAME>.services.ai.azure.com/api/projects/<PROJECT_NAME>
   Auth Type	api_key
   API Key Header	api-key
   API Key	Your API key from the Azure AI Foundry portal
   Pagination Type	cursor

5. After installation, configure the mapping in the integration's data sources page:

   Azure AI Foundry agent mapping (Click to expand)

   resources:
     - kind: /agents
       selector:
         query: "true"
         data_path: ".data"
         query_params:
           api-version: "v1"
       port:
         entity:
           mappings:
             identifier: .id
             title: .name
             blueprint: '"aiAgent"'
             properties:
               description: .versions.latest.description
               platform: '"azure-foundry"'
               status: .versions.latest.status
               model: .versions.latest.definition.model
               region: '"<YOUR_REGION>"'

6. Click Resync to discover your Azure agents.

Let's test it

After configuring your integrations, trigger a resync to populate your catalog:

1. Go to the Data sources page.

2. Find your cloud provider integration and click Resync.

3. Navigate to the AI Agent catalog page.

4. You should see your agents appearing from all connected cloud platforms.

Developers can now see all AI agents in one place, with key metadata like platform, status, model, and region visible at a glance.

Summary

You've built a centralized AI Agent Registry that:

• Discovers agents automatically from AWS Bedrock, AgentCore, and Azure AI Foundry.
• Provides a unified view of all agents across cloud platforms.
• Tracks key metadata including status, model, and region.

Next steps

• Connect your AI agents to Port's MCP Server for AI-powered workflows.
• Build an MCP Server Registry to manage MCP tools alongside your agents.
• Use Port's AI Assistant to query your agent catalog using natural language.
• Add a scorecard to track agent production readiness.

Related resources

• AWS Integration.
• Ocean Custom Integration.
• Port MCP Server.
• Manage MCP Server Registry.