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

Check out Port for yourself ➜ 

Build an AI Agent Registry

Implement with AI

Send this guide to your coding agent.

Prerequisite: Install Port MCP

Open in ClaudeOpen in CodexOpen in Cursor
Open plan mode if your tool supports it; otherwise present the plan below filled in and wait for my approval. Implement this Port guide in my org via MCP:

https://docs.port.io/guides/all/build-ai-agent-registry

Read the raw markdown version at https://docs.port.io/guides/all/build-ai-agent-registry.md - it contains every tab and code block without page markup.

Goal: get the guide's core flow working end-to-end in my org; adapting it to fit my existing setup takes priority over matching the guide 1:1.

Plan:
1. Confirm MCP is connected, in the right org, with sufficient permissions.
2. If the guide offers alternative implementation paths (tabs), pick the one matching my installed integrations and tools, confirm it with me, and implement only that path.
3. Diff the guide's data model (blueprints, properties, relations, workflows, actions, agents, automations, integrations, webhook data sources, secrets) against mine.
4. Propose adaptations for gaps, reusing existing blueprints/relations over guide-named duplicates.
5. Flag what needs a UI click, credential, or secret from me, testing MCP capability empirically before ruling anything out. If the guide has a "Set up via API" section, use it for anything MCP can't do before treating a step as UI-only.
6. Stop on any blocker and give me options. Approving this plan authorizes the writes it lists; pause only for writes beyond what's listed.

Build:
- Extend blueprint schema additively when upserting; don't remove or overwrite existing properties, and treat type conflicts as a blocker, not an auto-fix.
- Never print secret values into the chat or logs; ask me to set them in Port, or write them via the secrets API without echoing them back.
- List any mock data in the plan, minimal and labeled mock; once approved, seed it without re-asking, and tell me what you seeded.
- For anything the guide writes downstream (e.g. a webhook target), use a real entity, not a mock.
- For pages/widgets, use the real page identifier from the app URL, not a guessed slug.
- When you hit a UI step confirmed (not assumed) unsupported via MCP and not covered by the guide's API sections, pause, give exact clicks, then resume via MCP.
- Validate and give links after each meaningful step (only a tool-returned URL, no guessed paths); don't proceed if the last run wasn't a success.

Done:
- Run the guide's "Let's test it" steps where possible (e.g. execute a workflow test run) and confirm the expected output exists in Port.
- Summarize adaptations, seeded data, what was mocked or skipped, remaining UI steps, and how to verify.

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.

AI Agent Registry catalog with metadata columns

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:

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

  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.

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.

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​