ERC-7857 — AI Agents NFT with Private Metadata

Back to Token Standards

ERC-7857: AI Agents NFT

ERC-7857 lets an NFT represent an autonomous AI agent whose configuration / model weights / system prompts are private. The on-chain NFT carries a public-facing identifier; the actual agent parameters live encrypted off-chain (IPFS, Arweave) and are re-encrypted to the new owner's key on every transfer. Used by:

• Agent marketplaces — sell autonomous trading bots, content agents, customer-service NFTs without leaking the underlying model.
• AI character NFTs — game characters with private personality prompts.
• Specialised agent licensing — fine-tuned models bundled as transferable NFTs.

The on-chain part is small (the NFT + reference to encrypted blob); the off-chain part is the encrypted agent payload and a re-encryption service that runs at transfer time.

Required Interface (abridged)

interface IERC7857 {
    event AgentMetadataReencrypted(uint256 indexed tokenId, address indexed newOwner,
                                   string newMetadataPointer);

    function metadataOf(uint256 tokenId) external view returns (string memory);
    function reencryptOnTransfer(uint256 tokenId, string calldata newMetadataPointer,
                                 bytes calldata reencryptionProof) external;
}

The transfer flow:

1. Buyer initiates transfer.
2. Off-chain re-encryption service downloads old encrypted blob, decrypts (with seller's key escrow), re-encrypts to buyer's public key, uploads.
3. Service calls reencryptOnTransfer with the new IPFS pointer and a proof of correct re-encryption (typically a zk-SNARK or TEE attestation).
4. The NFT contract verifies the proof, updates the metadata pointer, transfers the NFT.

Neo Equivalent: NEP-11 + Re-encryption Service Hook

public static void ReencryptOnTransfer(ByteString tokenId, string newMetadataPointer,
                                       ByteString reencryptionProof)
{
    if (!Runtime.CheckWitness(GetReencryptionService())) throw new Exception("AI:NotService");

    if (!VerifyReencryptionProof(tokenId, newMetadataPointer, reencryptionProof))
        throw new Exception("AI:InvalidProof");

    Storage.Put(Storage.CurrentContext, MetadataKey(tokenId), newMetadataPointer);

    // Complete the deferred transfer.
    var pendingNewOwner = (UInt160)Storage.Get(Storage.CurrentContext, PendingOwnerKey(tokenId));
    Transfer(pendingNewOwner, tokenId, null);
    Storage.Delete(Storage.CurrentContext, PendingOwnerKey(tokenId));
    OnAgentMetadataReencrypted(tokenId, pendingNewOwner, newMetadataPointer);
}

ERC-7857 (Ethereum)	Neo Equivalent	Notes
Encrypted metadata blob (IPFS)	Same — IPFS / Arweave reference stored on-chain
Re-encryption service (off-chain)	Off-chain Neo C# service holding the seller's key escrow
reencryptOnTransfer(...)	ReencryptOnTransfer(...) service-witness-checked
TEE / zk proof	VerifyReencryptionProof(...) — pluggable verifier
Two-phase transfer (initiate, complete)	Pending-owner storage + reencrypt-then-transfer

Composition

• ERC-7007 — verifiable AI-generated content. Pair: the agent NFT proves its model identity; outputs prove provenance.
• ERC-6551 — token-bound accounts. AI agent NFTs can hold their own funds via TBA — the agent acts as its own treasurer.
• ERC-4519 — physical-asset NFTs. Same private-key attestation pattern, applied to AI agents instead of devices.

Migration Notes

For AI agent NFT platforms:

1. The expensive part is off-chain re-encryption infrastructure — TEE-backed services or zk-SNARK provers.
2. The on-chain footprint is two storage slots (metadata pointer + pending-owner during transfer) and the verification call.
3. For low-value agents, signature-from-the-service is cheaper than zk; for high-value bots, zk-attested re-encryption prevents service-operator collusion.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract ERC7857 {
    mapping(uint256 => string) public metadataOf;
    address public reencryptionService;

    event AgentMetadataReencrypted(uint256 indexed tokenId, address indexed newOwner,
                                   string newMetadataPointer);

    function reencryptOnTransfer(uint256 tokenId, string calldata newMetadataPointer,
                                 bytes calldata reencryptionProof) external {
        require(msg.sender == reencryptionService, "not service");
        require(_verifyProof(tokenId, newMetadataPointer, reencryptionProof), "bad proof");
        metadataOf[tokenId] = newMetadataPointer;
        // ... complete pending transfer ...
        emit AgentMetadataReencrypted(tokenId, msg.sender, newMetadataPointer);
    }

    function _verifyProof(uint256, string calldata, bytes calldata) internal pure returns (bool) {
        return true;
    }
}

using System;
using System.ComponentModel;
using Neo;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Attributes;
using Neo.SmartContract.Framework.Native;
using Neo.SmartContract.Framework.Services;

namespace R3E.Examples;

[DisplayName("AgentNFT")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep11)]
public class AgentNFT : Nep11Token<TokenState>
{
    public override string Symbol => "AGNT";

    private const byte Prefix_Metadata     = 0x10;
    private const byte Prefix_PendingOwner = 0x11;
    private const byte Prefix_Service      = 0xfe;

    [DisplayName("AgentMetadataReencrypted")]
    public static event Action<ByteString, UInt160, string> OnReencrypted;

    public static string MetadataOf(ByteString tokenId)
        => (string)Storage.Get(Storage.CurrentContext, MetadataKey(tokenId));

    public static void InitiateTransfer(ByteString tokenId, UInt160 newOwner)
    {
        if (!Runtime.CheckWitness(OwnerOf(tokenId))) throw new Exception("AI:NotOwner");
        Storage.Put(Storage.CurrentContext, PendingKey(tokenId), newOwner);
    }

    public static void ReencryptOnTransfer(ByteString tokenId, string newMetadataPointer,
                                           ByteString reencryptionProof)
    {
        var service = (UInt160)Storage.Get(Storage.CurrentContext, new byte[] { Prefix_Service });
        if (!Runtime.CheckWitness(service)) throw new Exception("AI:NotService");

        // Pluggable verifier — operator signature, TEE attestation, or zk-SNARK.
        // ... VerifyReencryptionProof(tokenId, newMetadataPointer, reencryptionProof) ...

        Storage.Put(Storage.CurrentContext, MetadataKey(tokenId), newMetadataPointer);

        var pending = (UInt160)Storage.Get(Storage.CurrentContext, PendingKey(tokenId));
        if (pending is null) throw new Exception("AI:NoPendingTransfer");
        Transfer(pending, tokenId, null);
        Storage.Delete(Storage.CurrentContext, PendingKey(tokenId));
        OnReencrypted(tokenId, pending, newMetadataPointer);
    }

    private static byte[] MetadataKey(ByteString tokenId) => new byte[] { Prefix_Metadata     }.Concat(tokenId);
    private static byte[] PendingKey(ByteString tokenId)  => new byte[] { Prefix_PendingOwner }.Concat(tokenId);
}