ERC-7007

At its core, ERC-7007 defines a smart contract interface (IAgent) that an AI agent must implement. This interface includes a single, critical function: processRequest. This function is the entry point where the agent receives an on-chain request (like a transaction or query), processes it using its AI logic, and returns an executable action (e.g., to, value, data). This standardizes how AI interacts with the blockchain, separating the AI's decision-making from the execution mechanics.

For an AI agent to act, it must receive a request. ERC-7007 is intrinsically linked to ERC-7008, the standard for AI Agent Requests. An ERC-7008 request is a structured data packet stored on-chain that contains the prompt, context, and constraints for the AI. The ERC-7007 agent's processRequest function consumes these standardized requests. This decoupling allows for request markets, verifiable AI inputs, and composability between different agents and request issuers.

The proposal includes an optional Agent Registry contract. This registry acts as a public directory where AI agents can be registered, discovered, and queried. Key functions include:

• registerAgent: Publishes an agent's address and metadata.
• getAgent: Retrieves agent details.
• isRegistered: Verifies an agent's status. This enables ecosystem tools, wallets, and users to find and interact with trusted, auditable AI agents without relying on off-chain lists.

The standard defines a clear execution flow to ensure security and determinism:

1. A Request (ERC-7008) is submitted to the agent's address.
2. The agent's processRequest function is invoked, running its AI model (on or off-chain).
3. The function returns a structured Action (target address, value, calldata).
4. This action is executed by the caller (e.g., a relayer). Critical security considerations include gas limits for execution, input validation to prevent prompt injection, and clear audit trails for the agent's decision logic.

ERC-7007 enables a new class of autonomous on-chain entities:

• DeFi Agents: Autonomous portfolio managers that rebalance based on market conditions.
• Gaming NPCs: Non-player characters that own assets, trade, and interact with players.
• Governance Delegates: AI delegates that analyze proposals and vote based on encoded principles.
• Automated Customer Service: Smart contract interfaces that can resolve disputes or process claims using natural language.

ERC-7007 agents are designed to be compatible with ERC-4337 Account Abstraction. An AI Agent can be implemented as a smart contract wallet (UserOperation sender). This allows the agent to:

• Pay for its own transaction gas via a paymaster.
• Have its own nonce and sign transactions programmatically.
• Be bundled with other operations for efficiency. This integration is crucial for creating truly autonomous, self-funding AI entities on Ethereum.

ERC-7007 NFTs can encapsulate the exact state of a trained machine learning model, its weights, and inference logic. This creates an immutable, timestamped record of a research output, enabling:

• Provenance Tracking: Verifiable lineage of model development.
• Result Replication: Any researcher can run the exact model used in a published paper.
• Audit Trails: Transparent documentation of training data and methodology for peer review.

The standard transforms AI models into ownable, tradable assets with programmable rights. This facilitates:

• Fractional Ownership: Multiple contributors can own shares of a high-value model NFT.
• Automated Royalties: Smart contracts can enforce license fees for commercial use, with payments streaming to token holders.
• Access Control: NFT ownership can grant exclusive rights to use, fine-tune, or query a proprietary model.

ERC-7007 enables novel incentive structures for collaborative AI development.

• Bountied Model Creation: Researchers can be rewarded with NFT shares for contributing compute or data to train a model.
• Data DAOs: Communities can pool data, train a model, and distribute ownership via the resulting NFT.
• Continuous Improvement: A model NFT's value can be linked to its performance, incentivizing holders to contribute to its fine-tuning.

AI Agent NFTs can be designed to perform on-chain inference, acting as decentralized oracles.

• DeSci Analytics: A model trained on biomedical literature could be queried on-chain to analyze new research proposals.
• Automated Peer Review: Basic plausibility checks or literature comparisons could be automated via model calls.
• Transparent Decision Support: Grant-funding DAOs could use verifiable model outputs to inform allocation decisions.

ERC-7007 NFTs become composable units in larger DeSci workflows.

• Pipeline NFTs: A research process (data cleaning → model A → model B) can itself be tokenized, with each step as a sub-NFT.
• Modular Science: Researchers can "plug and play" different pre-verified model NFTs into their experiments.
• Attribution Chains: Royalties and credit automatically flow upstream through a chain of dependent model NFTs.

The primary security guarantee of ERC-7007 is the use of zero-knowledge proofs (ZKPs) to verify off-chain AI execution. An AI Agent submits a ZK-SNARK or ZK-STARK proof with its result, cryptographically attesting that:

• The inference was performed correctly by the specified model.
• The input data was used as committed.
• The output matches the claimed result. This shifts trust from the agent operator to the mathematical soundness of the proof system and the integrity of the on-chain verifier contract.

ERC-7007 redefines the trust boundary for decentralized AI:

• Off-Chain (Execution): Trust is required in the ZK prover to generate a valid proof and the availability of the AI model (e.g., via IPFS, Filecoin). The computational work is opaque but its correctness is verifiable.
• On-Chain (Verification): Trust is minimized to the verifier smart contract, which is a small, deterministic program. The blockchain consensus ensures the verification result is immutable and final. This model is more efficient than on-chain execution while providing stronger guarantees than pure oracle-based systems.

To prevent tampering, ERC-7007 mandates cryptographic commitments for AI inputs and outputs.

• Input Commitment: The hash of the prompt and any data is submitted on-chain before execution. The ZKP proves the off-chain computation used this exact input.
• Output Commitment: The result is included in the proof. This creates a cryptographic binding between the specific request and its verified outcome, preventing result substitution or manipulation in transit.

Security depends on knowing which AI model was executed. ERC-7007 addresses this through:

• Model Identifier: A unique content-addressed hash (like a CID) that pinpoints the exact model weights and architecture used.
• Provenance Proofs: The ZKP can be extended to attest that the execution trace corresponds to this specific model identifier.
• Registry Contracts: Optional standard registries can map identifiers to audited model metadata, helping users trust the model's origin and intended behavior.

The standard supports cryptoeconomic security mechanisms to disincentivize malicious behavior:

• Staking: AI Agent operators may be required to stake tokens (e.g., ETH) as a bond.
• Slashing Conditions: The verifier contract can be designed to slash this stake if an agent submits an invalid proof or is found to have misbehaved via a fraud proof challenge period.
• Challenge Mechanisms: A secondary verification layer where other participants can dispute a proof's validity, triggering a more thorough check.

While ZKPs provide verifiability, they do not automatically guarantee full privacy:

• Input/Output Privacy: The standard supports private inputs/outputs by only committing to their hashes. The actual data remains with the user and prover, but the ZKP must be specifically designed for this (e.g., using zkML frameworks).
• Model Privacy: The model itself is typically public (via its identifier) to allow verification. Keeping a model private while proving execution is a complex, active research area.
• Metadata Leakage: Patterns of interaction with the smart contract may reveal usage metadata.

ERC-7007 NFTs are powered by external AI models. Key integration patterns include:

• On-chain Inference: Using verifiable compute or ZK-proofs for trustless execution (e.g., Giza, Ritual).
• Off-chain Oracle: A trusted service (like Chainlink Functions) calls an API and posts the result on-chain.
• Model Provenance: The modelURI points to a decentralized storage solution (like IPFS/Arweave) containing the model's hash, license, and framework.

This standard enables dynamic, generative digital assets. Primary applications include:

• Generative Art & Music: NFTs that create new outputs based on owner input or on-chain data.
• Interactive Gaming: NPCs or items with AI-driven behavior and dialogue.
• Dynamic Identity: PFPs or avatars that evolve through conversation.
• Autonomous Agents: NFTs that can perform on-chain actions based on AI decision-making.

A practical guide for developers building with ERC-7007 would cover:

1. Contract Structure: Inheriting from the base interface and implementing the inference hook.
2. Inference Logic: Designing the function to handle prompts, manage gas costs, and return results.
3. Security Considerations: Mitigating risks like prompt injection, model poisoning, and ensuring deterministic outputs for verifiability.
4. Frontend Integration: Connecting a dApp to listen for Inference events and display generated content.

ERC-7007 exists within the broader movement of Autonomous Worlds and on-chain AI. It provides a standardized primitive for creating agentic NFTs that can interact with other smart contracts and users. Its adoption depends on the maturity of verifiable compute networks and the emergence of dApps that leverage generative, interactive assets.