How AgentID works.

Overview

AgentID is an agent-gated fair mint on Ethereum L1. Only a wallet whose operator holds a verified .ai Agent ID (the Binance Agent ID, on BNB Smart Chain) can mint. The gate is proven by an EIP-712 voucher the backend signs after reading the Agent-ID registry. The contract verifies that signature, so identity lives on BNB while minting happens on Ethereum.

Only the mint contract can create $AGI, and never above the 4,440,000,000 (4.44B) hard cap. The team holds no separate allocation: if it wants $AGI, it mints and pays on the same ladder as everyone else.

Who can mint

You need a Binance Agentic Wallet holding a verified .ai Agent ID on BNB Smart Chain. The backend reads the registry and signs an EIP-712 voucher; the mint contract verifies the signature. No Agent ID, no mint. That holds on every track, free or paid.

Don't have an Agent ID yet? Set up the Binance Agentic Wallet and register one on BNB Chain. See the Binance Agentic Wallet docs.

There are three mint tracks and they all open in parallel: WL free and public free (500 shares each, up to 5 per Agent ID, $0) and public paid (the ladder below, max 15 per wallet, 10 per transaction). Whitelist allocation is earned off-chain: completing the social tasks grants a guaranteed 1 whitelist share, and each invited agent who also completes the tasks adds one more, up to 5 per Agent ID. Paid minting is open to any agent from the first share and never waits for the free pool to sell out. Free shares mint $AGI straight to the agent and add no liquidity.

Price ladder

Two tracks run in parallel. The free tracks are 1,000 shares total (500 whitelist + 500 public, $0), claimed separately through mintFree. The 444,000 paid shares climb the ladder below: $1.00 flat for the first 10,000 paid shares, then up about $0.16 every 10,000 shares, reaching $8.04 on the final share. The pool opens at 10,000 paid shares. Prices are set in USD and paid in ETH at the Chainlink ETH/USD price.

The 1,000 free shares (500 whitelist + 500 public) are a separate $0 track and do not use this ladder.

Each paid share mints 11,000 $AGI to the minter before the pool opens. After the pool opens, your payment buys $AGI at the pool price with a 1% discount, so the tokens per share follow the market.

Liquidity & the floor

The official Uniswap V2 $AGI/WETH pool opens automatically in the transaction that mints paid share 10,000. Until then, 100% of every payment is escrowed in the mint contract (fully refundable). At the open, and on every mint after:

• 80% of the payment seeds the Uniswap V2 pool, in the same transaction.
• The LP tokens are sent to the dead address 0x…dEaD, so they are burned and never withdrawable.
• 20% goes to the treasury.
• Trading and transfers switch on. (Admin renounce is a separate treasury step — see Anti-rug rules.)

Floor line. As minting continues, if the market value of circulating $AGI at the pool price falls below total paid × ~1.8, the mint burns $AGI from the pool to raise the price back toward the line. Each transaction can lift the pool price by at most 0.8%, and the pool always keeps a minimum token reserve. The floor is a mint-time mechanism, not a guarantee. If nobody mints, nothing defends the price.

Economics

The treasury's only inflows are the 20% mint share and the collected trade tax. There is no hidden token allocation and no way to spend the pool: LP is burned, and no function can move it or any holder's tokens.

Trade tax

Tax rates and the recipient are fixed constants in the contract and cannot be changed. Buys through the official pair take 2.5% (1% to the treasury, 1.5% burned). Sells take 2.5% to the treasury. Wallet-to-wallet transfers are untaxed. The collected tax is swapped to ETH for the treasury by a permissionless, per-block, pool-capped sweep. No swap ever runs inside a user transfer. Transfers into any non-official pair (including the Uniswap V4 PoolManager) are rejected, so the tax can't be bypassed. The DEX routers are never blocked.

Anti-rug rules (enforced in code)

• No withdraw. No owner/admin/dev function can pull escrow, the pool, or the LP. None exists.
• LP burned. All liquidity LP is sent to the dead address, permanently locked.
• Escrow refundable. Pre-open payments are 100% refundable for 30 days if the pool never opens.
• Admin renounce. The treasury can permanently give up pause and pool-blocking by calling renounce(). It is a manual step, not automatic at pool open. Until it is called, the treasury can pause minting and block rogue pools; it can never touch escrow, the pool, the LP, or anyone's tokens. Watch for the Renounced event.
• Fixed tax constants with no setter; recipient fixed.
• Capped supply. Only the mint contract creates $AGI, never above 4.44B.
• Agent-only. Every mint requires a signed Agent-ID voucher, so a human without an Agent ID cannot mint.

Quick start · mint as an agent

AgentID is minted by agents, for agents. Any wallet whose operator holds a verified .ai Agent ID can mint. The flow is three steps: prove the Agent ID, fetch a signed voucher, submit the mint. Give your agent the instruction below.

# needs a Binance Agentic Wallet + a verified .ai Agent ID
Mint 5 paid shares of AgentID ($AGI) on Ethereum mainnet.

1. Fetch a mint voucher for my wallet from https://agentideth.com/api/voucher
2. Call mint(shares, agentId, nonce, deadline, sig, maxCost, minTokensOut)
   on the AGI mint contract, paying in ETH at the quoted price.
3. Report the tx hash and the $AGI received.

The backend verifies the Agent ID against the BNB Chain registry and returns an EIP-712 voucher bound to your wallet. The contract recovers the signer, so the voucher is the gate. Without one, the mint reverts.

# Claim your free whitelist share
Claim my AgentID whitelist allocation. Fetch a free voucher with wl=true
from /api/voucher, then submit mintFree on the AGI contract.

# Claim a public free share (any agent, no whitelist needed)
Claim 1 public free share of $AGI. Get a voucher with wl=false, then mintFree.

# Get your ETH back before the pool opens
If the AGI pool has not opened, call refund() to return my escrowed ETH.

The mint skill

A skill wraps the flow so an agent mints from a single instruction. It routes each intent to the backend or to the Binance Agentic Wallet, which signs the on-chain call. The skill is published at /skill.md; the routing is:

The skill holds no keys of its own. It reads the voucher from the backend and hands the transaction to the wallet, which the operator controls. Nothing custodial sits in between.

API

The whitelist and voucher endpoints. JSON in, JSON out, same origin as this site. All writes run server-side; the Agent-ID check reads the BNB Chain registry. LLM-readable docs live at /llms.txt and /llms-full.txt.

# live whitelist count
curl https://agentideth.com/api/stats
# → {"wl_cap":500,"wl_registered":123,"public_cap":500}

# prove an Agent ID and register for the whitelist
curl -X POST https://agentideth.com/api/connect \
  -H 'content-type: application/json' \
  -d '{"handle":"yourname.ai"}'

Contracts

Two contracts, Solidity 0.8.24, deployed and verified on Etherscan. Every rule on this page is one of these. The token holds the cap and the tax, the mint holds the ladder and the gate.

// Fixed cap and trade tax. Constants, no setters, nothing to change later.
uint256 public constant MAX_SUPPLY       = 4_440_000_000 ether; // 4.44B hard cap
uint256 public constant BUY_TREASURY_BPS = 100;  // 1.0% of a buy to the treasury
uint256 public constant BUY_BURN_BPS     = 150;  // 1.5% of a buy burned
uint256 public constant SELL_TAX_BPS     = 250;  // 2.5% of a sell to the treasury
// a wallet to wallet transfer is untaxed

// Flat $1.00 until the pool opens, then one step up per 10,000 shares.
function priceCents(uint256 n) public view returns (uint256) {
    if (n <= OPEN_AT) return 100;      // $1.00 flat while funds accumulate
    uint256 band = (n - 1) / 10_000;   // 0, then 1, 2, ... per 10k shares
    return 100 + band * 16;            // +$0.16 a band, $8.04 at share 444,000
}

// paid ladder mint, at most 15 shares per wallet
function mint(uint256 shares, uint256 agentId, uint256 nonce, uint256 deadline,
             bytes calldata sig, uint256 maxCost, uint256 minTokensOut) external payable;

// free claim, $0. wl=true is the whitelist track, wl=false the public track
function mintFree(uint256 agentId, bool wl, uint256 shares,
                 uint256 nonce, uint256 deadline, bytes calldata sig) external;

// full ETH refund if the pool never opens within 30 days
function refund() external;

// The mint gate is a signed voucher. The backend reads the BNB Chain Agent-ID
// registry and signs; the contract recovers the signer. No signer match, no mint.
Mint(address minter,uint256 agentId,uint256 nonce,uint256 deadline)
Free(address minter,uint256 agentId,bool wl,uint256 shares,uint256 nonce,uint256 deadline)

Contract functions

All contracts are Solidity 0.8.24 and are verified on Etherscan. Read the source and check every rule described here.

Risks

AgentID is experimental software. Read these before you mint.

• Price can go to zero. $AGI has no promised utility, yield, or value. Only commit what you are fine losing.
• Thin at open. The pool opens with the liquidity gathered before open, so early trading can move the price sharply.
• External dependencies. Minting relies on the BNB Chain Agent-ID registry, the Chainlink ETH/USD feed, and Uniswap. If any is unavailable, minting can pause.
• Trusted signer. An off-chain signer attests your Agent ID and signs every mint voucher. The contract enforces the per-agent caps, the total free caps, and the supply cap, but if that signer key is compromised, the free allocation could be claimed by others and the agent gate bypassed up to those caps. The signer can never touch escrow, the pool, the LP, or anyone's tokens.
• Pre-audit. The contracts are being prepared for an independent audit; they are deployed and verified on Etherscan now. Read the source yourself.
• The floor is not a guarantee. It defends value only while minting continues. If nobody mints, nothing holds the price up.
• You sign everything. Every mint is your own transaction from your own wallet. Verify the contract address on Etherscan before you sign.

Addresses

AgentID's own contracts are deployed and verified on Etherscan, and it builds on public infrastructure you can verify right now. The one source of truth for the addresses is /api/contract.

This is not financial advice. See the Risks above, and verify every address on Etherscan before signing.