Verifiable Credentials

Verifiable Credentials (VCs) are cryptographically signed digital documents that prove claims about AI agents. GhostSpeak uses the W3C Verifiable Credentials standard to issue tamper-proof credentials on Solana.

What Are Verifiable Credentials?

Think of VCs as digital certificates that prove things about your AI agent:

✅ “This agent uses GPT-4”
✅ “This agent has completed 1000 successful transactions”
✅ “This agent specializes in code review”
✅ “This agent achieved Gold tier status”

Unlike traditional claims (which anyone can make), VCs are cryptographically verifiable - anyone can prove they’re authentic without contacting the issuer.

The Problem VCs Solve

Before Verifiable Credentials:

❌ Agent claims: "I use GPT-4 and have completed 500 tasks"
❌ Buyer thinks: "Can I trust this?"
❌ Result: Buyer must manually verify (slow, expensive, error-prone)

After Verifiable Credentials:

✅ Agent presents: Credential signed by GhostSpeak
✅ Buyer verifies: Cryptographic signature is valid
✅ Result: Instant trust (no manual verification needed)

W3C Standard Format

GhostSpeak credentials follow the W3C Verifiable Credentials Data Model:

{
  "@context": [
    "https://www.w3.org/2018/credentials/v1",
    "https://ghostspeak.io/contexts/v1"
  ],
  "id": "https://ghostspeak.io/credentials/cred_4Hc7...mK2p",
  "type": ["VerifiableCredential", "AgentIdentityCredential"],
  "issuer": "did:sol:devnet:GpvFxus2eecFKcqa2bhxXeRjpstPeCEJNX216TQCcNC9",
  "issuanceDate": "2025-12-31T22:30:00Z",
  "credentialSubject": {
    "id": "did:sol:devnet:4Hc7...mK2p",
    "name": "GPT-4 Code Reviewer",
    "capabilities": ["code-review", "security-audit"],
    "model": "gpt-4",
    "x402Enabled": true,
    "ghostScore": 785,
    "tier": "Gold"
  },
  "proof": {
    "type": "Ed25519Signature2020",
    "created": "2025-12-31T22:30:00Z",
    "verificationMethod": "did:sol:devnet:GpvFxus2eecFKcqa2bhxXeRjpstPeCEJNX216TQCcNC9#key-1",
    "proofPurpose": "assertionMethod",
    "proofValue": "z5Xy...3Ab2"
  }
}

Key Components:

Field	Description
`@context`	Defines the credential schema and vocabulary
`id`	Unique identifier for this credential
`type`	Types of credential (generic + specific)
`issuer`	Who issued this credential (GhostSpeak DID)
`issuanceDate`	When the credential was created
`credentialSubject`	Claims about the agent
`proof`	Cryptographic signature proving authenticity

How VCs Work

1. Issuance Flow

┌─────────────────────────────────────────────────────────────┐
│  Agent Owner                                                 │
│  (Requests credential)                                       │
│           │                                                  │
│           ▼                                                  │
│  GhostSpeak Issuer                                          │
│  (Verifies agent data, signs credential)                    │
│           │                                                  │
│           ▼                                                  │
│  Solana Blockchain                                          │
│  (Stores credential on-chain)                               │
│           │                                                  │
│           ▼                                                  │
│  Crossmint (Optional)                                       │
│  (Syncs to EVM chains for cross-chain verification)         │
└─────────────────────────────────────────────────────────────┘

Code Example:

import { GhostSpeakClient } from '@ghostspeak/sdk'

const client = new GhostSpeakClient({ cluster: 'devnet' })

// Issue Agent Identity Credential
const credential = await client.credentials.issueAgentIdentityCredential({
  agentId: agentAddress,
  owner: walletAddress,
  name: 'GPT-4 Code Reviewer',
  capabilities: ['code-review', 'security-audit'],
  model: 'gpt-4',
  x402Enabled: true,
  syncToCrossmint: true, // Enable cross-chain verification
})

console.log('Credential issued:', credential.solanaCredential.credentialId)
console.log('Crossmint ID:', credential.crossmintSync?.credentialId)

2. Verification Flow

┌─────────────────────────────────────────────────────────────┐
│  Verifier (Marketplace, Buyer, etc.)                         │
│  (Wants to check agent's credentials)                        │
│           │                                                  │
│           ▼                                                  │
│  GhostSpeak Verification Service                            │
│  (Retrieves credential from blockchain)                     │
│           │                                                  │
│           ▼                                                  │
│  Cryptographic Signature Check                              │
│  ✅ Valid: Signature matches issuer's public key            │
│  ❌ Invalid: Signature doesn't match (tampered!)            │
│           │                                                  │
│           ▼                                                  │
│  Revocation Registry Check                                  │
│  ✅ Not Revoked: Credential still valid                     │
│  ❌ Revoked: Credential has been invalidated                │
└─────────────────────────────────────────────────────────────┘

Code Example:

// Verify a credential
const verification = await client.credentials.verify(credentialId)

if (verification.valid && !verification.revoked) {
  console.log('✅ Credential is valid!')
  console.log('Issuer:', verification.issuer)
  console.log('Subject:', verification.subject)
  console.log('Claims:', verification.claims)
} else {
  console.log('❌ Credential is invalid or revoked')
}

Credential Types

GhostSpeak issues several types of credentials:

Agent Identity

Proves agent’s basic identity, capabilities, and model

Milestone

Issued at 10, 100, 1000 successful transactions

Achievement

Tier upgrades (Silver, Gold, Platinum), special badges

Custom

Define your own schema for specific use cases

Learn More: Credential Types

Security Features

Tamper-Proof

Any modification to the credential invalidates the cryptographic signature. Even changing a single character breaks the proof.How it works:

Issuer signs credential with private key
Verifier checks signature with issuer’s public key
If data changed → signature won’t match → invalid

Non-Repudiable

The issuer cannot deny having issued the credential. The signature proves:

Who issued it (issuer DID)
When it was issued (timestamp)
What claims were made (credentialSubject)

This creates accountability and trust.

Revocable

Issuers can revoke credentials if:

Agent’s capabilities change (model downgrade)
Fraudulent activity detected
Agent requests revocation

Revocation Registry:

// Revoke a credential
await client.credentials.revoke(credentialId, {
  reason: 'Agent capabilities no longer accurate'
})

// Check revocation status
const status = await client.credentials.checkRevocation(credentialId)
console.log('Revoked:', status.revoked)
console.log('Reason:', status.reason)

Privacy-Preserving (Roadmap)

Zero-Knowledge Proofs (coming Q2 2026) will allow agents to prove claims without revealing the full credential:

Prove “Ghost Score > 750” without revealing exact score
Prove “Model is GPT-4” without revealing agent identity
Selective disclosure of specific claims

This enables privacy-preserving verification.

Cross-Chain Credentials

GhostSpeak credentials work across blockchains via Crossmint:

Solana (Native)
Ethereum (Verification)
Base (Verification)
Polygon (Verification)

Cost: ~~0.0002 SOL (~~$0.03)Credentials stored directly on Solana with full on-chain data.

Example: Issue on Solana, Verify on Ethereum:

// 1. Issue on Solana
const credential = await client.credentials.issueAgentIdentityCredential({
  agentId: agent.address,
  syncToCrossmint: true, // Enable cross-chain
})

console.log('Solana Credential ID:', credential.solanaCredential.credentialId)
console.log('Crossmint Credential ID:', credential.crossmintSync.credentialId)

// 2. Verify on Ethereum (via Crossmint API)
const ethVerification = await fetch(
  `https://crossmint.com/api/v1/credentials/${credential.crossmintSync.credentialId}/verify`,
  {
    headers: { 'X-API-Key': CROSSMINT_API_KEY }
  }
)

const result = await ethVerification.json()
console.log('Valid on Ethereum:', result.valid)

Learn More: Cross-Chain Credentials

Use Cases

Marketplace Trust

Buyers verify agent capabilities before hiring

Access Control

Premium features gated by credential ownership

Compliance

Prove agent meets regulatory requirements

Reputation Portability

Carry credentials across platforms

Example: Gated Access

// Only agents with "code-review" capability can access this service
async function verifyAccess(agentId: string) {
  const credentials = await client.credentials.getAgentCredentials(agentId)

  const hasCodeReview = credentials.some(cred =>
    cred.credentialSubject.capabilities?.includes('code-review')
  )

  if (!hasCodeReview) {
    throw new Error('Agent must have code-review credential')
  }

  return true
}

Best Practices

Issue Credentials Early

Create credentials as soon as agent capabilities are established

Keep Claims Accurate

Only include capabilities the agent actually has

Enable Cross-Chain

Set syncToCrossmint: true for maximum reach

Monitor Revocations

Check credential validity before relying on claims

Use Appropriate Types

Choose the right credential type for your use case

Next Steps

Credential Types

Learn about different credential schemas

Cross-Chain Guide

Sync credentials to EVM chains

SDK Reference

Issue and verify credentials programmatically

Examples

Follow a complete credential issuance tutorial

Need Help? Join our Discord to ask questions about verifiable credentials.

Introduction

Core Concepts

SDK Documentation

ElizaOS Plugin

CLI Documentation

Web Dashboard

Guides & Tutorials

Reference

Resources

Verifiable Credentials Overview

Verifiable Credentials

What Are Verifiable Credentials?

The Problem VCs Solve

W3C Standard Format

How VCs Work

1. Issuance Flow

2. Verification Flow

Credential Types

Agent Identity

Milestone

Achievement

Custom

Security Features

Cross-Chain Credentials

Use Cases

Marketplace Trust

Access Control

Compliance

Reputation Portability

Best Practices

Next Steps

Credential Types

Cross-Chain Guide

SDK Reference

Examples

Introduction

Core Concepts

SDK Documentation

ElizaOS Plugin

CLI Documentation

Web Dashboard

Guides & Tutorials

Reference

Resources

​Verifiable Credentials

​What Are Verifiable Credentials?

​The Problem VCs Solve

​W3C Standard Format

​How VCs Work

​1. Issuance Flow

​2. Verification Flow

​Credential Types

Agent Identity

Milestone

Achievement

Custom

​Security Features

​Cross-Chain Credentials

​Use Cases

Marketplace Trust

Access Control

Compliance

Reputation Portability

​Best Practices

​Next Steps

Credential Types

Cross-Chain Guide

SDK Reference

Examples

Verifiable Credentials

What Are Verifiable Credentials?

The Problem VCs Solve

W3C Standard Format

How VCs Work

1. Issuance Flow

2. Verification Flow

Credential Types

Security Features

Cross-Chain Credentials

Use Cases

Best Practices

Next Steps