🫎 MUHOMOR. base.eth

mushroom 🍄 fairy

[🫎 MUHOMOR. base.eth @muhomoreth]

Which Client Does the Stack Under Your OpenClaw Serve First?

There is one seat left on the flight. One block of compute at the good rate. One quote before the price moves.
Two agents ask for it in the same millisecond.
Somebody decides who gets it. That somebody is not the market, and it is not physics. It is a rule that a person wrote, in a config you have probably never seen.
Why OpenClaw makes this question interesting rather than obvious
The reason I want to start with OpenClaw specifically is that it is the case where the usual answer does not apply.
OpenClaw is local-first. You install the runtime, it lives on your machine or your own server, it connects to your messaging apps and your tools, and it runs continuously under your control. That is the whole pitch, and it is a good one. When the agent is yours and the machine is yours, nobody is sitting between you and the world quietly deciding whose request goes first.
So the honest version of this piece does not start with “your agent platform is against you.” Self-hosting genuinely removes that conflict at the runtime layer.
Then you look at everything the runtime touches, and the conflict walks back in through a side door.
You own the agent. You do not own the path.
Your agent is local. Almost nothing else in the chain is.
There is now a market in hosted and managed OpenClaw, on cloud marketplaces and specialist providers, because running your own thing 24/7 is a chore and somebody will happily run it for you. The moment you take that offer, you are back to being one tenant among many on somebody else’s box, with somebody else’s scheduler deciding the order of operations.
Below that sit the shared tool servers. Your agent calls out to something for a quote, a booking, a lookup. That MCP server is serving other agents too. It sees a stream of requests and it answers them in some order, and that order is a choice.
Below that sit brokers and solvers, whose entire job is to receive intents from many parties and decide how to fill them. Ordering is not a side effect of what they do. Ordering is what they do.
And at the bottom sits the supplier itself, the one with the last seat, who has always had commercial reasons to prefer some channels over others.
Four layers. You self-hosted one of them.
Allocation is a policy, not an accident
Here is the part that I think gets skipped, because it sounds too simple to matter.
When two requests arrive close enough together that the difference is meaningless, the tie has to be broken by something. First in wins. Highest tier wins. Highest fee wins. Random. Round robin. Longest waiting. Whatever the code happens to do when nobody thought about it.
Every one of those is a policy with winners and losers, and almost none of them are published anywhere you can read.
This is not a new idea. It is just newly invisible. Airlines and hotels have always given some booking channels better inventory. Exchanges have explicit, regulated, written-down rules about order priority, precisely because everyone learned the hard way that ordering is where the money hides. Cloud providers sell priority capacity openly, and nobody minds, because it says so on the price list.
The agent stack has the same economics and, so far, almost none of the disclosure.
The sharpest version of the conflict
The uncomfortable case is not a provider being greedy. It is a provider having customers of its own.
Imagine any operator sitting in the middle of a lot of demand. It runs infrastructure for many clients. It also has its own agents, or a premium tier, or a partner it has revenue share with. When a scarce thing appears, it is holding information about that scarcity before anyone downstream, and it has a legitimate business reason to prefer somebody.
That structure exists all over finance and nobody thinks it is exotic. It is why order-flow arrangements are disclosed and argued about. It is why the phrase self-preferencing shows up in cases about platforms favouring their own products. The agent world has rebuilt the same structure, at machine speed, with fewer rules and less paperwork.
I want to be careful here, because this is a structural observation and not an accusation about any particular product. The point is that the incentive exists by default, in any design where one party sees many requests. If nobody writes down the ordering rule, you should not conclude that it is fair. You should conclude that you do not know it.
Why you will probably never notice
The failure mode is not an error message. It is a slightly worse outcome, delivered politely.
You get the second-best quote. The booking comes back as just gone. Your job waits eleven seconds instead of two. Every one of those is completely consistent with bad luck, and bad luck is real, and that is exactly why this is hard.
A human trader develops a nose for being consistently a step behind. Your agent has no nose. It gets an answer, it takes the answer, and it logs a success. Nothing in an ordinary agent loop asks the question a suspicious professional asks by reflex, which is not “did this work” but “did this work as well as it should have.”
That is the actual gap. Not fraud. Measurement.
What to ask for, and what to measure yourself
Two things worth demanding from anyone who sits between your agent and a scarce thing.
A written allocation rule. Not a promise of fairness. A description of the mechanism. What breaks a tie. Whether tiers exist and what they buy. Whether the operator or its affiliates compete for the same inventory through the same pipe. A provider that will not describe its ordering has told you something.
Quotes that bind. A price should arrive signed, tied to your specific request, valid once, and expiring in seconds. A number that is not bound to anything is not an offer. It is an opinion, and opinions can be revised after they learn what you wanted.
Then stop trusting and start measuring, because this is one of the rare problems where you can just check.
Run a control. Send the same request through two paths, or the same path from two accounts on different tiers, and compare what comes back. Not once. Continuously, in the background, as a permanent part of your setup. Log every quote you were given next to the price that was actually available at that moment, and watch the distribution rather than any single trade. Track how often you win contested things and whether that rate changes with your spend. Watch latency by request type: if your cheap requests are consistently slower than your expensive ones, that is a rule, not weather.
None of that requires anyone’s cooperation, and one weekend of building it will tell you more than any policy page.
Beyond that, the structural defenses are the boring ones. Self-host the parts that are cheap to self-host, because every layer you own is a layer that cannot reorder you. Use more than one supplier for anything scarce, so you have a baseline to compare against. And reveal as little as you can when you ask, because a request that announces its size and deadline has told the counterparty exactly how valuable it is to serve you last.
The fair objection
Priority tiers are not wrong. Paying for speed is a legitimate product, and I would rather live in a world where an operator sells fast lanes openly than one where everyone pretends capacity is infinite. Airlines sell priority boarding. Cloud providers sell reserved capacity. Nobody is scandalized, because the deal is on the price list.
The problem is not tiering. It is undisclosed tiering, and self-preferencing dressed as neutrality.
If a provider says “we fill in order of fee, here is the schedule,” you can decide whether to pay, route around it, or accept it. That is a market. If a provider says “we treat everyone the same” while quietly holding scarce inventory for its own book, that is something else, and the only reason it survives is that agents do not complain and nobody is checking.
The line worth keeping
Your agent is loyal to you. That was never the question.
The question is whether everything it has to ask permission from is loyal to somebody else at the same moment, and whether you would be able to tell.
Self-hosting the runtime is real progress, and it is worth doing. It just moves the conflict one layer down rather than removing it. Own what you can, get the ordering rule in writing, and instrument the rest yourself.
Because the opportunity your agent never saw does not show up in any log you own.
#openclaw #agents #arc @arc

[🫎 MUHOMOR. base.eth @muhomoreth]

@Arc_Punks 0xF64C8bFB15053E4672BA2272EC9b06AC8AF56050

[🫎 MUHOMOR. base.eth @muhomoreth]

@0xBobdbldr 0xF64C8bFB15053E4672BA2272EC9b06AC8AF56050

[🫎 MUHOMOR. base.eth @muhomoreth]

A Chain Built to Replace Human Labour, Has 54,000 People Doing Homework for It https://t.co/RPreWXK8Ql

[🫎 MUHOMOR. base.eth @muhomoreth]

@risextrade I want there to be marks in the open positions, that is, it is written short or long, now it’s not there, it’s very annoying

[🫎 MUHOMOR. base.eth @muhomoreth]

@fermah_xyz Gm Fermah

[Cashmere Labs @CashmereLabs]

Goat Street NFT GTD/WL form is now live.

48 hrs for applications.

Supply: 6666

Chain: @RobinhoodApp

MP: Free Mint

Form:
https://t.co/68UWjXzQSG

[🫎 MUHOMOR. base.eth @muhomoreth]

@CashmereLabs @RobinhoodApp 0xF64C8bFB15053E4672BA2272EC9b06AC8AF56050

[🫎 MUHOMOR. base.eth @muhomoreth]

Native EURC Markets for Macro Events — Live on Arc Testnet
Every prediction market asks you the same thing before you bet: do you want to do this in dollars?
Doesn’t matter that the event is an ECB rate decision. Doesn’t matter that you live in Madrid, get paid in euros, and your whole economic life is denominated in something that isn’t the dollar. Polymarket, Kalshi, all of them: dollars only.
So a European trader who wants a view on European monetary policy has to eat currency risk they never asked for — just to have an opinion about their own central bank.
I got annoyed enough to build the alternative. It’s called MacroArc. It runs on Arc. It’s live at https://t.co/wHVa666hYo.
What it actually is
Markets on the macro calendar: Fed and ECB decisions, CPI prints, euro-area HICP, EUR/USD levels.
The part that isn’t standard is that each market settles in the currency its outcome actually belongs to. Fed market settles in USDC. ECB market settles in EURC. Not wrapped. Not swapped at the end. Native.
Why hasn’t anyone done this?
Because until recently you couldn’t.
On a normal L1 you’d need a volatile gas token, plus your settlement stablecoin, plus a second stablecoin, plus a bridge between them. Every builder makes the same rational call: pick one asset, make it USD, move on. “Prediction markets are dollar-denominated” started to feel like a law of nature instead of a workaround.
Arc breaks that.
USDC is the native gas token. EURC sits next to it as a first-class asset. Fees are predictable and dollar-denominated, so a $5 position stays economic. A euro-native user holds EURC, bets in EURC, gets paid in EURC, and never touches a token they don’t want.
The design choices
The market is parimutuel. Stake YES or NO. Winners split the losing pool pro rata. 1% fee. No order book, no market maker, no cold-start problem where the first user stares at an empty book and leaves.
The part I find most interesting: every market’s implied probability is exposed onchain. Not in a frontend. Not behind an API key. A lending protocol pricing rate risk can read it. An agent hedging FX can read it. The market becomes public infrastructure, not a private feed.
Built for machines from day one
Circle keeps saying the next wave is agentic economic activity. Most projects nod along and ship a website.
MacroArc shipped three ways for a machine to trade it on day one:

a JS/TS SDK
a JSON HTTP API
an MCP tool server

That last one means an AI agent can connect MacroArc as a native tool and trade macro markets with its own wallet. get_markets, place_bet, claim_payout. No custody, no allowlist, no API key.
There’s also a pay-per-call signal endpoint, x402 style. Agent hits it, gets a 402 with a machine-readable price, sends 0.01 USDC onchain, retries with the tx hash, gets the data. No account, no signup, no human in the loop. Machines paying machines for information.
What’s live right now
Everything is live and verifiable on Arc testnet:

App: https://t.co/wHVa666hYo
Code: https://t.co/FfOWIDBhQA
Contract: 0xff95939b9eda771188ae5be523becc2098ffdbe7

What’s not there yet, plainly: no production volume, no audit, no mainnet — because Arc mainnet hasn’t launched. Next up is optimistic resolution, Circle Wallets for passkey onboarding, CCTP and Gateway for cross-chain funding, and StableFX for cross-currency positions.
The bet
Prediction markets stop being a US entertainment product the moment settlement stops being US-only. Demand for macro forecasting is global. Central banks exist everywhere. The only reason these markets look American is that the infrastructure to build them any other way didn’t exist.
Now it does.
Built solo, in days. Go break it and tell me what’s wrong with it.
#arc #agenticeconomy @BuildOnCircle @arc

[🫎 MUHOMOR. base.eth @muhomoreth]

Stop Letting Your AI Hallucinate: Why I Built Fermah MCP https://t.co/Ci3dnMJEAG

[🫎 MUHOMOR. base.eth @muhomoreth]

@TheSaudisNFT 3xN1cLn1byXiiRiM7Gq5B7QNMZBS1quewkVYb2Jqv86V

[The Saudis 🇸🇦 @TheSaudisNFT]

The Saudis have struck something. 🛢️

Early wallets will receive special access.

Something is coming to Robinhood. 🟢

https://t.co/0Au1GMR6am

Like. Repost. Drop your wallet. 👇

[🫎 MUHOMOR. base.eth @muhomoreth]

Asteroid Loot is our attempt to bring real arcade intensity into an on-chain game loop without sacrificing pace.

At its core, Asteroid Loot is a browser-based space shooter. Players dodge dense asteroid waves, destroy high-value vaults, catch temporary power-up lootboxes, and survive comet-boss finishes as each level becomes more aggressive. We wanted the game to feel fast first: sharp aiming, rising pressure, visible progression, and that constant “one more run” energy that defines great arcade design.

The blockchain layer is there to strengthen the run, not interrupt it.

Instead of forcing a wallet interaction on every action, Asteroid Loot uses an Inco-backed contract flow to lock in progression at meaningful moments. When a player clears a level, they can save that checkpoint on-chain, preserving earned progress, unlocking the next level, and queuing rewards for later withdrawal. That lets gameplay stay fluid while still giving the run real persistence and on-chain value.

What makes Inco exciting for us is not just storage, but the larger design direction it enables. The contract side of the project already includes confidential game logic primitives, and that opens the door to privacy-preserving mechanics, hidden loot logic, and more advanced competitive systems that feel native to games rather than copied from finance.

Asteroid Loot is about combining three things in one experience: arcade skill, rising difficulty, and meaningful on-chain progression.

Watch the demo here:
https://t.co/NejOpvqLH2

#IncoNetwork
@inconetwork @remi_gai

[🫎 MUHOMOR. base.eth @muhomoreth]

The Agent-on-Agent Scam Arc Cannot Stop https://t.co/AvOfA2us2j

[🫎 MUHOMOR. base.eth @muhomoreth]

Arc stole Ethereum’s ecosystem. Legally. With a single line in the announcement https://t.co/4V4DZRrbFp

[🫎 MUHOMOR. base.eth @muhomoreth]

small but nice update to the GIWA MCP Server: it now speaks Korean. https://t.co/Lh9LY8BdYE

[SAT20 Labs @SAT20Labs]

@muhomoreth Agent-facing Bitcoin tools are most useful when read access is source-verifiable and transaction authority stays explicitly scoped. That boundary lets builders automate research without turning observation into custody.

[🫎 MUHOMOR. base.eth @muhomoreth]

https://t.co/MVQgpDbAXC

[🫎 MUHOMOR. base.eth @muhomoreth]

https://t.co/Hn9eRW5f4l

[🫎 MUHOMOR. base.eth @muhomoreth]

https://t.co/ORB6mb7JQj