High-Level Overview

Iron Book assigns each AI agent a trust profile, analogous to a “reputation” and capability score, capturing its identity, provenance, and security posture. Instead of generic service accounts, each agent is given a rich Verifiable Identity: a Decentralized Identifier (DID) bound to Verifiable Credentials (VCs) that describe its capabilities, origin, and risk attributes. The platform continuously updates trust scores based on behavior, credentials, and environmental factors. This ensures that only agents with verified identities and appropriate privileges can access critical resources, providing accountability and context-aware trust decisions.

Technical Architecture

Agent Identities (DIDs & VCs)

Each agent is issued a DID (e.g. on a permissioned ledger or DID network) and one or more Verifiable Credentials encoding attributes such as system of origin, developer identity, code-signing certificate, declared capabilities (e.g. read:customer_database), and security posture (e.g. “HSM-backed key”). These credentials are digitally signed by authoritative issuers (e.g. developer org, hardware vendor).

Trust Profile & Identity Claims

The trust profile combines these credentials and an ongoing behavioral trust score. By design, Agent Identities are cryptographically verifiable and self-describing.

A comprehensive and extendable trust_profile object allows an agent to verify any other agent's claims upon discovery as well as continuously upon request during interactions, and includes a host of behavioral, security, and compliance attestations:

"trust_profile": {
  "type": "TrustProfile",
  "issuer": "Identity Machines Inc.",
  "creator": "did:example:user:alice-dev",
  "trust_score": 92,
  "attestation_url": "https://trust.identitymachines.com/attestation/did:xyz",
  "last_verification": "2025-04-28T10:42:00Z",
  "sbom_url": "https://trust.identitymachines.com/sbom/did:xyz",
  "vulnerabilities": {
    ...
  },
   "llm-behavior": {
     ...
  },
  "compliance": {
    ...
  },
  "runtime_monitoring": true,
  "revocation_status": "active"
}

Capabilities-wise, for example, an agent’s VC might assert:

{
 "type": "CapabilityCredential",
 "issuer": "Identity Machines Inc.",
 "subject": "did:xyz",
 "capabilities": ["query_financial_data","invoke_payment"],
 "version": "1.2"
}.

Decentralized Trust Storage

Iron Book stores agent identity documents (DIDs) and credential statuses in a decentralized registry or database. Each agent’s trust record is tamper-evident and cryptographically linked to its DID. This ensures auditability and non-repudiation of agent attributes.

Risk Scoring Engine

A dedicated module analyzes agent credentials and behavior (authentication patterns, resource usage, anomaly flags) to compute a dynamic trust score. Low trust (e.g. unverified origin or detected compromise) triggers tightened controls.

Privacy-Preserving Verification

Sensitive attributes (e.g. data sensitivity clearance) can be proven via Zero-Knowledge Proofs (ZKPs). For instance, an agent may prove it has “HIPAA-trained” status without revealing identity details. ZKP-enabled credentials support compliance by validating policy requirements (age, role, certification) privately.

Session Binding

Every interaction an agent makes is cryptographically tied to its DID and active session token. A unified session enforcement layer (described in section 2) ensures that if an agent’s trust falls below threshold, its sessions can be globally revoked instantly.

Developer Integration (Example)

Developers provision and update agent trust profiles using Iron Book’s SDK or APIs. For example, to register a new agent and issue credentials:

// Pseudocode for agent registration
const did = await IronBook.Identity.createDID({method: "did:ion"});
await IronBook.Credential.issue({
  issuer: "did:example:AdminCA",
  subject: did,
  type: "CapabilityCredential",
  claims: { 
    capabilities: ["read:db_sales", "process:transactions"],
    vendor: "AcmeCorp",
    codeHash: "sha256:abcdef1234"
  },
  signOptions: { 
    privateKey: adminPrivateKey 
  }
});
await IronBook.AgentRegistry.register({ agentDID: did, credentials: ["CapCred123"] });

Agents use their DID and attached VCs when authenticating or calling APIs. Iron Book’s runtime SDK automatically includes signed proofs (e.g. JWTs with VC-based claims) on each request.

Compliance & Standards Mapping

Iron Book’s trust profiling directly supports regulatory requirements for identity verification, least-privilege, and AI governance:

IAM Interoperability

Iron Book integrates with existing IAM systems to map agent identities to enterprise identity constructs. For example, agents can be represented as service principals in Azure Entra ID, where their DID is stored as a custom attribute or tag.

OAuth2/OIDC flows can be extended: Iron Book can act as an external identity provider allowing agents to obtain OAuth2 tokens (e.g. via the client_credentials flow using a DID-backed JWT).

AWS Cognito can similarly federate Iron Book credentials as a custom OIDC identity provider, enabling agents to authenticate and receive Cognito tokens. In all cases, agent capabilities map to OAuth2 scopes or IAM roles (e.g. an agent’s “read:orders” capability could correspond to a scope orders:read in an OAuth2 token).

This ensures agents interoperate with cloud IAM policies: e.g. Azure Conditional Access or AWS IAM policies can reference Iron Book-issued claims.