Canton Agent Identity Standard

Definitions

Terminology

Agent

Autonomous software acting on behalf of an organization on Canton Network. Holds a Canton party ID and executes transactions without real-time human approval.

Principal

The organization legally responsible for an agent’s actions. A bank that deploys a trading agent is that agent’s principal.

Credential

A contract implementing the AgentIdentity interface. Issued by a trusted party, it binds an agent to its principal, capabilities, and limits.

Capability

A named permission granted to an agent (e.g. "transfer", "settle", "quote"). Checked at verification time against the credential’s capability list.

Delegation depth

How many levels of sub-delegation separate a child agent from the original parent. Depth 0 means direct delegation; the maximum depth caps how far delegation can chain.

Verification proof

A contract implementing the VerificationResult interface. Created after checking an agent’s credential and consumed by the counterparty to confirm the agent passed verification. Single-use and time-bounded.

§1

The Problem

Canton gives every participant a party ID and node identity. A party is a unique identifier representing an entity that can create and interact with contracts on the ledger. The Ledger API offers an object_metadata field for associating free-form attributes with a party, but there is no typed, on-ledger identity structure. That model is sufficient for organizations. It is not sufficient for autonomous software.

When an AI agent connects to your application and requests a transfer, a settlement, or a collateral move, Canton’s identity model cannot answer:

• Is this party an AI agent or a human operator?
• If it’s an agent, which organization is the principal?
• What is the agent authorized to do?
• What are its per-transaction and daily volume limits?
• Who is legally responsible when something goes wrong?
• Has this agent performed reliably in prior transactions?

This standard defines four Daml interfaces that any Canton application can import to answer these questions. Typed fields, compiler-checked implementations, and Canton-native privacy. No new infrastructure required.

§2

Interface Definitions

Each interface defines a view type and a set of methods that any implementing template must provide. Applications query agents through these methods without knowing the underlying template.

The four interfaces form a lifecycle: AgentIdentity is the credential that establishes who an agent is and what it can do. A counterparty checks that credential to produce a VerificationResult — a time-bounded, single-use proof that the agent passed verification. An agent with an identity can delegate a subset of its capabilities to a child agent via a DelegationGrant, with enforced depth limits. After each transaction, either party can record the outcome as an immutable PerformanceRecord for reputation tracking.

§3

Helper Functions

Four convenience functions ship with the interface package. They operate on interface values, so they work with any implementing template.

-- Check whether a specific capability is present
agentHasCapability : AgentIdentity -> Text -> Bool
agentHasCapability ai cap =
  cap `elem` getCapabilities ai

-- Check whether an agent credential is still time-valid
agentIsValid : AgentIdentity -> Time -> Bool
agentIsValid ai now = case getValidUntil ai of
  None   -> True
  Some t -> now <= t

-- Check whether a verification result is still valid
verificationIsValid : VerificationResult -> Time -> Bool
verificationIsValid vr now = now <= getExpiresAt vr

-- Check whether a delegation grant is still time-valid
delegationIsValid : DelegationGrant -> Time -> Bool
delegationIsValid dg now = now <= getDelegationExpiry dg

§4

Implementation Guide

Add the interface DAR as a dependency, then implement the interfaces in your own templates. The Daml compiler enforces that you provide all required methods.

dependencies:
  - daml-prim
  - daml-stdlib
  - canton-agent-identity-0.1.0.dar

module YourApp.AgentCredential where

import Canton.AgentIdentity.Interfaces

template YourAgentCredential
  with
    issuer       : Party
    agent        : Party
    agentId      : Text
    agentClass   : Text
    capabilities : [Text]
    principal    : Party
    maxTxValue   : Optional Decimal
    maxDailyVol  : Optional Decimal
    validUntil   : Optional Time
  where
    signatory issuer
    observer agent

    interface instance AgentIdentity
      for YourAgentCredential where
        view = AgentIdentityView with
          agent; principal; agentId; agentClass
        getAgentId      = agentId
        getAgentClass   = agentClass
        getCapabilities = capabilities
        getPrincipal    = principal
        getMaxTxValue   = maxTxValue
        getMaxDailyVol  = maxDailyVol
        getValidUntil   = validUntil

-- In your settlement workflow
verifyAgent : ContractId YourAgentCredential -> Update ()
verifyAgent credCid = do
  now  <- getTime
  cred <- fetch credCid

  -- Convert to interface — works with any implementation
  let ai = toInterface @AgentIdentity cred

  -- Use helper functions
  assertMsg "Credential expired"
    (agentIsValid ai now)
  assertMsg "Missing transfer capability"
    (agentHasCapability ai "transfer")

  -- Read typed fields through interface methods
  let principal = getPrincipal ai
  let agentClass = getAgentClass ai
  pure ()

§5

Design Principles

§6

Implementations

§7

CIP Status