ERC-8410 Execution plan artifact reference standard (Portable Execution Plan Artifact)
Draft · Accounts & wallets · created 2026-09-04
A standard where a transaction plan created by an agent tool is passed to the wallet as a small reference made up of location, length, and digest instead of the full data, and the wallet fetches and verifies it directly.
Why it is needed
When an AI agent prepares a transaction on behalf of a wallet, the model has to read the calldata returned by the preparation tool as is and regenerate it as the input for the wallet call. The more complex the transaction, such as one bundling multiple steps like a swap, the larger this data gets, increasing the number of tokens the model must process along with response time and cost together. A bigger problem is that in the process of the model copying the bytes as is, some content can be dropped, truncated, or altered. Also, the wallet has no way to know which tool this calldata actually came from, so it must decide whether to approve based only on the explanation the agent gives. Execution conditions such as approval, cleanup, and atomicity also end up depending on the agent's explanation, making them hard for the wallet to verify independently.
In depth
Basic structure of an execution plan
The execution plan document must contain schema_version (currently fixed at "1"), chain_id (the EIP-155 chain ID), caip2_chain_id (must match "eip155:"+chain_id), sender (the account that will send every step), and ordered_steps (an array of 1 to 4096 steps). required_capabilities, simulation_failure_policy, and extensions are optional fields. If any member not listed here is present, the entire document must be rejected, and an unsupported schema_version or a contradictory chain value must also be rejected. A plan is restricted to a single sender and a single chain so that one wallet can verify and execute the entire call sequence.
Steps and kind labels
Each entry in ordered_steps has a step number assigned sequentially starting from 1, a kind, a transaction object, and an optional revert_decode. The transaction must contain chain_id and from matching the plan's chain_id and sender, plus to, data, and value (in wei); gas is optional (advisory only). A wallet must not broadcast the gas limit supplied by the creator as is without its own estimation. kind is one of execution (a call the user requested), approval (grants an allowance for a later step to use), allowance_cleanup (revokes an allowance granted by an earlier step), signature_dependent_execution (consumes a previously approved signature), or other, and is purely a display label, so a wallet must not infer permissions from this value or assume the calldata actually behaves as the label claims.
required_capabilities and atomic_batch
required_capabilities lists the behaviors needed for execution, and if even one item is not implemented by the wallet, the entire plan must be rejected. This version defines only one capability, atomic_batch, which is the condition that all steps execute as a single transaction and are entirely reverted if any one fails. This can be satisfied by an account abstraction batch executor or an EIP-7702 delegation. A multi-step plan that does not require atomic_batch may be executed as individual transactions, but in that case they must be started in order, each only after the previous step has been successfully mined, and must stop immediately on failure. Capability names are limited to 32 or fewer, each an ASCII string of 1 to 64 characters.
simulation_failure_policy
The creator may include a policy for each of three failure situations, rpc_error, execution_reverted, and simulation_setup_error, containing an action (retry_same_plan/reprepare_plan/user_review) and a 1 to 2000 character instruction. retry_same_plan cannot be used for execution_reverted or simulation_setup_error. This policy is purely advisory, so a wallet may ignore it, and it must never be treated as broadcast approval under any circumstance.
Computing the plan digest
The plan digest is the keccak256 hash of a JSON string obtained by serializing schema_version, chain_id, sender, and each step's step, kind, and transaction (chain_id, from, to, data, value) in a fixed order (not alphabetical by name) with no whitespace. caip2_chain_id, gas, revert_decode, simulation_failure_policy, required_capabilities, and extensions are excluded from the digest. This means the digest can be identical even when the gas hint or required capabilities differ, so the digest alone cannot establish that two plans are fully equivalent. Wallets are recommended to display and record this digest alongside the approval screen, the approval log, and the broadcast transaction hash.
Artifact references and delivery methods
An artifact reference contains kind ("artifact_reference"), artifact_type (execution_plan or typed_data_signature_request), url (https/data:/file), and, when https or file is used, the required integrity (keccak256 digest) and bytes (byte length). A wallet must not open a URL before confirming its length, and for https it must enforce the default port, a public unicast address, no redirects, no attached credentials, and must read the response body within the document size limit (checking the resolved address directly to prevent DNS rebinding). For data: URIs, the encoded length must be limited before decoding with no network access, and file is optional support, allowed only for absolute paths under localhost or an empty host, and must be rejected before reading if integrity or bytes is missing. On any path, if the received length or digest does not match the reference, it must be rejected.
Typed-data signature requests and EIP-5792 conversion
A typed_data_signature_request is a document separate from the execution plan, containing a single concrete EIP-712 message and the account that will sign it. Support is optional, and a wallet that supports only execution plans must reject signature requests and must not be able to hide a signature request inside a plan's steps or extensions. This ERC also defines a mapping to EIP-5792's wallet_sendCalls (chain_id to chainId, sender to from, mapping of step to/data/value, atomic_batch to atomicRequired). However, kind, revert_decode, simulation_failure_policy, and extensions have no corresponding field and are lost in conversion, and since a change in kind also changes the plan digest, a round-trip conversion may not preserve the digest.
Proposal status
This proposal was created on 2026-09-04 and is currently in Draft status. The field composition, signature request format, delivery rules, and other aspects may still change based on community discussion and implementation experience, or the proposal itself may stall.
Things to watch out for
- Not using metadata for authorization decisions: Plans and references are untrusted input, so a wallet must independently verify the call contents and must not use kind, instruction, extensions, or revert_decode results as grounds for approval. Neither digest authenticates the creator or proves approval, and a relay could swap out both the document and the reference together.
- Treating agent-generated code as a relay too: Code that a model writes itself and uses to call tools is also a relay, and since it is generated from untrusted content it may construct, tamper with, or replace the document or reference. A wallet must verify inline documents coming from such code just as it would verify input from any other relay, and must not assume they have not been tampered with.
- Not using simulation results as broadcast approval: State can change between simulation and actual mining, causing a call to revert or execute differently. A wallet must re-simulate immediately before signing and must not use a stored simulation result as grounds for broadcast approval.
- Preventing SSRF: Fetching a URL supplied by a caller can expose services on the wallet's internal network. A wallet must check the actually resolved address, not the hostname, and connect directly to that address; otherwise DNS rebinding could swap in a private address between verification and connection. Redirects, credentials, and non-standard ports must be forbidden, and the response body must not be included in error messages.
- Restricting local file access: Since a file reference is read with the wallet's own filesystem permissions, the wallet is recommended to restrict reads to a directory the user specifies. Missing, oversized, mismatched, and unparseable inputs must all be treated as the same indistinguishable failure to prevent file contents from leaking through errors.