ERC-8259 AI agent identity and threat registry (AI Agent Identity & Threat Registry)
Draft · Other · created 2026-05-07
Standardizes, through an on-chain interface, a decentralized identity (DID), reputation score, and threat intelligence sharing system that autonomous AI agents can use together across multiple protocols.
Why it is needed
Autonomous AI agents increasingly execute transactions across multiple protocols and wallets, but without a standardized identity system, how to confirm it is the same agent differs from protocol to protocol. Transaction history and trust built up in one app stay locked inside that app and cannot carry over to other services, and malicious behavior patterns detected by one protocol are not shared in real time with other networks. There is also no common standard for distinguishing a verified agent from a freshly created bot, so attackers can keep generating new addresses and repeat already-known attacks against other protocols. Without this standard, every protocol ends up having to rebuild identity verification, reputation tracking, and threat sharing on its own.
What to implement
function getEffectiveTier(address agentAddress) external view returns (uint8);: Returns the actual verification tier, reflecting active status and expiration.function getAgentIdentity(address agentAddress) external view returns (AgentIdentity memory);: Returns the agent's full identity record.function getAgentByDID(string calldata did) external view returns (address);: Looks up and returns the agent address corresponding to a DID string.function isVerified(address agentAddress) external view returns (bool);: Checks whether the agent is active and holds a verification that has not expired.function calculateTrustScore(address agentAddress) external view returns (uint16);: Computes a trust score combining reputation and a valid verification tier.function isKnownAttacker(address agent) external view returns (bool);: Checks whether the given address has an active threat incident.function hasActiveThreat(address agent) external view returns (bool);: An alias function that returns the same result as isKnownAttacker.function getAttackRecord(uint256 incidentId) external view returns (AttackRecord memory);: Returns the full record for a specific incident ID.function getAgentAttackHistory(address agent) external view returns (uint256 attackCount, uint256 totalBlocked);: Returns the agent's past attack frequency and total amount blocked.function getIncidentSummary(address agent) external view returns (uint256 active, uint256 resolved, uint256 retracted);: Returns the agent's incidents aggregated by status (active, resolved, withdrawn).function assessRisk(AssessmentRequest calldata request) external view returns (RiskAssessment memory);: An optional interface that assesses the risk of a single transaction before execution.function batchAssessRisk(AssessmentRequest[] calldata requests) external view returns (RiskAssessment[] memory);: Assesses the risk of multiple transaction requests at once.
In depth
Identity Registration and Initial State
registerAgent takes did, publicKey, and metadataURI and registers a new agent identity. It must revert if did is empty or already registered to a different address. Registration must always start with verificationTier 0 and verificationExpiry 0, and registerAgent itself must not accept a nonzero tier value. The verification tier can only be raised by a separate call to updateVerificationTier. A successful registration must emit an AgentRegistered event, and the reputationScore of a new identity must be initialized to the neutral value of 500 unless a special governance setting overrides it.
Verification Tier and Expiry Logic
The verification tier has five levels: 0 (unverified), 1 (Bronze), 2 (Silver), 3 (Gold), and 4 (Platinum). updateVerificationTier can only be called by an authorized verifier, and the call must set verificationExpiry to block.timestamp + validityPeriod. getEffectiveTier must return 0, regardless of the stored verificationTier value, whenever the agent is inactive (!isActive) or block.timestamp has passed verificationExpiry. isVerified must be true only when the agent is active and getEffectiveTier is greater than 0. Reputation score updates or general activity (lastUpdate) do not refresh or extend verificationExpiry.
Reputation Score Update Authority and Trust Score Calculation
updateReputationScore can only be called by an authorized party, such as a designated oracle address, an audited verification contract, or a governance multisig, and it must revert if called by any other address. newScore cannot exceed 1000; if it does, the transaction reverts. A successful update emits a ReputationScoreUpdated event. calculateTrustScore must return 0 if the agent is inactive, and the tier-based weighting must use the result of getEffectiveTier rather than the stored verificationTier field. As a result, an agent whose verification has expired does not get that tier's weighting reflected in its trust score, even if the verificationTier field value remains.
Identity/Reputation Boundary
This standard requires a clear semantic distinction between identity verification and reputation assessment. A party authorized only to update reputation must not be able to change an identity's identifier binding or controller, and identity lifecycle operations such as key rotation or privilege revocation must be separated from reputation updates by distinct authority and records. The fact that reputation was recently updated must not be presented as evidence that the identity binding has been revalidated, and neither identity verification nor a high reputation score should be interpreted as authorization for any specific action. The specification defines this through conformance test items T1 through T8; for example, T8 requires that updating reputation after verification has expired must not revive the tier weighting in calculateTrustScore.
Threat Reporting and Incident Lifecycle
recordAttack can only be called by an approved security oracle, monitoring contract, or whitelisted protocol adapter, and on success it creates an incident record with status ACTIVE and emits an AttackBlocked event. retractAttack can only be called by the original reporter or governance to transition a false positive to RETRACTED, and resolveAttack cannot be called by the targeted agent itself; it transitions the incident to RESOLVED along with remediation evidence from a verifier, auditor, or governance. isKnownAttacker and hasActiveThreat must return true only when at least one incident is in the ACTIVE state. If one incident is retracted or resolved but another remains ACTIVE, the attacker flag must stay true.
Threat Pattern Hash Generation Rules
A threat pattern must be created by packing actionType (string), destination (address), and amountBucket (number) with abi.encodePacked and hashing the result with keccak256. The resulting bytes32 value is the threat pattern identifier shared via shareThreatPattern or recorded as the pattern argument of recordAttack. Any protocol that computes patterns this same way can recognize the same behavior under the same hash.
Optional Pre-Transaction Risk Assessment Interface (IRiskAssessment)
IRiskAssessment is an optional interface in which assessRisk takes an AssessmentRequest containing the agent, amount, action, destination, and metadata, and returns a RiskAssessment containing the allowed flag, risk score, reason, confidence, and a list of related threat patterns. batchAssessRisk evaluates multiple requests at once, and updateRiskParameters updates the risk assessment criteria using a parameter hash and an array of new values. Only registries that want to assign a risk score before transaction execution need implement this interface.
Proposal status
ERC-8259 is currently registered in Draft status. Its interface or requirements may still change during community discussion and review, or the proposal may stall and go no further.
Things to watch out for
- Reputation Manipulation and Access Control: If updateReputationScore is unprotected or secured only by an easily compromised key, an attacker could inflate a malicious agent's reputation or drive a competing agent's score to zero to damage its standing. Registries must implement strict access control, such as multisig governance, timelocks, or consensus among multiple independent reporting nodes.
- Denial of Service via False Threat Reports: If recordAttack can be called by anyone without verification or collateral, an attacker could falsely register a legitimate address as an attacker, causing integrating protocols to block an ordinary user. Registries must restrict this function to authenticated monitors or require a collateral deposit that is forfeited on a false report.
- Self-Selected Verification Tier and Unenforced Expiry: If registerAgent accepts a nonzero tier, an unverified bot could falsely claim trust. In addition, a static tier record with no validity period leaves the credential of an abandoned or compromised agent in place indefinitely. getEffectiveTier, isVerified, and calculateTrustScore must all consistently honor verificationExpiry to prevent an expired credential from continuing to provide benefit.
- Sybil Resistance and the Ban on Granting Trust at Tier 0: Ethereum accounts can be created at essentially no cost, so an attacker can generate an unlimited number of tier 0 unverified identities. Integrating protocols must not grant privileges, loan limits, or collateral relief based on tier 0 registration alone, and high-trust operations must require tier 2 (Silver) or above together with a review of prior transaction history.
- Replay and Front-Running Risk: If a transaction risk assessment or threat pattern hash is exposed in the public mempool, a malicious agent could monitor incoming reports and act before the blocking transaction lands. Implementations are recommended to use a private mempool, a commit-reveal scheme, or batched updates for critical threat reports.