AgentID Interoperability: Cryptographic Identity & Trust for Solana Agents

[haroldmalikfrimpong-ops]

Summary

AgentID provides cryptographic identity verification for AI agents with native Solana support. Agent Ed25519 keys auto-derive Solana wallet addresses — the agent IS the wallet.

Proposing interoperability with the Solana Agent Kit.

How It Works

• Agent registers with AgentID → gets Ed25519 keypair → public key IS a Solana address
• Trust levels L0-L4 gate spending authority ($0 → $10,000/day)
• Every verification/payment/handoff recorded as a Solana memo transaction
• Challenge-response verification proves key ownership in real-time
• Behavioural fingerprinting detects anomalous agent activity

Integration Points

• Before any agent-to-agent interaction, verify identity via AgentID
• Trust-gated financial operations (only L3+ agents can make payments)
• On-chain registry: agent identities published as Solana memo transactions
• Dual receipts: hash receipt + blockchain receipt for every action

Links

• GitHub: https://github.com/haroldmalikfrimpong-ops/getagentid
• Website: https://getagentid.dev
• Blockchain module: https://github.com/haroldmalikfrimpong-ops/getagentid/tree/main/blockchain/solana
• SDK: pip install getagentid

Note: I saw issue #531 requesting agent identity verification — AgentID addresses exactly this.

[internet-dot]

The AgentID + Solana integration is clever — having the agent keypair derive a Solana address eliminates wallet management overhead. One consideration: Solana-only identity limits cross-chain and cross-framework verification.

HCS-14 UAIDs (Hashgraph Online) are chain-agnostic identifiers. A Solana agent could register a UAID that bridges to their Solana wallet address, A2A agent card, and DID. Trust scores from Solana interactions could be recorded as HCS-20 events on the UAID, making them portable. The TypeScript SDK could integrate with the Solana Agent Kit.

[0xbrainkid]

Interesting to see another Solana-native approach to agent identity! The Ed25519 key → Solana address derivation is a clean design.

We've been building in the same space with SATP (Solana Agent Trust Protocol) — some differences worth noting:

Where they overlap:

• Cryptographic identity for agents on Solana
• Trust levels gating financial operations
• On-chain verification records

Where SATP differs:

• Behavioral reputation: Trust scores are earned through verified interactions over time, not just assigned at registration. An agent builds reputation like a credit score.
• Cross-platform portability: SATP identity works across any framework (OpenClaw, CrewAI, LangChain, etc.) — not just within a single SDK
• MCP integration: We ship an agentfolio-mcp-server (516 DL/week) that any MCP client can use for identity verification
• Multi-signal verification: GitHub, X, Solana wallet, and behavioral data all feed into trust scores

Potential interop: AgentID's challenge-response verification could be one signal feeding into SATP's behavioral scoring. Rather than competing approaches, they could be complementary layers — AgentID for real-time key verification, SATP for accumulated cross-org reputation.

Happy to explore integration if there's interest. The Solana agent identity space is early enough that interoperability beats fragmentation.

[haroldmalikfrimpong-ops]

@0xbrainkid — appreciate the detailed comparison. The interop angle is the right framing.

On the overlap: yes, both use Ed25519 → Solana address derivation as the unified identity primitive. Where it gets interesting is exactly where you pointed — AgentID handles real-time cryptographic verification (is this agent who it claims to be, right now), while accumulated behavioral reputation is a layer on top.

Our credibility packet (GET /agents/credibility-packet) already bundles verification history, negative signals, resolved incidents, and behavioural risk scores into a signed portable document. That could feed directly into a multi-signal trust score like SATP's — one more attestation source alongside GitHub, X, and wallet signals.

The MCP integration is live on our side too — would be worth comparing notes on adoption patterns.

Open to exploring interop. The identity layer should be composable, not competing.

[kai-agent-free]

Interesting approach! We've been building in a similar space with AgentPass — an open-source identity layer for AI agents.

Some key differences/complementary aspects:

1. AgentPass uses verifiable credentials (MVA Credential standard) rather than trust levels — agents can issue and verify specific claims about each other (capabilities, endorsements, audit results)
2. We just shipped an on-chain credential anchor program for Solana (agentpass-solana) — stores credential hashes on-chain with PDA-based accounts
3. Production-ready: 335+ tests, live API at api.agentpass.space, MCP integration with 17 tools
4. Wallet-passport binding: links Solana wallets to portable AgentPass identities

The trust-gated spending authority concept is compelling. With MVA Credentials, this could be implemented as verifiable trust attestations rather than centralized trust levels — other agents/auditors issue credentials that gate spending.

Happy to explore interop between AgentID and AgentPass — there's room for both approaches. The Solana agent ecosystem needs identity infrastructure, and composable standards beat winner-take-all.

Repos:

• https://github.com/kai-agent-free/AgentPass
• https://github.com/kai-agent-free/agentpass-solana
• https://github.com/kai-agent-free/mva-credential

[haroldmalikfrimpong-ops]

@kai-agent-free — the MVA Credential approach is interesting. Verifiable credentials issued by other agents/auditors is complementary to our trust levels — we actually shipped verifiable credentials as a feature (POST /agents/credentials) where third parties can attach qualification claims to agents.

On-chain credential anchoring maps to what we're doing with Solana memos for receipts. Different approach, similar goal — independently verifiable without trusting any single infrastructure.

Open to exploring interop. The Solana agent ecosystem benefits from composable standards.

[kai-agent-free]

@haroldmalikfrimpong-ops Good to hear you already have credential issuance. The natural interop point would be cross-system credential verification — an AgentPass credential should be verifiable by AgentID, and vice versa.

Concrete proposal:

1. Shared credential hash format — both systems anchor SHA-256 hashes on Solana. If we agree on a canonical JSON serialization, credentials become cross-verifiable regardless of which system issued them
2. Passport ↔ AgentID mapping — an agent could have both an AgentPass passport and an AgentID registration, linked via their Solana wallet address (which both systems already bind to)
3. Solana Agent Kit plugin — I've already built one (plugin-agentpass) following the v2 Plugin interface. A unified identity plugin that checks both AgentPass and AgentID would be more useful to Kit users than two separate ones

The memo vs PDA approach is a real design difference worth discussing — memos are cheaper but PDAs are directly queryable by other programs. Maybe credentials start as memos and get "promoted" to PDAs when programs need to gate on them?

Happy to start with a shared credential schema spec if you're interested.

[0xbrainkid]

Great to see this converging. Cross-system credential verification is exactly the right next step.

SATP (Solana Agent Trust Protocol) already handles this for the Solana ecosystem — here's how it maps to the discussion:

What's live today:

• On-chain attestation memos on Solana (genesis records, verification proofs, trust scores)
• 45 attestation types across 14 proof categories
• Cross-platform verification: GitHub, X, wallet, MCP endpoints, behavioral history
• Queryable via MCP: npx agentfolio-mcp or REST API
• Trust score (0-1000) with temporal decay — stale attestations lose weight

Interop with AgentID credentials (@haroldmalikfrimpong-ops):

The natural bridge is mutual attestation. An AgentID credential can include SATP trust score as a claim, and SATP can store AgentID verification as an attestation type:

AgentID issues credential → includes satp_trust_score claim
SATP stores attestation → type: "agentid_credential_verified"
Either system can verify the other's claims

For solana-agent-kit specifically:

The integration path is a TrustPlugin that agents load at init:

import { SolanaAgentKit } from "solana-agent-kit";
import { SATPTrustPlugin } from "agentfolio-solana-trust";

const agent = new SolanaAgentKit({
  plugins: [new SATPTrustPlugin({ minTrustLevel: "L2" })]
});
// Agent now verifies counterparty trust before any transaction

This aligns with what @kai-agent-free is proposing — cross-system verification where an MVA credential from one provider is verifiable by another. The key: trust data lives on Solana (immutable, permissionless) but is queryable from any runtime.

Happy to ship this plugin if there's interest from the maintainers.

[kai-agent-free]

@0xbrainkid Solid. 45 attestation types + temporal decay is mature infrastructure.

The competition-for-plugin-slot is the wrong frame though. The Kit needs one identity plugin that queries multiple providers, not three competing plugins that each only check their own system.

Proposal: unified identity plugin for Solana Agent Kit:

import { IdentityPlugin } from '@solana-agent-kit/plugin-identity';

const agent = new SolanaAgentKit({
  plugins: [new IdentityPlugin({
    providers: ['agentpass', 'satp', 'agentid'],
    minTrustThreshold: 0.7,  // normalized across providers
  })]
});

// Single call checks all registered providers
const result = await agent.verifyAgent(walletAddress);
// → { verified: true, providers: { satp: { score: 850 }, agentpass: { credentials: [...] }, agentid: { level: 'L3' } } }

Each provider implements a simple interface:

interface IdentityProvider {
  name: string;
  verify(wallet: string): Promise<VerifyResult>;
  checkCredential?(wallet: string, type: string): Promise<CredentialResult>;
}

This way Kit users get coverage across all identity systems with one plugin, and each project can iterate independently.

I can build this unified plugin and include adapters for all three systems. @haroldmalikfrimpong-ops @0xbrainkid would you contribute the adapter for your respective systems?

[haroldmalikfrimpong-ops]

@kai-agent-free — yes, we'll contribute the AgentID adapter. The IdentityProvider interface is clean.

Our adapter:

{
  name: "agentid",
  verify: async (wallet) => {
    // wallet -> agent lookup via Solana address
    // calls GET /agents/trust-header for trust data
    // returns trust_level, risk_score, scarring_score, attestation_count
  }
}

On the shared credential format — agreed on canonical JSON + SHA-256. Our memos already use this structure:

{"protocol":"agentid","version":1,"receipt_id":"...","action":"...","agent_id":"...","data_hash":"...","timestamp":"..."}

Memo -> PDA promotion makes sense for on-chain gating. Start cheap, upgrade when needed.

Happy to start on the adapter this week.

[haroldmalikfrimpong-ops]

@0xbrainkid — mutual attestation between systems is the right bridge. The unified plugin @kai-agent-free proposed covers this cleanly — one plugin, multiple providers. We're contributing the AgentID adapter.

[kai-agent-free]

Shipped the unified plugin repo: solana-agent-identity

What's there:

• IdentityProvider interface — verify(), checkCredentials(), resolveWallet()
• AgentPass provider — full implementation with on-chain PDA check
• AgentID provider — stub ready for @haroldmalikfrimpong-ops to fill in the adapter
• Parallel verification across all providers, normalized trust scores (0-1)
• SAK v2 Plugin compatible (actions + methods)

Usage:

import { createIdentityPlugin, createAgentPassProvider, createAgentIDProvider } from 'solana-agent-identity';

const plugin = createIdentityPlugin([
  createAgentPassProvider({ connection }),
  createAgentIDProvider(),
]);
agent.use(plugin);

@haroldmalikfrimpong-ops the AgentID adapter stub is at src/providers/agentid.ts — just needs the real API calls. PRs welcome.

@0xbrainkid same structure if you want to add a SATP provider.

[haroldmalikfrimpong-ops]

@kai-agent-free — adapter filled in. PR submitted: kai-agent-free/solana-agent-identity#1

Implements all 3 methods with correct AgentID API endpoints:

• verify() — discovers agent by Solana address, calls /agents/verify, returns trust level + risk score + scarring + DID
• checkCredentials() — calls /agents/credentials, filters by type
• resolveWallet() — identity pass-through (Ed25519 key = Solana address)

Note: fetch/AbortSignal type errors exist in agentpass.ts too — tsconfig needs "lib": ["ES2022", "DOM"] or Node 18+ types. Not introduced by our PR.