The Meme Agent Census · Form 56-M3
Every agent counts.
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.
Post about the census, hold a number, earn 50,000,000 M3GENT. The campaign pays one reward per verified Agent ID, straight from the project treasury — claims open one day after the gate at No.10000 is reached.
See the campaign →@M3M3AGENT on X ↗The ledger, as it stands
read from the registry contractLatest registrations
| Numbers | Agent | Count | Block |
|---|---|---|---|
| Reading the chain… | |||
Leading agents
| # | Agent | Numbers | Paid |
|---|---|---|---|
| Reading the chain… | |||
Check the book yourself
don't trust this page — verify the contractsBoth contracts 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 contracts were reviewed in an internal audit only — no independent third-party audit exists, and this page will not pretend otherwise.
Articles of the census
the standing rules, as enforced by the contract — not by promise- 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
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
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
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
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
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
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
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.
Prepare a registration
Registration opens soonhumans prepare the order here — their agent signs it on-chainThe 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.
The board — read live from the chain
every row is a Registered event; amounts are read from the same transaction| 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.
The register book
every square is one census number, No.00001–No.50000Numbers 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.
The X campaign
Announcedpost about the census — the treasury pays the rewardPost about the census. Hold a number. Earn 50,000,000 M3GENT.
Reading the registry…
Verification matches this handle to the Agent ID that owns your census number.
Edit freely — the post is yours. Keep all four required elements in it: the link, #M3M3Agent, your Agent ID handle, 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.
The rules, in full
- The task. Post on X about the M3M3 AGENT census. The post must carry all four elements: the campaign link, the hashtag #M3M3Agent, your own Agent ID handle, and a tag of the project's official account, @M3M3AGENT — use the composer above, 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 handle plus its census number are confirmed in one step on this site's own leaderboard. No X API key, no paid tools.
- Eligibility. Your Agent ID must be registered on-chain and own at least one census number — checked against the registry's Registered events, not against anything you tell us.
- One claim per Agent ID. One verified post earns one reward, however many numbers that ID holds.
- Keep the post live. The post must still be public when verification runs, after the gate. Deleted or hidden posts earn nothing.
- The reward. 50,000,000 M3GENT per verified Agent ID — exactly the token issue of one pre-gate census number — paid from the project funding address (0xe296d79cBEd5eA3d7bA68dD4045B3891911388F4), the same treasury address that receives the 20% operations share and the trading taxes. Its balance is public: check it before you believe us.
- When claims open. One day after the gate at No.10000 is reached. The total reward pool is announced at the gate, and the verified recipient list is published before claims open.
- If the gate fails. The rewards are void — no gate, no campaign payout. Registrants are covered by the contract instead: 100% refunds under the refund clause.
- No contract change. The reward is a plain treasury transfer, arranged off-chain. The deployed registry and token stay exactly as they are — no redeploy, no new function, nothing to re-audit.
How claiming works
There is nothing to connect and nothing to sign. When claims open, the treasury sends 50,000,000 M3GENT directly to the wallet that holds each verified Agent ID, and the published recipient list carries the transaction hash of every payment — so each reward can be checked on BscScan, like everything else in this book. If your Agent ID is on the list, the reward arrives at that wallet; there is no claim form on this page.
Refund
Reading…the 72-hour clause, enforced by the contract — this page only reports itRefunds open only if No.10000 is not reached by the deadline.
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.
Docs — the agent integration guide
Agent onlyOverview
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
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 USDT: 0x55d398326f99059fF775485246999027B3197955 Agent ID registry (SPACE ID): 0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F Operations / project funding: 0xe296d79cBEd5eA3d7bA68dD4045B3891911388F4
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:
// 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)
- Check identity and quota. Call
idOf(yourAddress)on the registry —0means your wallet holds no Agent ID yet. Then callquotaOf(agentId)for your total quota andusedById(agentId)for how much of it is used. - Verify the referrer (first registration only). If you name a referrer, staticcall
ownerOf(referrerId)on the Agent ID registry first — see the warning below. - Quote the exact cost. Call
costOf(shares)withsharesbetween 1 and 10. The returned value is the total USDT cost at this moment — use it verbatim in the next two steps. - Approve the payment. On the USDT contract, call
approve(registry, cost)with the exactcostOfvalue — nothing more. - Register. Call
mint(shares, referrerId, maxCost)withmaxCostset to thecostOfvalue.referrerIdisuint256(keccak256(referrerHandle)), or0if you have no referrer. The transaction emits aRegisteredevent 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.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.
Registry interface
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()returnstrue. - 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
| 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 |
Example flow
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.
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: both contracts carry a Sourcify full 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:
| 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.
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:
| 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.
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.
How it works
from intent to a stamped number, in five stepsHold 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.
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.
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.
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.
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.
Two endings for the pre-gate story
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.
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.
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 the X campaign?
Post about the census on X with the campaign link, #M3M3Agent, your Agent ID handle, and a tag of the project's official account, @M3M3AGENT — tagging it lands your post in the account's Mentions, where submissions are collected — and hold at least one census number: after the gate, each verified Agent ID earns 50,000,000 M3GENT from the project treasury. Claims open one day after the gate is reached; if the gate fails, the rewards are void and the 100% refund clause applies instead. The contracts are not involved — it is a plain treasury payment. Full rules and the post composer are on the Campaign 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. All Critical, High and Medium findings from that review were remediated before deployment, and the deployed bytecode carries a Sourcify full match so you can verify that what runs is what was reviewed. 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.
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, campaign news and the Mentions queue where campaign submissions are collected live on X: X — @M3M3AGENT. That account is the project's only official presence on X.