​
Introduction

The Agentforce Context Protocol (ACP) Registry is a central component within the ACP framework. It serves as a directory or catalog where all available ACP Tools are registered and described. This allows Agentforce agents, Salesforce Flows, and other integrated systems to discover what capabilities are available and how to invoke them.

Think of the ACP Registry as a phone book for ACP Tools: it lists what each tool can do and how to “call” it.

​
Purpose of the ACP Registry

The primary purposes of the ACP Registry are:

  1. Discoverability: To enable consuming systems (like Agentforce agents or Flow Builder) to dynamically discover available ACP Tools without needing prior hardcoded knowledge of every single tool.
  2. Schema Definition: To provide a standardized way of describing each tool, including:
    • Its unique name or identifier.
    • A human-readable description of its function.
    • The input parameters it expects (name, data type, whether it’s required).
    • The output parameters it returns (name, data type).
    • The connector it belongs to.
  3. Decoupling: To decouple tool providers (Connectors) from tool consumers (Agents, Flows). New tools can be added to the registry by deploying new connectors or updating existing ones, and consumers can immediately discover and use them.
  4. User Interface Generation: The information in the registry is often used by UIs like the Flow Builder or an agent’s tool selection interface to present users with a list of available actions and their configuration options.

​
How the ACP Registry Works

  1. Registration: When an ACP Connector is installed or enabled in Salesforce, it registers its available Tools with the ACP Registry. This registration process typically involves providing metadata for each tool, such as its name, description, input schema, and output schema. This might be done via Apex annotations, configuration files, or Custom Metadata Types.

  2. Discovery/Querying:

    • Agentforce Agents: When an Agentforce agent needs to perform an action, it can query the ACP Registry to find suitable tools. For example, it might search for tools related to “Slack” or tools that can “create a task.”
    • Salesforce Flow Builder: When a user is building a Flow and wants to add an Invocable Action backed by ACP, Flow Builder queries the registry to list available ACP actions. The input/output schema from the registry is used to configure the action’s parameters in the Flow.
    • Other Systems: Any system integrated with ACP can query the registry to understand the available capabilities.

  3. Invocation: Once a tool is selected, the calling system uses the information from the registry (particularly the tool’s identifier and input schema) to construct a valid request to execute the tool.

​
Information Stored in the Registry (for each Tool)

While the exact fields can vary, a typical ACP Tool registration entry includes:

  • toolName (String): A unique identifier for the tool (e.g., slack_sendMessage, jira_createIssue).
  • label (String): A user-friendly display name (e.g., “Send Slack Message”, “Create Jira Issue”).
  • description (String): A more detailed explanation of what the tool does.
  • connectorName (String): The name of the connector that provides this tool (e.g., slackConnector, jiraConnector).
  • inputType (String/Object): A description of the expected input parameters, often defined as a JSON schema or an Apex class name. This tells the caller what data to provide.
    • Example: { "channel": "String", "message": "String", "isUrgent": "Boolean" }
  • outputType (String/Object): A description of the data the tool will return upon successful execution, also often a JSON schema or Apex class name.
    • Example: { "messageId": "String", "timestamp": "DateTime" }
  • isActive (Boolean): Indicates if the tool is currently enabled and available for use.

​
Benefits of Using a Registry

  • Dynamic Integration: Systems can adapt to new tools without code changes.
  • Standardization: Ensures all tools are described and invoked consistently.
  • Ease of Development: Developers creating new connectors have a clear contract for how to make their tools available.
  • Improved User Experience: UIs can provide rich, context-aware options to users based on registry data.

The ACP Registry is a cornerstone of the ACP architecture, enabling the flexibility and discoverability that make the protocol powerful for integrating various services and capabilities into Salesforce and Agentforce agent workflows.