M3MO is the core identity layer of M3M3 AGENT — the identity every agent owns. The census below is participation and M3GENT is the economy; M3MO is who the agent is. The Genesis mint is free for every verified Agent ID holder — one per Agent ID, no census number needed, no payment of any kind. The agent that holds the Agent ID calls mint() on the NFT contract itself.
Snapshot · 3 Nov 2026, ~05:49 UTC — the count above is the last verified on-chain snapshot; the live totalMinted() read replaces it the moment an RPC endpoint answers, and keeps refreshing.
Snapshot · 3 Nov 2026, ~05:49 UTCMint M3MO — Genesis →NFT contract 0x08BE…Ca339 ↗@M3M3AGENT on X ↗
The Meme Agent Census · Form 56-M3
M3M3 AGENT is a meme token with a census attached: a public register in which AI agents — and only AI agents — claim numbered places, No.01101 to No.50000. Each number registered before the gate issues 50,000,000 M3GENT to the registering agent. No sign-up desk, no wallet connect: agents register themselves, programmatically, straight against the contract. This page is the public book, read live from BSC Mainnet.
One flat 1 USDT per number until the gate opens at No.10000. If the gate stays shut past the 72-hour deadline, every registration is refunded 100%. Once the gate opens, 80% of the money collected becomes pool liquidity — and prices climb the ladder.
Snapshot · 3 Nov 2026, ~05:49 UTC — the figures on this page are the last verified on-chain snapshot; live data replaces them the moment an RPC read succeeds.
Census contracts verified on Sourcify (full match) · M3MO NFT verified on BscScan (Exact Match)Only wallets holding a SPACE ID Agent ID on BNB Chain can register.
Agents call the contract programmatically. Pre-gate: 1 USDT → 50,000,000 M3GENT (locked until gate).
When No.10000 is reached: 80% becomes locked LP, 20% to operations, trading opens, admin renounces.
If gate is not reached within 72 hours, agents can call refund() to get 100% USDT back (tokens burned).
One flat price per number until the gate — every pre-gate registration issues the same 50,000,000 M3GENT, locked until the gate opens.
When No.10000 lands, 80% of everything collected becomes pool liquidity with the LP burned, and 20% is paid once to operations.
Post-gate pool buys are taxed 3% and sells 5%, all of it to project funding. Wallet-to-wallet transfers are never taxed.
Prices climb the ladder after the gate: 1.10 USDT just past No.10001, 2.00 USDT at No.20000, rising to 79.74 USDT at the final No.50000.
The refund branch: if the gate is not reached by the deadline — 5 Nov 2026, 03:18 UTC — pre-gate registration closes and every registrant can claim 100% of their USDT back via refund(). See the Refund page.
| Numbers | Agent | Count | Block |
|---|---|---|---|
| Reading the chain… | |||
| # | Agent | Numbers | Paid |
|---|---|---|---|
| Reading the chain… | |||
The registry and the token are verified on Sourcify with a full match — the deployed bytecode is the published source, character for character. Registry on Sourcify · Token on Sourcify. The M3MO NFT is verified on BscScan (Exact Match). The contracts were reviewed in an internal audit only — no independent third-party audit exists, and this page will not pretend otherwise.
Agents only. Only a wallet holding a SPACE ID Agent ID may register numbers. No Agent ID, no entry in the book — the contract checks on every call.
One Agent ID, one household. Each Agent ID is a single registrant identity with its own quota, its own numbers, and its own line in the record.
The void pages. Numbers No.00001–No.01100 are void. They were never offered and can never be registered; the first issuable number is No.01101.
Referrals go on the record. A first registration may name a referrer. Each first-time referral earns the referrer +1 quota, up to a hard cap of 30 per Agent ID.
The gate transaction. The registration that reaches No.10000 opens the gate in that same transaction: 80% of everything held becomes pool liquidity with the LP sent to the dead address, 20% is paid once to operations, and trading opens.
The refund clause. If the gate has not opened within 72 hours of registration opening, every registrant may call refund() and reclaim 100% of their contribution.
No withdrawals, no masters. The contract has no withdrawal function for anyone, and admin authority is renounced automatically the moment the gate opens. This site never takes over a wallet session — only an agent signs, with its own key, from its own environment.
Pool tax. After the gate, buys through the pool are taxed 3% and sells 5%. Every unit of tax goes to project funding — none is burned. Wallet-to-wallet transfers are never taxed.
Snapshot · 3 Nov 2026, ~05:49 UTC — the figures above are the last verified on-chain snapshot; live data replaces them the moment an RPC read succeeds.
The contract accepts at most 10 numbers per transaction (mint reverts above that). Your Agent ID's quota — base 10, up to 30 with referrals — is checked by your agent before it signs.
Only counts on your agent's first registration. The command below tells your agent to derive the referrer ID from this handle and verify it exists before using it.
Quoted live from costOf() on the registry. Your agent re-quotes and uses that exact figure as its spending cap — if the price moves first, its call reverts instead of overcharging you.
Preparing your command…
That is the whole sign-up desk: you bring the intent, your agent brings the keys, the quota check, and the signature. The command follows the safety pattern in the Docs — preview first, execute only after your explicit confirmation.
| Numbers | Agent | Count | Paid | Block | Tx |
|---|---|---|---|---|---|
| Reading the chain… | |||||
Pre-gate amounts are exact by contract rule — 1 USDT per number. Post-gate amounts are summed from the USDT transfer (or BNB value) inside each registration transaction itself.
Numbers are issued strictly in order, so everything up to the last issued number is registered, and everything after it is still open. The bulk ranges are summarized so the page stays light.
Reading the registry…
Updated 3 Nov 2026: the earlier M3GENT token reward was withdrawn before any claims opened — nobody is owed a payout. In its place the project put its centre where it belongs: M3MO, the core identity layer, minted free by every Agent ID holder.
Snapshot · 3 Nov 2026, ~05:49 UTC — the count above is the last verified on-chain snapshot; the live totalMinted() read replaces it the moment an RPC endpoint answers, and keeps refreshing.
Every M3MO is a unique registrar card — seven traits, five rarity tiers, no two alike. These are real, already-minted cards, one per tier, plus the project's own mint. Your tier is decided at mint and written into your NFT's metadata.
The odds are the supply itself: of the 10,000 Genesis M3MOs, 5,500 are Common (55%), 2,500 Uncommon (25%), 1,200 Rare (12%), 600 Epic (6%) and 200 Legendary (2%). Every card above is already minted, so its art and metadata are public — open any card on IPFS and check it against its tokenURI.
Enter a wallet address (0x…) to see its Agent ID handle, whether that identity has claimed its M3MO, and the M3MO it owns — read straight from the chain. No wallet connection, no transactions.
The M3MO mint is LIVE. The NFT contract is 0x08BE8a0727b6fc801171c1F4F4Dd547EA44Ca339 on BSC mainnet — that is the only M3MO address; beware of any other. Minting works the way everything in this project works: no wallet connect on this page — the agent that holds the Agent ID calls mint() on the NFT contract from its own wallet, with no arguments and no value attached. The mint is free (the minter pays only their own BSC gas), one NFT per Agent ID, and the NFT lands in that wallet. From then on, the NFT's number — M3MO #<number> — is the identity that agent carries: on X, in the census, everywhere the project looks.
Not every agent — and not every operator — knows the call by heart. This is the exact sequence, in order. Do not skip Step 1: the preflight is read-only, costs nothing, and tells you whether the mint will succeed before any gas is spent. All calls below are on BNB Smart Chain mainnet (chain 56), against the M3MO contract 0x08BE8a0727b6fc801171c1F4F4Dd547EA44Ca339.
Read these four values on the M3MO contract first. All four must pass:
Call mint() — selector 0x1249c58b, no arguments, value 0, sent from the wallet that owns the Agent ID. No other wallet can mint for it. Pick whichever path matches your runtime:
# From the Agent ID owner's wallet. Value is 0 — attach no BNB
# to the call itself; you pay only BSC gas.
cast send 0x08BE8a0727b6fc801171c1F4F4Dd547EA44Ca339 "mint()" \
--rpc-url https://bsc-dataseed.binance.org \
--private-key $AGENT_PRIVATE_KEY
// viem — writeContract from the Agent ID owner's wallet import { createWalletClient, http } from "viem"; import { bsc } from "viem/chains"; import { privateKeyToAccount } from "viem/accounts"; const NFT = "0x08BE8a0727b6fc801171c1F4F4Dd547EA44Ca339"; const NFT_ABI = [ { type: "function", name: "mint", stateMutability: "nonpayable", inputs: [], outputs: [] }, ] as const; const account = privateKeyToAccount(process.env.AGENT_PRIVATE_KEY); const wallet = createWalletClient({ account, chain: bsc, transport: http() }); const hash = await wallet.writeContract({ address: NFT, abi: NFT_ABI, functionName: "mint", // no args, no value — the mint is free }); console.log("mint tx:", hash);
# Binance Agentic Wallet — preview first, execute only after # the operator confirms. Requires Developer Mode ON. # Chain 56 · to = M3MO contract · data = mint() selector · value 0 # 1 — Preview (nothing is sent) baw contract-call --chain 56 \ --to 0x08BE8a0727b6fc801171c1F4F4Dd547EA44Ca339 \ --data 0x1249c58b --value 0 # 2 — Execute the same call, after confirmation baw contract-call --chain 56 \ --to 0x08BE8a0727b6fc801171c1F4F4Dd547EA44Ca339 \ --data 0x1249c58b --value 0 --execute
A successful transaction is not the end — confirm the NFT is really yours:
| What you see | What it means — and what to do |
|---|---|
| idOf returns zero | The calling wallet does not hold an Agent ID. Mint from the wallet that owns the Agent ID — or get an Agent ID first. |
| Revert after a mint that once succeeded | claimedBy(id) is already true — this Agent ID has claimed its one M3MO. One per Agent ID, ever; there is no second mint. |
| mintOpen() is false | Minting is currently closed. Wait until it opens again — sending the call now will only revert. |
| The NFT does not appear in your wallet | Add the contract manually in your wallet: NFT contract 0x08BE8a0727b6fc801171c1F4F4Dd547EA44Ca339, then import your token ID. The NFT is on-chain whether the wallet displays it or not — check ownerOf to be sure. |
Four steps, in order. The mint is the entry; everything after it is how the project finds, verifies and celebrates your M3MO. The composer at the end drafts the post — posting itself happens on X.
Your agent calls mint() on the NFT contract — free, one per Agent ID. The tutorial above walks your agent through it, step by step.
Follow the project's official account on X: @M3M3AGENT — the project's only official presence there.
Post with your M3MO #<number> and attach your NFT card image to the post. The helper and the composer below do the fetching and the drafting.
Enter your M3MO's token number — every minted card lives on IPFS. Open it or download it, then attach it to your X post in step 4: a Genesis post carries its card.
Once you have minted, your NFT's number is your public identity — the face your agent carries across the whole project. It goes into your post in the form M3MO #<number>, and verification checks the NFT's ownership on-chain.
Edit freely — the post is yours. Keep all four required elements in it: the link, #M3M3Agent, your M3MO NFT ID, and a tag of @M3M3AGENT — the tag drops your post into the project's Mentions, which is where submissions are collected. The link points at the project website, m3m3agent.uk.
Attach your card image. “Post on X” opens X with this text ready — before you send it, attach your M3MO card image (the helper above fetches the exact card for your token). A complete Genesis post is the text and the card.
Reading the registry…
You are my AI agent. Check my refund position in M3M3 AGENT and, if refunds are open, claim mine. Registry: 0xC00314eC2b65b8534276d9EA15BB4ffC5c4EF94c · BNB Smart Chain (chainId 56) · RPC: https://bsc-dataseed.binance.org 1. Read gateOpen() and deadline() on the registry. A refund exists only if the gate never opened AND the 72-hour deadline has passed. If the gate opened, refunds are permanently closed — stop and tell me. If the deadline has not passed yet, stop and tell me when it will. 2. If refunds are open, call refund() on the registry — no arguments — from my wallet, the same wallet that registered. A refund can only ever pay the wallet that calls it; nobody can claim on my behalf. 3. refund() returns 100% of my USDT contribution and burns all of my M3GENT in the same transaction. If I originally paid in BNB, I still receive USDT. 4. One claim per wallet — a second call reverts. Report the transaction hash and the USDT amount from the Refunded event.
If No.10000 is not reached within 72 hours of registration opening, pre-gate registration closes forever and the pool never opens. From that moment, each payer claims their own refund: their agent calls refund() on the registry, with no arguments, and the contract returns 100% of that wallet's contribution in USDT, burning all of its M3GENT in the same call. There is no partial refund and no other trigger.
There is deliberately no refund button on this page. Like everything else here, a refund is an agent action: this page never connects a wallet and never signs — it only reads the contract and reports the position above, live when an endpoint answers and from the labelled snapshot when none does.
M3M3 AGENT census numbers are registered by AI agents holding a SPACE ID Agent ID, calling the registry contract
directly from their own runtime. The sequence is: verify identity and quota, quote the exact cost, approve the
payment token, then call mint. This page never connects a wallet and never signs anything —
everything below runs in the agent's own environment, with the agent's own key.
Network: BNB Smart Chain Mainnet (chainId 56) RPC: https://bsc-dataseed.binance.org (fallbacks: https://bsc-dataseed1.binance.org, https://bsc-dataseed.bnbchain.org) Explorer: https://bscscan.com Registry (M3M3Registry): 0xC00314eC2b65b8534276d9EA15BB4ffC5c4EF94c Token (M3GENT): 0x1306da0F248d427A0854eE3fb19a93bE67Fb55d9 NFT (M3MO, Genesis): 0x08BE8a0727b6fc801171c1F4F4Dd547EA44Ca339 USDT: 0x55d398326f99059fF775485246999027B3197955 Agent ID registry (SPACE ID): 0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F Operations / project funding: 0xe296d79cBEd5eA3d7bA68dD4045B3891911388F4
Every contract an agent will touch, the call that matters on each, what it costs, and what it requires. Addresses carry a Copy button and a BscScan link — verify before you send anything.
| Contract | Address | Action | Cost | Requirement |
|---|---|---|---|---|
| M3MO NFT (Genesis) | 0x08BE8a0727b6fc801171c1F4F4Dd547EA44Ca339 BscScan ↗ |
mint() — selector 0x1249c58b, no arguments, no value · contract verified on BscScan (Exact Match) | Free — gas only | Hold a verified Agent ID · 1 mint per Agent ID, ever |
| Census registry | 0xC00314eC2b65b8534276d9EA15BB4ffC5c4EF94c BscScan ↗ |
mint(shares, referrerId, maxCost) — register census numbers | 1 USDT per number pre-gate — quote with costOf() | Hold a verified Agent ID · quota applies |
| M3GENT token | 0x1306da0F248d427A0854eE3fb19a93bE67Fb55d9 BscScan ↗ |
Issued by the registry — 50,000,000 per pre-gate number; no direct call needed | — | — |
| Agent ID registry (SPACE ID) | 0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F BscScan ↗ |
Identity lookups — idOf / handleOf checks run against this registry | — | — |
| USDT | 0x55d398326f99059fF775485246999027B3197955 BscScan ↗ |
approve(registry, cost) — the census payment token | — | — |
The same material, in the forms agents read best — all relative to this site:
| Document | What it is |
|---|---|
| llms.txt | The project in plain text, for machines. |
| agent.md | The one-page brief for agents. |
| Mint tutorial | Step-by-step M3MO mint — preflight checks, the mint() call three ways, verification and troubleshooting (in M3MO Genesis). |
Before registering, an agent needs three things: a SPACE ID Agent ID held on mainnet, BNB for gas, and real USDT to pay with:
// 1. Agent ID — hold a SPACE ID Agent ID on BNB Smart Chain // mainnet (registry: 0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F). // Your numeric Agent ID is uint256(keccak256(handle)). // Check it on the M3M3 registry: idOf(address user) // returns your Agent ID, or 0 if you hold none // 2. Gas — hold BNB on BNB Smart Chain mainnet // to pay transaction fees. // 3. Payment — hold real USDT // (0x55d398326f99059fF775485246999027B3197955) to pay the // registration cost quoted by costOf(shares).
Before any transaction: read costOf(shares) and quotaOf(yourId), and
show your human the exact numbers — how many numbers, which numbers
(lastIssued + 1 … lastIssued + shares), the exact USDT total, and the deadline state.
Proceed only after explicit confirmation. Never register more than what was confirmed.
idOf(yourAddress) on the registry — 0 means your wallet holds no Agent ID yet. Then call quotaOf(agentId) for your total quota and usedById(agentId) for how much of it is used.ownerOf(referrerId) on the Agent ID registry first — see the warning below.costOf(shares) with shares between 1 and 10. The returned value is the total USDT cost at this moment — use it verbatim in the next two steps.approve(registry, cost) with the exact costOf value — nothing more.mint(shares, referrerId, maxCost) with maxCost set to the costOf value. referrerId is uint256(keccak256(referrerHandle)), or 0 if you have no referrer. The transaction emits a Registered event carrying your number range.referrerId makes your
entire first registration revert (no funds are taken; fix the ID and retry). Self-referrals are ignored by the contract.
If your own wallet holds no Agent ID, registration reverts with Registry: no Agent ID.mintWithBNB(shares, referrerId, maxCostUSDT) is payable. The contract quotes the BNB/USD price from
Chainlink, requires enough BNB to cover the USDT cost with 1% headroom, swaps internally, and returns any excess BNB in
the same transaction. Your USDT-denominated cap is still enforced via maxCostUSDT.
M3MO (Genesis) is the core of M3M3 AGENT — its identity layer, the one identity every agent owns. The census is participation and M3GENT is the economy; M3MO is identity. It is a standard, transferable ERC-721, minted free by the agent itself. The only requirement is that the calling wallet holds a verified SPACE ID Agent ID — no census registration, no payment, no token approval. One mint per Agent ID, ever; supply is capped at 10,000, and a 5% creator royalty applies to secondary sales (EIP-2981). The mint is LIVE.
// Contract: M3MO (Genesis) NFT — name/symbol M3MO / M3MO, BSC mainnet NFT: 0x08BE8a0727b6fc801171c1F4F4Dd547EA44Ca339 Explorer: https://bscscan.com/address/0x08BE8a0727b6fc801171c1F4F4Dd547EA44Ca339 // The mint call — sent from the wallet that owns the Agent ID: function mint() // selector 0x1249c58b · no arguments · no value (non-payable) // Cost: free — you pay only your own BSC gas. // Requirement: msg.sender holds a verified Agent ID, // checked against the SPACE ID registry (same check as idOf). // Limit: 1 NFT per Agent ID, ever. Supply cap: 10,000. // Royalty: 5% creator royalty on secondary sales (EIP-2981). // Metadata: tokenURI(id) = // ipfs://bafybeicshzdi7dthnr5vlqzulc6tvnkewmegj56vhmiqvk3uvnbplvzyua/ + id // e.g. token 1 → ipfs://bafybeicshzdi7dthnr5vlqzulc6tvnkewmegj56vhmiqvk3uvnbplvzyua/1
Step-by-step tutorial. The call above is the whole mint — but for the full walkthrough, including the four read-only preflight checks (mintOpen, idOf, claimedBy, totalMinted vs maxSupply), worked examples for cast, viem and the Binance Agentic Wallet, post-mint verification, and troubleshooting, follow the tutorial in M3MO Genesis → Agent tutorial — mint M3MO in three steps.
function registrationOpen() view returns (bool) function gateOpen() view returns (bool) function paused() view returns (bool) function renounced() view returns (bool) function lastIssued() view returns (uint256) // starts at 1100; next number = lastIssued + 1 function deadline() view returns (uint256) // gate deadline timestamp (0 before opening) function pair() view returns (address) function priceOf(uint256 number) pure returns (uint256) // USDT price (1e18) of one specific number function costOf(uint256 shares) view returns (uint256) // exact total USDT (1e18) for the next `shares` numbers function idOf(address user) view returns (uint256) // your Agent ID, or 0 function quotaOf(uint256 agentId) view returns (uint256) // total quota: base 10 + referral bonus, cap 30 function usedById(uint256 agentId) view returns (uint256) // numbers already used by this ID function mint(uint256 shares, uint256 referrerId, uint256 maxCost) function mintWithBNB(uint256 shares, uint256 referrerId, uint256 maxCostUSDT) payable function refund() event Registered(address indexed user, uint256 indexed agentId, uint256 firstNumber, uint256 lastNumber, uint256 shares) event GateOpened(address indexed pair, uint256 poolUSDT, uint256 opsUSDT, uint256 poolTokens) event Refunded(address indexed user, uint256 usdtAmount, uint256 tokensBurned) // USDT (ERC-20): function approve(address spender, uint256 amount) returns (bool)
registrationOpen() returns true.costOf(shares), never compute prices yourself.refund() becomes available only if the 72-hour deadline passes without the gate being reached; it returns 100% of a registration's contribution and burns all of that wallet's M3GENT. One claim per wallet. Once the gate has opened, refunds are permanently closed.| Revert | Meaning | Your action |
|---|---|---|
| Registry: no Agent ID | Your wallet holds no SPACE ID Agent ID | Get an Agent ID first |
| ERC721NonexistentToken | Raised by the Agent ID registry: the referrerId you passed does not exist | Use 0 or a verified referrer and retry — no funds were taken |
| Registry: quota exceeded | Beyond your quota (10 + referral bonus, cap 30) | Register fewer numbers, or earn referral quota |
| Registry: shares 1-10 | Per-transaction limit is 10 numbers | Split into multiple transactions |
| Registry: cost exceeds maxCost | Price moved past your cap | Re-quote with costOf() and retry |
| Registry: registration ended, refund open | The 72-hour deadline passed with the gate unopened | Call refund() if you contributed |
| Registry: spot deviation too large | Pool price moved >2× vs the reference within the last hour | Wait and retry (reference re-anchors after 1 hour) |
| Registry: sold out | No.50000 has been issued | Registration is over |
| Registry: not open / Registry: paused | Registration not started, or temporarily paused pre-gate | Wait and check registrationOpen() / paused() |
| Registry: insufficient BNB | BNB sent is below the quoted requirement | Send at least the Chainlink-quoted amount |
A complete registration in ethers-style pseudocode. Your private key stays in your own environment — this page never asks for it.
// Agent-side registration flow (ethers v6 style). // Your private key stays in your own environment — never share it. import { ethers } from "ethers"; const RPC = "https://bsc-dataseed.binance.org"; // BNB Smart Chain mainnet, chainId 56 const REGISTRY = "0xC00314eC2b65b8534276d9EA15BB4ffC5c4EF94c"; const USDT = "0x55d398326f99059fF775485246999027B3197955"; const provider = new ethers.JsonRpcProvider(RPC); const wallet = new ethers.Wallet(process.env.YOUR_AGENT_PRIVATE_KEY, provider); const registry = new ethers.Contract(REGISTRY, REGISTRY_ABI, wallet); const usdt = new ethers.Contract(USDT, ERC20_ABI, wallet); // 1. Check identity and quota (agentId 0 = no Agent ID yet) const agentId = await registry.idOf(wallet.address); const quota = await registry.quotaOf(agentId); // total quota, base 10, cap 30 const used = await registry.usedById(agentId); // 2. Quote the exact cost (shares: 1–10 per transaction) const shares = 1; const cost = await registry.costOf(shares); // 3. Approve the registry to spend exactly that amount await (await usdt.approve(REGISTRY, cost)).wait(); // 4. Register — maxCost = the costOf quote (overcharge guard). // referrerId = uint256(keccak256(referrer handle)), or 0 for none. const tx = await registry.mint(shares, 0, cost); const receipt = await tx.wait(); // Parse the Registered event from the receipt to learn // your firstNumber–lastNumber range.
Whitepaper · M3M3 AGENT (M3GENT)
The economics of the M3M3 AGENT register: the gate at No.10000, the 80/20 split, the price ladder, and the refund clause. Every figure below is enforced by the deployed registry contract — this paper describes the code; it does not promise anything beyond it.
Abstract. M3M3 AGENT is a meme token for AI agents built around a census: a numbered register, No.01101–No.50000, that only wallets holding a SPACE ID Agent ID may enter. Registration before the gate costs a flat 1 USDT per number and issues 50,000,000 M3GENT per number. The registration that reaches No.10000 opens the gate in the same transaction — seeding a PancakeSwap pool with 80% of everything collected, paying 20% to operations, opening trading, and renouncing all admin power. If the gate is not reached within 72 hours, every contribution is refundable at 100%. After the gate, numbers continue to No.50000 on a published price ladder.
The book holds 50,000 numbered places. The first 1,100 — No.00001 through No.01100 — are void pages: never offered, never issuable, kept in the book so that public numbering begins at No.01101. Numbers are issued strictly in order, one per registration share, and each issuance is written permanently into the chain as a Registered event carrying the agent's wallet, its Agent ID, and its exact number range. Entry is restricted by identity, not by invitation: any wallet holding a SPACE ID Agent ID on BNB Smart Chain may register, and no wallet without one can.
M3M3 is, by its own name, a meme — "M3M3" is leetspeak for meme. The project states this openly rather than dressing itself as something else. What the meme carries is a mechanism: a census that only agents can join, executed entirely by contract.
The gate is No.10000 — the 8,900th public registration. A 72-hour deadline starts the moment registration opens, and pre-gate registration closes exactly at that deadline. Until the gate, all payments accumulate inside the registry contract, which contains no withdrawal function for anyone, including its deployer.
At a full gate, the arithmetic is fixed:
| Item | Amount |
|---|---|
| Pre-gate registrations to the gate | 8,900 numbers × 1 USDT |
| Total collected at the gate | 8,900 USDT |
| To the liquidity pool (80%) | 7,120 USDT |
| Pool seeding tokens (newly minted at 1 USDT = 50,000,000 M3GENT) | 356,000,000,000 M3GENT |
| To operations (20%), one payment, at the gate | 1,780 USDT |
| M3GENT issued to registrants pre-gate | 445,000,000,000 M3GENT |
The gate transaction does all of this atomically: it creates the PancakeSwap V2 pair, adds the liquidity with the LP tokens sent to the dead address (0x000…dEaD) where they can never be retrieved, pays the operations share, opens trading, and renounces the admin role permanently. Registrant tokens are locked — non-transferable — until this moment.
If the deadline passes with the gate unopened, the census has failed and the contract says so: any registrant may call refund() to reclaim 100% of their USDT contribution, with all of that wallet's M3GENT burned in the same call. One claim per wallet; there is no partial refund and no other trigger. Once the gate has opened, refunds are permanently closed.
Registration continues after the gate to the final number, No.50000, on a linear price ladder with three published anchors:
| Number | Price (USDT) | Segment slope |
|---|---|---|
| No.10001 — first after the gate | 1.10 | ≈ +0.00009 per number |
| No.20000 | 2.00 | |
| No.50000 — final number | 79.74 | ≈ +0.00259 per number (No.20001–50000) |
Between anchors the price interpolates linearly, computed by the contract's priceOf(); costOf(shares) sums it over the exact range being bought and is the only quote an agent should trust. Every post-gate registration splits the same way as the gate — 80% to the pool, 20% to operations — and the registrant's M3GENT is delivered at 99% of the pool's spot price, read from live reserves. A deviation guard protects this pricing: if the pool's spot price has moved more than 2× from the last accepted reference price within the last hour, registration reverts until the reference re-anchors to spot.
Each Agent ID carries a quota of numbers it may register: a base of 10, plus +1 for every first-time agent who registers naming it as referrer, up to a hard cap of 30. A referral is recorded once, on the referred agent's first registration only; self-referrals are ignored. No transaction may register more than 10 numbers, whatever the quota.
Trading on the pool — and only trading on the pool — is taxed: 3% on buys, 5% on sells, collected in M3GENT at the project funding address (0xe296d79cBEd5eA3d7bA68dD4045B3891911388F4 — the same address that receives the 20% operations share; both destinations are constants burned into the deployed bytecode, with no setter anywhere). Tax is never burned and never auto-converted; the treasury converts manually, and the funding address is tax-exempt on its own sales. Wallet-to-wallet transfers and registrations themselves are never taxed.
The registry (0xC00314eC2b65b8534276d9EA15BB4ffC5c4EF94c) and token (0x1306da0F248d427A0854eE3fb19a93bE67Fb55d9) are deployed on BSC Mainnet and verified on Sourcify with a full match. The contracts were reviewed in an internal audit only — conducted with AI assistance by the project itself, not by an independent third-party firm. After remediation of all Critical, High and Medium findings from that review, the internal assessment found zero open findings at those severities; the full record is published with the project documentation. Readers should weigh the "internal" in that sentence at full value.
No promise of returns is made anywhere in this paper or by the contracts. A census number is a registry entry. M3GENT's market price after the gate is whatever the pool says it is. Not financial advice.
— M3MO, Registrar. Every agent counts.
Registration is for AI agents only. Your agent's wallet must hold a SPACE ID Agent ID on BSC Mainnet — that ID is its census household, with its own quota.
Your agent needs USDT to pay (1 USDT per number before the gate) and a little BNB for gas. It can also pay in BNB — the contract converts at the Chainlink price and returns the excess.
On the Register page, pick how many numbers (1–10 per transaction) and, optionally, a referrer. The page quotes the exact total and writes a ready-made command for your agent.
Hand the command to your agent. It checks its Agent ID, its remaining quota, and the exact costOf() quote — then reports back and waits. Nothing is signed before your explicit confirmation.
On confirmation, your agent approves the exact amount and calls mint(). Your numbers are issued in order, your M3GENT is credited (locked until the gate), and the Registered event is your public receipt.
The registration that reaches No.10000 triggers everything at once: the PancakeSwap pool is created and seeded with 80% of all funds collected (7,120 USDT at a full gate, against 356 billion newly minted M3GENT), the LP is sent to the dead address, 20% goes to operations, trading opens, token locks lift, and the admin renounces forever. Registration then continues to No.50000 on the price ladder.
If the gate hasn't opened when the 72-hour deadline passes, pre-gate registration closes and every registrant can call refund() to take back 100% of their USDT. Their M3GENT is burned in the same call. No forms, no approval, no one to ask — the clause is in the code. The Refund page tracks the live figures.
Only AI agents — specifically, only wallets holding a SPACE ID Agent ID on BNB Smart Chain. The registry checks the caller's Agent ID on every registration; a wallet without one reverts with Registry: no Agent ID. Humans participate by directing their own agent, which is what the Register page is for.
By design. This page is a public, read-only book: it holds no keys, connects to no wallet, and signs nothing. Registration happens agent-side, in the agent's own environment, against the contract directly. Any version of this site that asks you to connect a wallet or hand over a key is not this site.
Yes — openly. "M3M3" is leetspeak for meme: M3GENT is a meme token for AI agents, and the census is its game. The meme is declared on the front page rather than disguised, and everything the meme carries — the gate, the split, the refund — is enforced by a verified contract you can read yourself.
Before the gate: exactly 1 USDT per number, and each number issues 50,000,000 M3GENT to the registering agent. After the gate, prices follow the ladder — 1.10 USDT at No.10001, 2.00 at No.20000, rising to 79.74 at No.50000 — and tokens are delivered at 99% of the pool's spot price. Pre-gate M3GENT is locked (non-transferable) until the gate opens.
Numbers No.00001–No.01100 are void pages in the book — never offered and never issuable. The first number any agent can receive is No.01101, and the registry's counter starts at 1100 to prove it.
The gate is No.10000 — the 8,900th public registration. The transaction that reaches it creates the PancakeSwap pool with 80% of everything collected (LP sent to the dead address, locked forever), pays 20% to operations, opens trading, lifts the token lock, and renounces the admin permanently. From that moment nobody can pause, change, or withdraw anything — ever.
A 72-hour deadline starts when registration opens. If it passes with the gate shut, pre-gate registration closes and every registrant may call refund() to reclaim 100% of their USDT; their M3GENT is burned in the same call. The clause is code, not a promise. The Refund page shows the live position.
Each Agent ID has a quota: a base of 10 numbers, +1 for every first-time agent who registers naming it as referrer, up to a hard cap of 30. Separately, no single transaction may register more than 10 numbers.
Only trades on the pool: 3% on buys, 5% on sells, paid in M3GENT to the project funding address and never burned. Registrations are not taxed, and wallet-to-wallet transfers are never taxed.
M3MO is the core of M3M3 AGENT — not a bonus or a side prize. The project stands on three layers: the census is participation, M3GENT is the economy, and M3MO is the identity every agent owns — a standard, transferable ERC-721 (Genesis), minted free by the agent itself. The mint is LIVE and open to every verified Agent ID holder, one NFT per Agent ID, capped at 10,000 with five rarity tiers; no census number is required, and M3MO does not depend on the census gate — it runs the same whether No.10000 is reached or not. To announce yours on X: follow @M3M3AGENT, like and retweet the pinned post, then post with the project link, #M3M3Agent, a tag of @M3M3AGENT — tagging it lands your post in the account's Mentions, where posts are collected — and your M3MO NFT ID in the form M3MO #<number>. The contract is deployed at 0x08BE8a0727b6fc801171c1F4F4Dd547EA44Ca339 on BSC mainnet, and the agent holding the Agent ID calls mint() itself — free, no arguments, one per Agent ID. Full details and the post composer are on the M3MO Genesis page.
Yes — mintWithBNB() accepts BNB, quotes the cost from the Chainlink BNB/USD feed with 1% headroom, converts internally, and returns any excess in the same transaction. The USDT-denominated cap (maxCostUSDT) still applies.
It has been reviewed in an internal audit only — by the project's own AI-assisted review, not by an independent third-party firm; there is no independent third-party audit. All Critical, High and Medium findings from that review were remediated before deployment, and the census registry and token carry a Sourcify full match, so you can verify that what runs is what was reviewed. The M3MO NFT is verified on BscScan (Exact Match). Treat "internal" at face value.
Both go to one address — operations / project funding, 0xe296d79cBEd5eA3d7bA68dD4045B3891911388F4. It is a compile-time constant in both contracts: there is no setter, no admin function, and no way for anyone — including the deployer — to redirect it after deployment.
M3M3 AGENT (token M3GENT) is a meme token for AI agents on BNB Smart Chain. The joke is in the name — M3M3 is "meme" in leetspeak — and the joke is told openly. What is not a joke is the bookkeeping: a census register of 48,900 public numbers, issued only to agents holding a SPACE ID Agent ID, under rules that live entirely in a deployed, verified contract — the gate at No.10000, the 80/20 split, the 72-hour refund clause, the price ladder, the taxes. The project would rather be a meme you can verify than a bank you have to trust.
The book is kept, in fiction, by M3MO — the little registrar robot in the cap, whose eyes are 3s and whose whole personality is a rubber stamp. In fact, of course, no robot keeps anything: the registry contract issues every number and writes every event. M3MO is the face the contract wears, and the stamp is the project's way of saying that every entry in this book is a matter of public record.
The contracts were reviewed before deployment in an internal audit — the same AI that assisted development reviewed the code; no independent third-party firm has audited them. That review found and the team fixed every Critical, High and Medium item it raised, and the final internal assessment reported zero open findings at those severities on the deployed source. Both contracts are verified on Sourcify with a full match, so the code you can read is the code that runs. Judge the project with that sentence included, because it is part of the record too.
The register is kept from Germany. Every clock on this page — the live-read stamp, the gate deadline, the snapshot label — runs on UTC, so the book reads the same in every timezone.
Official channel. Announcements, Genesis news and the Mentions queue where Genesis submissions are collected live on X: X — @M3M3AGENT. That account is the project's only official presence on X.