> For the complete documentation index, see llms.txt.
Skip to main content

Check out Port for yourself ➜ 

Build an AI Agent Registry

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, Azure AI Foundry, and GCP Vertex AI in one place.

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

  4. Agent Sprawl Prevention - Understand what agents exist across teams to reduce duplication and promote collaboration.

Prerequisites​

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

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

    • 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.

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": "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", "gcp-vertex"],
            "enumColors": {
              "aws-bedrock": "orange",
              "aws-agentcore": "orange",
              "azure-foundry": "blue",
              "gcp-vertex": "green"
            },
            "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.

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"
        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"
        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.

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, Azure AI Foundry, and GCP Vertex AI
  • Provides a unified view of all agents across cloud platforms
  • Tracks key metadata including status, model, and region
  • Prevents agent sprawl by making existing agents discoverable

Next steps​

  • Add a scorecard to track agent production readiness
  • Create self-service actions to register or provision new agents
  • Set up automations to notify teams when agent status changes
  • Extend the blueprint with relations to teams or services for ownership tracking