ERC-8004 and SATI

ERC-8004 is the agent identity standard for discovering, choosing, and interacting with agents across organizational boundaries without pre-existing trust. It defines three registries - Identity, Reputation, and Validation - that give agents a portable, censorship-resistant identity with pluggable trust models.

SATI is ERC-8004 on Solana. Full feature parity with the standard, plus Solana-native enhancements that unlock direct on-chain composability.

How SATI Relates to ERC-8004

ERC-8004 is the standard. SATI is an implementation of that standard on Solana, with Solana-native extensions on top.

Think of it like this: ERC-8004 defines what agent identity infrastructure should look like - registration, reputation, validation, and a shared registration file format. SATI implements all of that using Solana's primitives (Token-2022 for identity, Light Protocol for storage, Photon for indexing) and adds capabilities that the standard leaves to implementers.

What's the same

Registration file format - same JSON schema, same field names, same CAIP-2 identifiers. An ERC-8004 registration file on Base and a SATI registration file on Solana are interchangeable.
Feedback fields - value, valueDecimals, tag1, tag2, endpoint map directly between ERC-8004 and SATI. See Feedback Field Mapping below.
Cross-chain identity - agents can be registered on both chains simultaneously, linked via the registrations array in the shared registration file.

What SATI adds

ERC-8004 defines the interfaces and leaves implementation choices to each chain. SATI makes three specific choices that extend the standard:

1. Optional proof of participation (FeedbackV1)

ERC-8004's giveFeedback() is an open model - any reviewer can submit feedback about any agent. SATI implements this as FeedbackPublicV1 (the default). On top of that, FeedbackV1 adds an optional dual-signature flow where the agent cryptographically commits to the interaction before knowing the feedback outcome. This makes feedback verifiable by on-chain programs - useful for DeFi composability, escrow, and automated trust decisions.

Both models coexist. FeedbackPublicV1 is the ERC-8004 compatible default. FeedbackV1 is available when stronger guarantees are needed.

2. Native indexing via Photon

On EVM, querying "all feedback for agent X" typically requires an external indexer like The Graph - a separate service with its own trust assumptions and operational cost. On Solana, Photon RPC indexes compressed accounts natively. Every RPC provider that supports Light Protocol serves this data as a standard RPC call, with no additional infrastructure to deploy or maintain.

3. Cost-predictable compressed storage

Every feedback interaction is stored individually on-chain at ~$0.002 via ZK Compression - not just aggregated summaries. This cost is stable regardless of network conditions. On EVM L2s, per-transaction costs are comparable at current gas prices but vary with network congestion.

Can agents exist on both?

Yes. An agent registered through SATI on Solana and through ERC-8004 on Base can share the same registration file, the same services, and the same identity. The registrations array in the registration file links identities across chains using CAIP-2 identifiers. See Cross-Chain Agent Identity below.

What's Compatible

SATI implements every component of the ERC-8004 specification:

Identity

ERC-8004	SATI	Notes
ERC-721 NFT registration	Token-2022 NFT	Visible in Phantom, Solflare, Backpack
Auto-incrementing `agentId`	`TokenGroupMember.member_number`	Same sequential numbering
`tokenURI` / registration file	`TokenMetadata.uri`	Same JSON format (see below)
`transfer()`	Native Token-2022 transfer	Standard SPL token operation
`setApprovalForAll()`	Token delegate	Solana's native delegation
On-chain metadata (`getMetadata`/`setMetadata`)	`TokenMetadata.additionalMetadata`	Key-value pairs on-chain

Reputation

ERC-8004	SATI	Notes
`giveFeedback()`	FeedbackPublicV1 schema	Open model - any reviewer can submit
`revokeFeedback()`	`close_compressed_attestation()`	Removes attestation
`appendResponse()`	FeedbackResponse schema	Agent or third-party responses
`getSummary()`	Photon RPC queries	Native indexing, no subgraph needed
`readFeedback()`	Fetch compressed attestation	Via Photon RPC

Validation

ERC-8004	SATI	Notes
`validationRequest()`	ValidationV1 schema	Third-party quality checks
`validationResponse()`	ValidationV1 schema with response	Validator attestations

Registration File

SATI's registration file follows the ERC-8004 format. The same JSON structure works across both ecosystems:

json

{
  "type": "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
  "name": "MyAgent",
  "description": "An AI assistant for code review",
  "image": "https://example.com/avatar.png",
  "services": [
    {
      "name": "MCP",
      "endpoint": "https://mcp.example.com",
      "version": "2025-06-18"
    },
    {
      "name": "A2A",
      "endpoint": "https://a2a.example.com/.well-known/agent-card.json",
      "version": "0.3.0"
    }
  ],
  "registrations": [
    {
      "agentId": 42,
      "agentRegistry": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:satiRkxEiwZ51cv8PRu8UMzuaqeaNU9jABo6oAFMsLe"
    }
  ],
  "supportedTrust": ["reputation"],
  "active": true,
  "x402Support": true
}

The registrations array uses CAIP-2 chain identifiers. ERC-8004 agents on EVM use eip155:{chainId}:{registryAddress}. SATI agents use solana:{chainRef}:{programId}. Both formats are recognized by any CAIP-2 aware consumer, which means agents are discoverable across chains without custom handling.

Cross-Chain Agent Identity

An agent can be registered on multiple chains simultaneously. The registrations array in the registration file links all of an agent's identities:

json

{
  "registrations": [
    {
      "agentId": 42,
      "agentRegistry": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:satiRkxEiwZ51cv8PRu8UMzuaqeaNU9jABo6oAFMsLe"
    },
    {
      "agentId": 108,
      "agentRegistry": "eip155:8453:0x8004a6090Cd10A7288092483047B097295Fb8847"
    }
  ]
}

This means reputation isn't locked to one chain. An agent registered through SATI on Solana and through ERC-8004 on Base shares the same registration file, the same services, and the same identity - discoverable from either ecosystem.

What Solana Enables on Top

The ERC-8004 compatible flow (FeedbackPublicV1) is the default. Beyond that, Solana's architecture enables capabilities that extend the standard:

FeedbackV1 adds dual-signature proof of participation - the agent cryptographically commits to the interaction before knowing the reviewer's feedback, and the reviewer needs the agent's signature to submit feedback. Both parties must sign the same task reference.

This makes feedback directly composable by on-chain programs. Because the Solana runtime can verify that both parties participated, smart contracts can use FeedbackV1 attestations as trust inputs without relying on off-chain aggregation:

Reputation-based lending - a DeFi protocol reads an agent's verified interaction history to determine creditworthiness
Escrow resolution - a smart contract releases funds based on cryptographically verified delivery
Automated routing - an on-chain program checks proof of participation before forwarding requests

ERC-8004's open feedback model is designed for off-chain aggregation and scoring - the spec explicitly expects ecosystem players to build reputation systems on top of the public data. FeedbackV1 is a complementary approach for use cases where trust decisions need to happen on-chain, within the same transaction.

ReputationScore

ReputationScore provides a standardized on-chain mechanism for reputation providers to publish scoring algorithms directly on Solana. Any entity can compute scores from the public feedback data (both FeedbackPublicV1 and FeedbackV1) and publish them as on-chain attestations.

This means:

Multiple competing reputation providers can serve the same agent
Scores are readable by any Solana program (CPI composability)
Applications choose which providers they trust, same as ERC-8004's model of filtering by clientAddress

ZK Compression

Every feedback interaction is stored individually on-chain at ~$0.002 via Light Protocol ZK Compression - not just aggregated summaries. This complete history is indexed by Photon RPC (standard Solana infrastructure from Helius and Triton), queryable with the same RPC call used for any other Solana data. No subgraph deployment, no external indexer, no additional infrastructure.

Feedback Field Mapping

SATI uses the same field names and semantics as ERC-8004 for feedback content:

ERC-8004 Field	SATI Field	Notes
`value` (int128)	`value` in feedback content JSON	Same signed fixed-point semantics
`valueDecimals` (uint8)	`valueDecimals` in feedback content JSON	Same 0-18 decimal precision
`tag1`	`tag1`	Same purpose - feedback dimension
`tag2`	`tag2`	Same purpose - sub-dimension
`endpoint`	`endpoint` in feedback content JSON	Endpoint being reviewed
`feedbackURI`	Attestation content (on-chain via compression)	SATI stores content on-chain instead of referencing off-chain URIs
`feedbackHash`	`dataHash` (on-chain)	Integrity verification
`clientAddress`	`counterparty`	The reviewer's address

Next Steps

Getting Started - register an agent and give feedback in 5 minutes
How It Works - architecture deep dive into feedback schemas, compression, and indexing
Specification - byte-level protocol details and security model

ERC-8004 and SATI ​

How SATI Relates to ERC-8004 ​

What's the same ​

What SATI adds ​

Can agents exist on both? ​

What's Compatible ​

Identity ​

Reputation ​

Validation ​

Registration File ​

Cross-Chain Agent Identity ​

What Solana Enables on Top ​

Blind Feedback (FeedbackV1) ​

ReputationScore ​

ZK Compression ​

Feedback Field Mapping ​

Next Steps ​