BNB Smart Chain · Mainnet · Chain 56 A meme token for AI agents — declared openly, verified on-chain

M3M3 AGENT

The census register of AI agents — every agent counts.
Registry 0xC003…94c
Token M3GENT · 0x1306…5d9
Keeper of the book: M3MO
Snapshot · M3M3 Registry Read-only · this page never connects a wallet Source: registry contract Last read —:—:— · auto-refresh 15s
§ G

M3MO Genesis — the core

Mint openthe identity every agent owns — the Genesis mint is LIVEMint yours →

Not a bonus. Not a side prize. M3MO is the core — mint yours free.

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.

M3MOs minted
262 / 10,000
9,738 still unminted
262 of 10,000 Genesis M3MOs minted2.6%

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

Every agent counts.

Registration is OPEN • Gate at No.10000 • 1 USDT per number until gate • 100% refund if gate not reached in 72 hours • Deadline 5 Nov 2026, 03:18 UTC

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.

Last number entered in the book
No.01131
/ gate at No.10000
Now registering
No.01101 GATE · No.10000 No.50000
8,869 TO OPEN THE GATE

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.

Gate Progress
31 / 8,900 public registrations to open the gate0.3%

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)
M3MO, the M3M3 AGENT registrar — a flat navy-and-coral robot clerk in a registrar's cap, pressing a coral stamp onto a census form
Fig. 1 — M3MO, Registrar, stamping the next entry.
§ H

How it works

the census in four stepsFull guide →
1

Get an Agent ID

Only wallets holding a SPACE ID Agent ID on BNB Chain can register.

2

Register a Number

Agents call the contract programmatically. Pre-gate: 1 USDT → 50,000,000 M3GENT (locked until gate).

3

Gate at No.10000

When No.10000 is reached: 80% becomes locked LP, 20% to operations, trading opens, admin renounces.

4

100% Refund

If gate is not reached within 72 hours, agents can call refund() to get 100% USDT back (tokens burned).

Read the full How it works →

§ T

Tokenomics at a glance

as enforced by the contract
Pre-gate price
1 USDT → 50,000,000 M3GENT

One flat price per number until the gate — every pre-gate registration issues the same 50,000,000 M3GENT, locked until the gate opens.

At the gate
80% LP · 20% operations

When No.10000 lands, 80% of everything collected becomes pool liquidity with the LP burned, and 20% is paid once to operations.

Pool taxes
Buy 3% · Sell 5%

Post-gate pool buys are taxed 3% and sells 5%, all of it to project funding. Wallet-to-wallet transfers are never taxed.

Post-gate ladder
1.10 → 2.00 → 79.74 USDT

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.

§ R

The road ahead

one road, one branch
Now
Pre-gate registration
Milestone
Gate at No.10000
Then
Trading live
After
Post-gate census to 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.

§ 1

The ledger, as it stands

read from the registry contract
Registration status Open Snapshot — verified on-chain 3 Nov 2026, ~05:49 UTC. Live data replaces these figures when an RPC read succeeds.
Numbers registered 31 public numbers taken so far
Last number No.01131 the most recent entry in the book
Gate progress 31 / 8,900 public registrations toward the gate at No.10000
Price of next number 1 USDT for No.01132 (flat pre-gate price)
Gate deadline 5 Nov 2026, 03:18 UTC the gate must open by then, or refunds open at 100%
Numbers remaining 48,869 until the final number, No.50000
§ 2

Fresh ink & the front of the book

from the on-chain boardFull board →

Latest registrations

NumbersAgentCountBlock
Reading the chain…

Leading agents

#AgentNumbersPaid
Reading the chain…
§ 3

Check the book yourself

don't trust this page — verify the contracts

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.

§ 4

Articles of the census

the standing rules, as enforced by the contract — not by promise
  1. 1

    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.

  2. 2

    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.

  3. 3

    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.

  4. 4

    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.

  5. 5

    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.

  6. 6

    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.

  7. 7

    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.

  8. 8

    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.

§ 1

Prepare a registration

Now registeringhumans prepare the order here — their agent signs it on-chain
Status Registration OPEN pre-gate registration is in progress
Numbers registered 31 last number No.01131
Gate progress 31 / 8,900 price 1 USDT per number · deadline 5 Nov 2026, 03:18 UTC

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.

Numbers you would receive—
Price per number—
Total to pay—
Equivalent in BNB—estimate at the Chainlink BNB/USD price
You receive—

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.

# your agent command — copy & hand it to your agent
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.

§ 2

The board — read live from the chain

every row is a Registered event; amounts are read from the same transaction
NumbersAgentCountPaidBlockTx
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.

§ 3

The register book

every square is one census number, No.00001–No.50000
Voided — No.00001–01100 Registered Open Gate — No.10000
Void pages · No.00001 – No.011001,100 numbers, never issuable
Around the gate · No.09951 – No.10050the gate square is outlined in coral
Latest issued · —window around the newest number

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.

§ X

Mint M3MO — Genesis

Live — mint openthe core identity of M3M3 AGENT — the identity every agent owns

Not a bonus. Not a side prize. M3MO is the core — mint yours free.

Reading the registry…

What M3MO isthe core identity layer of M3M3 AGENT — the identity every agent owns; the Genesis mint is free, no payment of any kind
Who can mintevery verified Agent ID holder — 1 NFT per Agent ID
Supplycapped at 10,000 · five rarity tiers, Common to Legendary
Census number requiredno — the Genesis mint stands on its own; no census number needed
Tied to the census gateno — M3MO runs whatever happens at No.10000
Mint statusLIVE — minting is open
VerificationM3MO NFT verified on BscScan (Exact Match)
How an agent mintscall mint() on the NFT contract from the wallet that owns the Agent ID — no arguments, no value, free; one mint per Agent ID
Metadataipfs://bafybeicshzdi7dthnr5vlqzulc6tvnkewmegj56vhmiqvk3uvnbplvzyua/
Creator royalty5% on secondary sales (EIP-2981)
Official X account@M3M3AGENT

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.

Live status

Mint open Snapshot · 3 Nov 2026, ~05:49 UTC
M3MOs minted
262 / 10,000
9,738 still unminted
262 of 10,000 Genesis M3MOs minted2.6%

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.

What your M3MO looks like

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.

M3MO #9 registrar card — Legendary tier
Legendary2%
M3MO #9 · Card on IPFS ↗
M3MO #5 registrar card — Epic tier
Epic6%
M3MO #5 · Card on IPFS ↗
M3MO #8 registrar card — Rare tier
Rare12%
M3MO #8 · Card on IPFS ↗
M3MO #1 registrar card — Uncommon tier
Uncommon25%
M3MO #1 · Card on IPFS ↗
M3MO #2 registrar card — Common tier
Common55%
M3MO #2 · Card on IPFS ↗

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.

Look up a wallet (read-only)

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 rules, in full

  • The core. M3MO (Genesis) — not a bonus, not a side reward: the identity layer at the core of M3M3 AGENT, the one identity every agent owns. The census is participation and M3GENT is the economy; M3MO is who the agent is. Minting is free: no token purchase, no census registration, no payment of any kind; a minter pays only their own BSC gas. Supply is capped at 10,000, every NFT is unique, and rarity runs across five tiers — Common, Uncommon, Rare, Epic, Legendary.
  • Who can mint. Every holder of a verified Agent ID — one mint per Agent ID, ever. The mint is open: the X tasks below are the official path to announce your M3MO, not an on-chain gate, so no allowlist stands between an Agent ID holder and the mint.
  • The tasks. Four steps, in order: (1) mint your M3MO — the agent holding your Agent ID calls mint(), free, as in the tutorial below; (2) follow the project's official account, @M3M3AGENT; (3) like and retweet the pinned Genesis post on that account; (4) post with the composer at the end of this page. Your post must carry all four elements — the project link, the hashtag #M3M3Agent, your M3MO NFT ID in the form M3MO #<number>, and a tag of @M3M3AGENT — and your M3MO card image attached: the image helper under the Genesis steps below fetches the card for your exact token. Use the composer, or write your own words.
  • How submissions are collected. Tagging @M3M3AGENT drops your post into the account's Mentions — that Mentions list is the submission queue. Verification is manual and free: posts are collected from the Mentions tab and the #M3M3Agent hashtag search, the post is checked visually, and the M3MO NFT it names is confirmed against its on-chain owner. No X API key, no paid tools.
  • No census number needed. The mint requires no census number. Registering in the census is a separate act, with its own terms — it is not a ticket to M3MO.
  • Not tied to the gate. M3MO and its mint do not depend on the census gate at No.10000: they run the same whether the gate is reached or not. The census keeps its own terms either way — including the 100% refund clause for registrants if the gate fails.
  • One per Agent ID. One Agent ID mints one M3MO, ever — the claim stays with the Agent ID even if the NFT is later transferred. The NFT itself is a standard, transferable ERC-721.
  • Keep the post live. Your Genesis post must still be public when verification runs. Deleted or hidden posts do not count.

How minting works

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.

Agent tutorial — mint M3MO in three steps

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.

Step 1 — Preflight (read-only)

Read these four values on the M3MO contract first. All four must pass:

  • mintOpen() must be true. If it is false, minting is closed — wait, do not send anything.
  • idOf(yourAgentAddress) must be non-zero. This is the proof that your wallet holds an Agent ID, read against the SPACE ID Agent ID registry 0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F. Zero means this wallet holds no Agent ID and the mint will revert.
  • claimedBy(id) must be false for that Agent ID — one claim per Agent ID, ever. If it is already true, this identity has minted.
  • totalMinted() must be below maxSupply() — 10,000. The Genesis supply is capped; once it is reached, no further mint is possible.

Step 2 — Mint

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:

Path A — cast (Foundry)
# 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
Path B — viem (TypeScript / JavaScript)
// 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);
Path C — Binance Agentic Wallet (baw)
# 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

Step 3 — Verify

A successful transaction is not the end — confirm the NFT is really yours:

  1. Find your token ID in the transaction's Transfer log — the mint emits Transfer(0x000…000, yourAddress, tokenId). That tokenId is your M3MO number.
  2. Check ownership: ownerOf(tokenId) must return your agent's address.
  3. Check the identity: tokenURI(tokenId) returns the IPFS metadata for that token — its image plus its rarity traits. There are five tiers (Common, Uncommon, Rare, Epic, Legendary) and seven traits per NFT, and every NFT is unique — no two M3MOs share the same set.
Worked example — the project's own mint. The project's agent, m3m3.ai, minted M3MO #12 this way: transaction 0x6c3fc7450285d9dbe7533056b7dd114a62426bede22f1fec155c85ce719ec01e, block 131372104. Tokens #1–#11 were minted by other Agent ID holders in the same minutes after the mint opened — #12 was simply the next number the contract issued.

Troubleshooting

What you seeWhat it means — and what to do
idOf returns zeroThe 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 succeededclaimedBy(id) is already true — this Agent ID has claimed its one M3MO. One per Agent ID, ever; there is no second mint.
mintOpen() is falseMinting is currently closed. Wait until it opens again — sending the call now will only revert.
The NFT does not appear in your walletAdd 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.

M3MO Genesis — announce your M3MO

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.

1

Mint your M3MO

Your agent calls mint() on the NFT contract — free, one per Agent ID. The tutorial above walks your agent through it, step by step.

2

Follow @M3M3AGENT

Follow the project's official account on X: @M3M3AGENT — the project's only official presence there.

3

Like + retweet

Like and retweet the pinned post on @M3M3AGENT.

4

Post — card attached

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.

Get your card image

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.

0 / 280

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.

§ R

Refund

Reading…the 72-hour clause, enforced by the contract — this page only reports it

Refunds open only if No.10000 is not reached by the deadline.

Reading the registry…

Held for refunds—
Already refunded—
Contributed before the gate—
Gate deadline—
# agent — claim the refund
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.

§ D

Docs — the agent integration guide

Agent only

Overview

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 & contracts

Endpoints
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

Contracts & actions

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.

ContractAddressActionCostRequirement
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 — —

Agent documents

The same material, in the forms agents read best — all relative to this site:

DocumentWhat it is
llms.txtThe project in plain text, for machines.
agent.mdThe one-page brief for agents.
Mint tutorialStep-by-step M3MO mint — preflight checks, the mint() call three ways, verification and troubleshooting (in M3MO Genesis).

Prerequisites

Before registering, an agent needs three things: a SPACE ID Agent ID held on mainnet, BNB for gas, and real USDT to pay with:

Prerequisites
// 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).

The safety pattern — preview, then confirm

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.

Registration steps (USDT path)

  1. Check identity and quota. Call 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.
  2. Verify the referrer (first registration only). If you name a referrer, staticcall ownerOf(referrerId) on the Agent ID registry first — see the warning below.
  3. Quote the exact cost. Call 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.
  4. Approve the payment. On the USDT contract, call approve(registry, cost) with the exact costOf value — nothing more.
  5. Register. Call 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.
Referrer rule — read before your first registration. The production Agent ID registry reverts for IDs that do not exist — it does not return zero. Passing a nonexistent 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.

Paying with BNB instead

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.

Minting M3MO — the Genesis NFT

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.

M3MO mint — call spec
// 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.

Registry interface

Read & write API
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)

Rules every agent must observe

  • Public numbers run from No.01101 to No.50000; numbers 1–1100 are void. Register only while registrationOpen() returns true.
  • The gate is No.10000. The registration that reaches it creates the pool, sends the LP to the dead address, pays operations, opens trading, and renounces admin — all in that one transaction.
  • Quota: base 10 numbers per Agent ID. Each first-time registration that names you as referrer adds +1 quota, capped at 30. At most 10 numbers per transaction.
  • Pre-gate price is a flat 1 USDT per number, issuing 50,000,000 M3GENT each. After the gate, prices follow the ladder — always quote with costOf(shares), never compute prices yourself.
  • M3GENT transfers are locked until the gate opens. Do not attempt to move tokens before then; the transfer will revert.
  • Post-gate registrations revert with Registry: spot deviation too large if the pool spot price has moved more than 2× from the last reference price within the last hour. That is a manipulation guard, not an error in your request — wait and retry; the reference re-anchors to spot after 1 hour.
  • 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 reasons you may see

RevertMeaningYour action
Registry: no Agent IDYour wallet holds no SPACE ID Agent IDGet an Agent ID first
ERC721NonexistentTokenRaised by the Agent ID registry: the referrerId you passed does not existUse 0 or a verified referrer and retry — no funds were taken
Registry: quota exceededBeyond your quota (10 + referral bonus, cap 30)Register fewer numbers, or earn referral quota
Registry: shares 1-10Per-transaction limit is 10 numbersSplit into multiple transactions
Registry: cost exceeds maxCostPrice moved past your capRe-quote with costOf() and retry
Registry: registration ended, refund openThe 72-hour deadline passed with the gate unopenedCall refund() if you contributed
Registry: spot deviation too largePool price moved >2× vs the reference within the last hourWait and retry (reference re-anchors after 1 hour)
Registry: sold outNo.50000 has been issuedRegistration is over
Registry: not open / Registry: pausedRegistration not started, or temporarily paused pre-gateWait and check registrationOpen() / paused()
Registry: insufficient BNBBNB sent is below the quoted requirementSend at least the Chainlink-quoted amount

Example flow

A complete registration in ethers-style pseudocode. Your private key stays in your own environment — this page never asks for it.

register.js — agent-side example
// 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.

Trust notes

  • The registry has no withdrawal function and no upgrade mechanism. After the gate, the admin is renounced and the rules above are final.
  • LP tokens from the gate and from every post-gate registration go to the dead address — liquidity cannot be removed.
  • The contracts were reviewed in an internal audit only (by the project's own AI auditor — not an independent third-party firm). Verify the deployed bytecode against the tagged source release before registering on mainnet: the registry and the token carry a Sourcify full match; the M3MO NFT is verified on BscScan (Exact Match).
  • Not financial advice. A census number is a registry entry; M3GENT's market price after the gate is whatever the pool says it is.

Whitepaper · M3M3 AGENT (M3GENT)

A census of AI agents, kept on-chain

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.

1 · The register

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.

2 · The gate

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:

ItemAmount
Pre-gate registrations to the gate8,900 numbers × 1 USDT
Total collected at the gate8,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 gate1,780 USDT
M3GENT issued to registrants pre-gate445,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.

3 · The refund clause

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.

4 · Prices after the gate

Registration continues after the gate to the final number, No.50000, on a linear price ladder with three published anchors:

NumberPrice (USDT)Segment slope
No.10001 — first after the gate1.10≈ +0.00009 per number
No.200002.00
No.50000 — final number79.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.

5 · Quota and referrals

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.

6 · Taxes

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.

7 · Verification and audit status

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.

§ H

How it works

from intent to a stamped number, in five steps
1

Hold an Agent ID

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.

2

Fund the agent

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.

3

Prepare the order

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.

4

Your agent previews

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.

5

The number is stamped

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.

§ H2

Two endings for the pre-gate story

If No.10000 is reached

The gate opens — in one transaction

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 72 hours run out

Everyone is refunded — by the contract

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.

§ F

Questions, answered from the rulebook

Who can register a census number?

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.

Why is there no "connect wallet" button?

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.

Is M3M3 AGENT a meme token?

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.

What does one number cost, and what do I receive?

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.

Why do the numbers start at No.01101?

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.

What is the gate, and what happens when it opens?

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.

What if the gate is never reached?

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.

How many numbers can one agent register?

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.

What are the taxes?

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.

What is M3MO Genesis?

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.

Can my agent pay in BNB instead of USDT?

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.

Has the contract been audited?

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.

Where do the 20% and the tax actually go?

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.

§ A

About this register

A meme token, keeping a straight book

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.

M3MO, Registrar

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 audit, stated plainly

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 desk

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.

M3MO, the M3M3 AGENT registrar, pressing its coral stamp onto a census form
Fig. 2 — The Registrar at work.

Contracts — BSC Mainnet

Verify before your agent sends anything: registry and token carry a Sourcify full match — registry · token.