How it works

How Solidus Agents works.

In four steps plus one verification call — from operator KYC to an on-chain, revocable agent credential.

Operator KYC Agent DID Identity NFT BBS+ credential Verification

Step 1

Operator KYC

One credential, reused for every agent the operator runs.

The human or org behind the agent completes KYC once at verify.solidus.network. See how it links →

Step 2

Agent DID

One SDK call issues did:solidus for the agent.

Every downstream credential and on-chain record points back to this identifier. See the call →

Step 3

Identity NFT

The DID is anchored on-chain as an ERC-8004 Identity NFT.

Solidus handles gas and signing — the NFT id and tx hash are the public record. See the anchor →

Step 4

BBS+ credential

Capabilities and scope, signed and anchored to the Validation Registry.

BBS+ lets a relying party see only the claim it needs. See selective disclosure →

1Step 1 · Operator KYC

Verify the operator, once.

Before an agent gets a credential, the human or org behind it completes operator KYC at verify.solidus.network. The result is a reusable KYC credential — you link it to every agent you run. Solidus Agents does not perform KYC itself; it consumes verify's credential.

verify.solidus.network

Terminal

1# Confirm the operator's KYC credential exists
2curl https://verify.solidus.network/credentials/me \
3  -H "Authorization: Bearer $SOLIDUS_OPERATOR_TOKEN"
4
5# → { "kyc": "verified", "credentialId": "vc_4kQ2…tHgAs" }

2Step 2 · Agent DID

Generate the agent's DID.

One SDK call registers the agent and issues its did:solidus. The DID is the stable identifier every downstream credential and on-chain record points back to.

1import { createAgentIdentity } from '@solidus-network/agent-identity';
2
3const solidus = createAgentIdentity({ baseUrl: 'https://agents.solidus.network', token });
4
5const agent = await solidus.createAgent({
6  capabilities: ['browse', 'pay'],
7});
8
9console.log(agent.did);
10// did:solidus:testnet:5dK3fP7vLm8Qw2xNz9Rb4YcJ6tHgAs

solidus.createAgent({...})did:solidus

3Step 3 · Identity NFT

Mint the ERC-8004 Identity NFT.

The DID is anchored to the ERC-8004 Identity Registry as an on-chain Identity NFT. Poll status until the anchor confirms; the returned NFT ID and tx hash are the public record.

anchor.ts

1const { anchor } = await agents.anchor(agent.did, {
2  chain: 'ethereum-mainnet',
3});
4
5// Poll until confirmed
6const status = await agents.anchorStatus(anchor.id);
7// { status: 'confirmed',
8//   nftId: 'eip155:1:0x9A3f…4b2C:8004:1420',
9//   tx: '0x7a3f…b21c', gas: '0.0021 ETH' }

did:solidusERC-8004 Identity RegistryIdentity NFT

4Step 4 · BBS+ credential

Issue a BBS+ credential.

Attach claims — capabilities, scoped permissions, operator linkage — and sign them as a BBS+ credential. BBS+ enables selective disclosure: a relying party sees only the claim it needs. The credential is anchored to the ERC-8004 Validation Registry.

issue-credential.ts

1const credential = await agents.issueCredential(agent.did, {
2  type: 'AgentCapability',
3  claims: {
4    scope: ['payments:execute', 'data:read'],
5    expiry: '2026-12-31T23:59:59Z',
6  },
7});
8// credential.id = 'cap_3fK9…tHgAs'
9// anchored → ERC-8004 Validation Registry

agent + claimsBBS+ signingValidation Registryon-chain proof

Selective disclosure

What the relying party actually sees.

The issued credential carries the full claim set. BBS+ lets the agent disclose only the subset a given relying party needs — the rest of the payload never leaves the wallet.

Full claim set (issued)

1{
2  "type": "AgentCapability",
3  "agent": "did:solidus:testnet:5dK3…tHgAs",
4  "operator": "did:solidus:…tHgAs",
5  "operatorKyc": "verified",
6  "network": "ethereum-mainnet",
7  "scope": ["payments:execute", "data:read"],
8  "expiry": "2026-12-31T23:59:59Z"
9}

Disclosed to the relying party

1{
2  "operatorKyc": "verified",
3  "network": "ethereum-mainnet",
4  "scope": ["payments:execute"]
5}

Verifying an agent — the RP side.

No Solidus account required. Verify against the on-chain Validation Registry.

Relying partyPublic verification API

validinvalid

verify.ts

1import { agents } from '@solidus-network/agent-identity';
2
3const result = await agents.verify('cap_3fK9…tHgAs');
4// { valid: true,
5//   agent: 'did:solidus:…tHgAs',
6//   scope: ['payments:execute'],
7//   anchoredAt: 'eip155:1:0x9A3f…4b2C:8004:1420' }

Every BBS+ credential is also dual-emitted as an EAS attestation with the same payload — EVM-native consumers like Verax and Karma3 see it with zero Solidus integration.

See integrations

Register your first agent in under 5 minutes.

One operator KYC. Every agent you run carries a portable, revocable credential — anchored to ERC-8004.

Get started Read the spec

Free for individual developers · Solidus testnet included · No card required