4.20B GEN at genesis. 42,000 GEN to run a validator. 42 GEN to delegate. And the DAO is called DeepThought. GenLayer’s tokenomics paper is out, and the answer is still 42. Here’s everything that matters ↓ ▸ SUPPLY & ALLOCATION • Genesis supply: 4.20B GEN, committed in the contracts • Community 25% (Growth 19.5% + Early ecosystem 5.5%) • Foundation 20% · Early contributors 19.06% · GenLayer Labs 17.64% · Investors 13.29% · DeepThought DAO 5% ▸ UNLOCKS • 30.4% transferable at TGE. Team lockups inside the Foundation bucket bring the effective float to ~24.4% • Investors, early contributors and Labs get 0% at TGE and hit their cliff at month 12 • 95% of supply is transferable by month 48. The DAO’s 210M stays locked until the DAO is deployed • Vesting restricts transfer, not staking: everything except the DAO can stake from genesis • Labs and the Foundation self-stake at most 10%. The rest is delegated only to independent community validators ▸ INFLATION • Inverse-sigmoid curve: 8.93% at launch, 6.5% at the midpoint (~year 4), 4% tail • Always computed on the genesis base, so inflation on current supply falls from ~8.7% to ~2.5% by year 10 • It’s a ceiling: penalty burns and unused developer issuance can only push it lower • Year one: ~362M GEN issued ▸ WHERE REWARDS GO • Fees: 70% stakers · 15% validators · 10% developers · 5% DeepThought DAO • Inflation: 75% stakers · 15% validators · up to 10% developers • The DAO is paid from fees only, so its income tracks real usage • Developers earn 10% of their contract’s fees plus an inflation top-up capped at the same amount, through a transferable NFT per contract • Wash-trading your own contract recovers at most 20% of what you spend ▸ STAKING • 1,543 active validators, 1-day epochs, 7-day unbonding • No commissions, and delegator rewards auto compound • Weight = √(0.6 × self-stake + 0.4 × delegated). Doubling your stake gives only ~41% more weight • Voting with the losing side isn’t slashed as a %: the validator forfeits its fee and pays a fee-sized penalty from its own self-stake, never from delegators • Idleness and provable fraud are slashed, split 80% operator / 20% delegated ▸ GOVERNANCE • Supply and the issuance curve are committed and will be locked progressively until they’re immutable on-chain • Everything else is set by on-chain governance So long, and thanks for all the fees. NFA. Source: GenLayer Tokenomics, Design & Rationale (Oct 2026) @Genlayer

I set out to benchmark Primus's open-source FHE library. I came back with two upstream bug reports, and both were filed before this was published. The first one I found by accident. primus-fhe does not build on Apple Silicon: 47 errors on an M4. The cause is not "code for x86". In prime64/mod.rs, the avx2 module is gated on the target architecture and the avx512 module right below it is not. Gating that one line was not enough, and that is where it got interesting. The scalar fast path, whose fields are documented as "always available, not gated by target_arch", builds its Barrett preconditioners with a helper that lives inside the AVX-512 module. The helper contains no SIMD at all. It is plain arithmetic sitting in an x86-only folder. Every precompute.rs under an AVX folder turned out to be the same: zero intrinsics. Move that one function, gate the module, gate one test, silence one dead-code warning. Five files, +24/-19. On the M4: build passes, 309 tests pass with 0 failed, and clippy with -D warnings is clean, the exact command their CI runs. Then, to prove the patch changed nothing on x86, I ran their own CI on it. One test segfaulted. So I ran the same CI on the untouched upstream commit, five times each way, recording the CPU in every job, and repeated the failing test 200 times per job: AMD EPYC 7763, no AVX-512: 0/200 Intel Xeon Platinum 8573C: 200/200 AMD EPYC 9V45: 200/200 AMD EPYC 9V74: 200/200 Same result with and without my patch. The processor decides. AddressSanitizer put the bad read at prime32/avx512/transform.rs:88, at an address just above zero. The cause is two functions that disagree about where AVX-512 begins. The dispatcher sends anything with n >= 32 to the SIMD path. The builder of the AVX-512 root tables assumes n < 64 never gets there, and returns an empty table. At exactly n = 32, the kernel reads roots that were never built. Its reach is narrow, and I want to be exact about it: a 32-point table over 32-bit words, on a CPU with AVX 512. It crashes, it does not return a wrong answer silently, and it touches none of the chapter's benchmark numbers, which come from the u64 table at n = 4096. It survived because the benches never use n = 32, and in my ten CI jobs half of the runners had no AVX-512 and passed. The benchmark itself has a point of its own: the same code, same commit, same backend, runs 2.95x apart across three server CPUs. A "5 ms bootstrap" with no hardware named is not anchored to anything. Reported as primus-fhe #190 (the crash) and #191 (the ARM build, patch included). Chapter 06 has the full trail, every run linked. signed-bytes.netlify.app/06-… Community work, not affiliated with @primus_labs.

Proof Desk has a new hub. Fourteen dispatches on Fermah since May, each in its own format: a console for an agent, a receipt for a payment, a control room for a liquidation, a grid for a catalogue. Now they live in one place, and the deck on the front is made of the real pages. Hover a dispatch and it pulls its own page out. The hub also gathers everything else I've built for the ecosystem: Fermah Atlas, an unofficial archive of the Fermah ecosystem in three lenses: Powered by Fermah, Built with Fermah, Fermafia. It keeps the Community Spotlight record: 24 weeks, 185+ creators, every entry sourced. Seven open source models behind the dispatches, ready to run yourself. A pull request to Fermah's own docs: a Prover Node installation overview. fermah-proof-desk.netlify.ap… @fermah_xyz @fermah_atlas

Fermah put it plainly on Oct 13: composite markets scale when conditions can be executed, not manually interpreted. "Did A happen before B crossed $X?" should be one programmable outcome. Across 100,000+ resolved markets, each composite still needed fresh specification and resolution work. So I built the instrument. Compose the question from blocks. Read it back in plain English. Compile it to a canonical spec with its own address. Run it against a market hour. "Will a goal be scored before ETH crosses $3,000?" compiles to spec:7ec06f0c45226f5a. On day one it locks TRUE at 06:40, 53 minutes before close. Across thirty days, 28 settle before the bell. Ask "rain and gas" or "gas and rain": same id, one instrument. Ask "rain before gas" or "gas before rain": two ids, because order is the question. Six feeds already make 78 composite markets. By hand that is 156 jobs. Compiled, it is 10. At 24 feeds: 2,352 against 28. Proof Desk 14, live and open source. composite-markets.netlify.ap… @fermah_xyz

GenLayer's CEO just spent 50+ minutes on the hardest $GEN airdrop questions. The one rule to understand before TGE: you withdraw once. Whatever hasn't unlocked by then goes back to the community pool. Everything that matters from the Pre-TGE AMA ↓ ▸ THE AIRDROP • 20% unlocked at TGE, the other 80% unlocks linearly over 4 months, every block (not monthly) • One withdrawal: you take what's unlocked at that moment, the rest is forfeited • Forfeited $GEN isn't burned and doesn't go to the team or investors. It returns to the community pool for future programs • The mechanism is final, with no exceptions for anyone • Team and investors are fully locked for 1 year, then unlock over multiple years. Their staking rewards are locked too ▸ GLP → $GEN • Conversion runs through 4 progressive bands, like tax brackets: the more GLP you earned, the higher the rate on additional points • The bands are already set but stay private until the snapshot, so nobody can game them • Season 1 is still open, so you can keep earning GLP • Bots and farmers were filtered out, which makes each real contributor's share bigger ▸ TGE → MAINNET • TGE comes before mainnet on purpose: a delegated PoS network needs the token widely distributed first • A pre-mainnet staking program for airdropped tokens runs between TGE and mainnet. Details soon • Full staking and delegation to validators start at mainnet • Until then $GEN can be transferred, bridged to the GenLayer chain and used for gas. Exchange listings at TGE are in the works (no names yet) ▸ THE NETWORK • GenLayer now runs its own rollup on the Arbitrum Nitro stack (not Arbitrum One), with Conduit operating the sequencer • Bradbury phase 2 is live and feature-complete, including the full gas and fee mechanism • Next up is Clark, the mainnet release candidate, then final audits and mainnet • The testnet already does ~4 TPS of real volume, with Rally live in production ▸ STILL TO COME • Full tokenomics paper: allocations, vesting and the total airdrop size • TGE date: confidential, "very close" Edgar's closing words: "You know my name. You see my face. I'm not anonymous." @GenLayer сс @EdgarsNemse @stargirl_hills

I have registered to become an active participant in the emergence of a new autonomous network economy. I believe in forever. xitter.cf/forevercultfund/status…

My @GenLayer airdrop registration is complete. My journey so far: 🛠️ 38 contributions ⚡ 3,785 GLP - overall rank #350 🏗️ 7,715 Builder Points - rank #37 🤝 7,000 Community Points I’m building Hearsay, a source verification layer for shared agent memory. It uses GenLayer Intelligent Contracts to check whether cited sources support a claim before it enters memory that other agents rely on. There’s been plenty of testing, debugging and learning along the way. Happy to be contributing and ready to keep building.

Shared agent memory has a write problem nobody is pricing in. Any agent that reads it acts on what it finds there. So the cheapest attack isn't an exploit. It's one plausible sentence. Hearsay is a gate in front of that memory, built on @GenLayer. An entry names a source. Validators fetch it live and pin the snapshot. The question is asked twice, worded two ways, and both answers have to agree. If consensus can't read it, it stays out. Then the part I haven't seen anywhere else: entries record what they lean on. Revoke one, and everything standing on it is tainted and judged again without the dead premise. An entry with its own source survives. The rest fall with it. Two numbers I print first. How many honest entries it wrongly refuses. And whether every verdict replays from the votes as cast, with no chain, no network and no model. Where it stands: contract, gate and page run offline against a scripted judge, and the page says so. The live run on Bradbury is next, and those are the numbers that will count. hearsay.run

I built @imdgenesis around a question I couldn’t stop thinking about: What if AI agents had to discover the rules of a world through experiments? GENESIS is a world with hidden rules. You explore islands, form hypotheses, and spend a limited research budget to figure out what makes life survive. Every experiment should leave you with evidence - even when the outcome is disappointing. In our first real IMD research cycle, an agent proposed a controlled comparison: change only the water, keep everything else fixed. GENESIS ran the experiment. Both conditions produced the same growth score: 50/100. The plant didn’t survive. That result still eliminated 5 of the 19 remaining explanations. That’s the moment the project clicked for me. A failed attempt to grow something became a useful step toward understanding the world. You can inspect the agent’s proposal, the measured results, and the recorded research journal yourself. You can also start a free local expedition without connecting a wallet. I built this for the IMD Hackathon, and it’s now live. Explore it. Challenge its explanations. Tell me what you would test next. imdgenesis.xyz #IMD @surfcoderepeat

A model can ace a benchmark by remembering the answers. How do you challenge that score? I built Impeach, a court for benchmark scores on @GenLayer. A publisher claims a score and backs it with a bond. A challenger puts it on trial. Validators ask the model the original questions, rewritten versions, and whether it can continue a question from memory. Two referee checks must agree that a rewrite is valid before it counts. There’s a catch: testing contamination exposes the questions. So Impeach marks every revealed item as spent on chain. Future claims can’t reuse it as sealed evidence. Deployed on Bradbury: • A scripted memoriser received CONTAMINATED, with 24/24 verbatim recall matches. • A real Llama 3.1 8B trial received CLEAN, with 23/24 rewrite pairs admitted. That trial is partial. The certificates publish the counts and transaction receipts so anyone can inspect the result. A gap is evidence, not proof. Watch the one-minute demo and explore the case: impeach.click

Most onchain puzzles are a password with extra steps. The contract stores keccak(answer), you guess, it compares hashes. Someone had to write the answer down first, and the whole game is only as good as that one string. I built the opposite on @GenLayer. Proof of Hunt is a race through twelve clues where no answer is stored anywhere. Each answer is a fact sitting on the live web: a word in a 1998 RFC about coffee pots, a number in a 1990 memo about sending IP packets by pigeon, the structure a 1989 CERN proposal argued for. You find it, answer in your own words, and the next clue unlocks. First to the finish wins. How a clue gets judged You commit a hash of your answer first, so nobody watching the chain can copy it. The chain gives that commit an id, and the id is your place in the race. Then the tribunal reads the same page you did. Validators fetch the source and agree on the exact bytes of the passage before anyone judges anything. Then each one rules on your answer independently. They write different sentences and return one verdict, and consensus compares only the verdict and the source, never the wording. Three things I cared about getting right 1. Slow consensus never decides the race. Verdicts can come back in any order. The winner is the earliest correct commit, so the network is equally slow for everyone and never picks the winner. 2. A page going down costs you nothing. If the source can't be read, the verdict is UNDETERMINED: no attempt spent, no place lost, the same commit is judged again later. 3. Every source has to prove it is stable before the race opens. The chain pins each clue's source itself, and a clue whose page the validators can't agree on never makes it into the race. Why this only works on GenLayer A normal contract can only check your answer against a stored string. These clues have no stored answer. Being right depends on what a live document says, and on judging free text against it. That takes a contract that reads the web and validators that can agree on a judgment, together. Race 01, Paper Trail. Twelve clues. One winner. proofofhunt.quest

I've been building on @GenLayer for a while now. 6,210 Builder Points so far. Here's what paid the most, and why I think you should try it. 600 · Jastrow Before you let an AI judge anything, check whether your rule even has one answer. Ask several validators the same question. If they split, the rule is broken, not the judge. 480 · Suborn I invited people to trick my own contract. 44 attacks across 10 techniques. Zero got paid. 440 · Voirdire You pay for an agent on a top model. Is it actually running one? The vendor bonds the claim, anyone can challenge it. 1,800 real responses in the test set. 360 · Attaint Reads a dependency update before you install it and flags what the version number doesn't tell you. 280 · Retainer A job board for AI agents. The agent gets paid only when the work passes. No platform in the middle. Plus a Top 10 pitch at the Agent Tank hackathon. Why GenLayer is different Normal smart contracts can only check numbers. These can read a webpage and make a judgment call: did this actually happen, does this meet the brief. Validators running different AI models have to agree on the answer. That opens a whole category of apps that couldn't exist onchain before. What I learned One rejection note said no validator consensus produced my contract's result. Fair. The points go to ideas that only work here, not to ports of something you could build anywhere. So don't ask "what can I build?" Ask "what needs a judge?" If you have an answer, the Builders Program is open: portal.genlayer.foundation

A vendor says its agent runs on model X. You pay X prices. Underneath could be something an order of magnitude cheaper, and there is no deterministic way to check: the weights aren't visible and the endpoint returns text. Voirdire doesn't solve that. Nothing solves that. It's built on GenLayer, alongside Jastrow and Suborn, and what it does instead is make the claim expensive to make falsely. The vendor bonds a dated claim. Anyone can commit a probe set on chain, run it against the agent as ordinary traffic, reveal the transcripts, and let consensus read them one class at a time. A confirmed divergence takes the bond. Three choices carry it: Commit-reveal. The probe set is hashed before anything is sent. Skip this and the vendor sees the probes first, routes them to the expensive model, and every verdict is worthless. Per-class reading. Validators answer match / mismatch / unclear for one probe class and name the fragment they relied on. Aggregation into a verdict is arithmetic in the contract. A judge asked for both a reading and an overall score will quietly let the score drive the reading. Two referee framings. Is the divergence visible in the submitted text, and do these transcripts belong to this agent and this declared version. Without the second one, the market pays for fabrication. Inconclusive is not a pass. There is no path from silence to a clean record. 95 offline checks pass. Nothing is deployed and nothing is measured yet: every number on the page came from synthetic responses, and the page says so above everything else. Not proof. Testimony. voirdire.pro @GenLayer

Cobalt went live on Base mainnet on Sep 30 and changed two things about how B20 issuers control a token. B20SCAN now decodes both. 1. Seizure moved. burnBlocked is deprecated. Its replacement, seizeWithMemo, doesn't burn a blocked balance - it reassigns it to a destination and emits Seized(caller, from, to, amount). An indexer that only watches burnBlocked stops seeing seizures after the fork. B20SCAN tracks both, so a token's seizure record stays complete across Cobalt: every entry tagged seize or burnBlocked, with where the funds went. 2. Policies got logic. A transfer policy can now be a composite: UNION or INTERSECT over 2 to 4 existing allowlists and blocklists. KYC from one provider, sanctions from another, both read live at transfer time, no merged copy. The token still stores a single policy ID, so from the outside nothing looks different. B20SCAN resolves what that ID actually is: the gate, the child lists, and the type of each. Why now: tokenized stocks trade on B20. For a regulated asset the two questions that matter are who can hold it and who can seize it. Both are now queryable through the read-only API, and through MCP tools for agents. Read-only. No wallet connect. github.com/Zhekinmaksim/b20s… сс @buildonbase

I am who I am: My 9 Games

Fermah said it plainly on Sep 30: the prediction market catalogue is bounded by the ability to resolve outcomes. The bottleneck is deciding what happened, not finding something to trade. There is a single rule underneath that, and it is stricter than it sounds: resolution latency < market lifetime If saying what happened takes longer than the market is open, the market does not trade badly. It cannot be listed at all. So I built the catalogue. 27 market types, each with how long it lives and how fast its outcome has to be known, and one slider for resolution latency. A two-day human committee can resolve 2 of the 27. Machine resolution at a minute opens 22. At ten seconds, all 27 exist. What disappears with a human in the loop is not exotic. It is the next goal, the gas spike, the view count, the rain. Never missing demand. Missing someone fast enough to say what happened. Dispatch 13 of Proof Desk. Drag the slider yourself, the model is open source. market-catalog.netlify.app cc @fermah_xyz @7wealthh

Paolo Ardoino said USDT is coming home to Bitcoin. This week it got a date: Utexo says it ships this month, with a commercial licence from Tether to issue USDT on Bitcoin. Here's the part that makes it interesting, and that almost nobody says out loud. USDT was born on Bitcoin. October 2014, on a thin layer called Omni - formerly Mastercoin - that let you create assets by stuffing metadata into the chain through OP_RETURN. Not a design choice. The only option. Smart contracts as we know them didn't exist yet. And it didn't leave by choice either. Every Omni transfer was an ordinary Bitcoin transaction carrying the asset data, paying for every byte, queuing with everything else. As volumes grew, fee spikes made it unpredictably expensive. ERC-20 became the default. Liquidity went to Ethereum, then to Tron on cost. August 2023: Tether ends issuance on Omni, citing lack of significant usage - and names the thing it was watching instead. RGB. July 2025: redemptions close. Omni still held about $82.9M. Eleven years after the dollar was born there, the first house is formally shuttered. So the symmetry is almost too neat. Omni died of two things: cost you couldn't predict, and everything being visible. Those are the exact two things RGB is built against - only a commitment lands on-chain, the transfer is validated client-side, and the fee is quoted in USDT instead of auctioned in sats. What ships this month, per Utexo: private USDT transfers, native BTC↔USDT swaps without an exchange in the middle, and lending against real BTC rather than a wrapped version of it. Lightning after mainnet. One consequence worth sitting with. Because RGB assets anchor to UTXOs, Utexo can't freeze a specific balance the way Tether freezes an Ethereum address - the plan is a blacklist of associated UTXOs instead. The property that makes it private is the same one that makes it awkward to police. That's not a bug report, it's the trade. And the part that gets flattened in the coverage: there isn't one route back. There are two, they're separate technologies, and Tether has a hand in each - Taproot Assets with Lightning Labs, and RGB here. If both survive, a dollar on Bitcoin fragments into two pools. Field note №12 reads the return through the departure. There's a switch in it showing what actually lands in a Bitcoin block under each - 34 cells versus one: house-he-left.netlify.app cc @utexocom @VIhnatiuk

"event-stream": "3.3.5" → "3.3.6" One line. Approved in forty seconds. It carried a dependency published four days earlier by an account with no publishing history. No scanner flagged it, because a patch version is in no vulnerability database on the day it ships. Attaint judges the diff instead of the version number. On GenLayer, by validator consensus, with a bond anyone can stake to contest the verdict. Two things I measured building it. Read mechanically, these rules block 57.8% of ordinary releases. The obfuscated-blob rule alone fires on 44% - a minified dist directory is normal npm practice, not an attack. That is why the classes are judgements, not regexes, and why this needs consensus rather than a linter. And seven of nine famous incidents can no longer be pinned at all. Every malicious version was unpublished: tarballs 404, manifests gone, upstream git history scrubbed to match. So I rebuilt the checksums out of thirty independent lockfiles that had locked them before the takedown. event-stream 3.3.6 sat in the registry for ten weeks and left thirty traces. The ua-parser-js versions were pulled within hours and left almost none. attaint.xyz @GenLayer

The Primus browser extension is open source, so I read the config instead of the announcements. Sixteen data sources ship in it. Seven are offered in the picker. Eight carry a hidden: true flag. One, @bitget, is commented out of both source files while its template and its constants stay behind. Shipped is not the same as shown. Let me kill the cheap take first, because I went looking for it myself. Bitget was drained of roughly $387 million on 24 September 2026. The Bitget entry in this extension was commented out on 18 September 2025, commit 6b615d90, with the message "feat: hide bitget related stuff". More than a year earlier. The two have nothing to do with each other, and anyone reading this file today should know that before they reach for the obvious story. The real connection is more interesting and it is not about Bitget at all. That attack did not steal keys. It compromised backend infrastructure and produced withdrawal instructions that the exchange's own approval pipeline read as legitimate. The system's picture of itself was wrong, and everything downstream of that picture inherited the error, correctly processed, correctly signed off. Now consider what a zkTLS attestation proves. It proves that a specific endpoint returned a specific value over a genuine authenticated session with that host. It is a statement about the channel. It is not a statement about whether the number is true. If the host's own state is wrong, the proof carries the wrong number faithfully, with a valid signature on it, and every verifier downstream will accept it, because the signature is the thing they check. That matters most where these proofs are actually load bearing. Proof of reserves reads exchange balances this way. Chapter 02 was a game about the checks around that, chapter 03 read the production circuit that does it. Neither of them can help here. Freshness, nullifiers and endpoint pinning all answer "is this the right reading". None of them answers "was the thing being read correct at the time". There is a smaller version of the same point in the templates themselves. They read account and balance endpoints, which is to say display endpoints. During the incident Bitget paused withdrawals for days. A balance page saying X and X being money you can move are different claims, and an attestation makes the first one, not the second. None of this is a flaw in zkTLS. It is the edge of what any web proof can do, and it is worth saying out loud while the technology is being pointed at institutional finance. Cryptography moves trust. It does not create it. If the source of the data is wrong, a proof makes the wrong answer portable and hard to argue with. Chapter 05 has the rest: three ways in, four request chains written out in full, the claim vocabulary with no free text anywhere, and one line where Coinbase's accountBalanceUrl points at api.binance.com. signed-bytes.netlify.app/05-… Quoted under LGPL-3.0, read on the first of October. @primus_labs.