
I belong to Jesus. Core developer #MultiversX
Joined August 2014
- Tweets15.9K
- Following731
- Followers22.6K
- Likes18.8K
things are moving fast.
private LLMs, owning models and data is getting important.
not only for regulated businesses, but like any startup too.
AI is opening up a lot of new things.
open-weight models closed the quality gap.
the new bottleneck is serving: cost per token, latency under load, and where your data is processed.
Alpha has joined NVIDIA Inception to scale that layer.
alpha.sh/blog/alpha-joins-nv…
a draft ERC on Ethereum asks a good question: when an issuer changes a token, where is the "why"?
today a rescale, a new issuance or a parameter change shows up as raw event logs. no reason, no link to the disclosure behind it.
the proposal: an Announcement event opens a bracket, the state changes run inside it in the same transaction, an EndAnnouncement closes it. one id ties the change to a document, and later corrections keep the same id.
for tokenized real-world assets this matters. a corporate action gets announced, corrected, confirmed, then executed. the chain only sees the last step.
the same gap exists for issuer actions on MultiversX tokens. a multisig / governance contract can be set as the token controller and these implementations can be done there.
builders: would you want this as a standard, or is a link in the transaction data field enough?
4
476
xExchange merged a small PR today that every contract team should copy: reproducible release builds.
the problem: you read the source on GitHub, but what runs on chain is a .wasm file. how do you know one came from the other?
what mx-exchange-sc #1081 does:
- release builds run inside a pinned Docker image, sdk-rust-contract-builder v12.0.0
- the reproducible-build workflow from mx-sc-actions is pinned to one commit
- it runs by hand from the release tag, for one contract or all of them
- the release notes get the image and the codehash of each .wasm appended
their test release for token-unstake: the wasm built in CI was identical to a local build. same codehash.
that line is the point. same source + same pinned toolchain = same bytes. anyone can rebuild it, hash it, and compare with the code hash of the deployed contract.
two details I like:
- the CI action is pinned to a commit, not a branch. a moving CI dependency is a supply-chain hole
- the build starts from the tag, by hand. a release is a decision, not a side effect of clicking publish
if you ship contracts on MultiversX: could you rebuild your deployed wasm byte for byte today?
"RL generalizes, SFT memorizes" became a rule of thumb after DeepSeek-R1. this paper checks whether the comparison was ever fair.
the setup: Qwen2.5-7B and Qwen3-8B-Base, trained on DAPO math problems, then tested on reasoning tasks outside math.
what they changed on the SFT side:
- the source. a mix of answers from the RL-tuned model and from Qwen3-14B beat answers from the bigger model alone. the best mix in their runs was 70/30
- the scale. RL sees many rollouts per prompt, SFT usually gets one answer per prompt. match the number of correct rollouts and SFT generalizes much better. match the total rollout budget and it lands level with RL
- both together: SFT ends up ahead of RL
the why is the part I liked. they had an LLM label the solution methods in the training data. bigger datasets cover more rare methods, and those rare methods are the ones used on the out-of-domain questions.
honest limits: 7-8B models, math as the only training domain, and the theory part is on shallow transformers, not big ones.
my takeaway: before blaming the algorithm, check how much data it saw and how varied it was.
if you fine-tune: one answer per prompt, or many?
Great paper on why SFT can generalize just as well as RL if you give it enough diverse training data.
Like everyone else since DeepSeek-R1 dropped, I’ve been treating "RL generalizes, SFT memorizes" as gospel.
Whenever SFT runs plateaued on out-of-domain reasoning, everyone just blame the algorithm.
Turns out, we might have been running an unfair comparison the entire time.
In standard setups, RL gets to explore a huge rollout budget per prompt while SFT gets trained on a tiny slice of data.
So the authors decided to actually level the playing field on Qwen2.5 and Qwen3 models by testing two things: mixing data sources instead of just distilling from one giant teacher, and scaling up the SFT data to match RL's rollout budget.
The results completely flip the usual narrative.
A carefully mixed dataset easily beats single-teacher distillation, and matching RL's rollout budget lets SFT generalize just as well as RL.
And when you combine both, SFT actually outperforms it.
To figure out why, they used LLM annotations to inspect the rollouts and proved (both empirically and theoretically on shallow transformers) that larger data budgets expose SFT to rare, "tail" solution methods.
Those uncommon reasoning paths are where the actual generalization signal lives.
Honestly, for everyone tired of debugging finicky online RL pipelines, this is a huge relief.
SFT wasn't broken, we were just starving it of diverse rollouts.
Full paper PDF: arxiv.org/pdf/2611.14912
3
428
"who runs this thing?" is a fair question. the answer just isn't the one a politician expects.
on MultiversX nobody signs off on your transaction. validators run the same protocol rules, every block is checked by a group of them, and a block that breaks the rules gets rejected.
changing the rules themselves goes through on-chain governance proposals.
so the honest answer to "who runs it": a lot of independent operators, all running the same rules.
harder to fit on a TV panel than a name.
So Boris Johnson continues to get Bitcoin wrong, so I set the record straight at Solana Breakpoint.
"Who runs this thing? Yakamoto Nakasori… I don't know where to find him."
- No one has to guarantee it. That's the beauty of the protocol
- Finite issuance, secured by hardware and electricity
- Drug dealers? They'd rather use cash in hand than a traceable blockchain
Healthy scepticism is fine, Boris. But we've got to do better at educating politicians and influencers.
8
585
same curve on our side.
agents made writing the change cheap. they didn't make proving it correct cheap.
for smart contracts it's even sharper: unit tests, then scenario tests, then the chain simulator, then devnet. each layer is slower, and each one catches something the last one didn't.
so the work moved: faster suites, tests that run in parallel, and knowing which tests a change actually touches.
the team with the fastest honest feedback loop wins, not the one with the fastest model.
The bottleneck for software engineering keeps changing.
Historically, it was writing the code and tests to ensure they conformed with the specs.
In early days of agentic coding it was reviewing code for correctness.
Now (for complex projects) it's the build & test phase.
It's rather frustrating when you can make significant code changes in 10 minutes but then it takes an hour or more to find out if it passes QA.
the racetrack is the benchmark. the jungle is a real deployment: missing data, unclear goals, people who change their minds, systems nobody documented.
models keep getting faster on the track. most of the work is still in the jungle.
WASMageddon on MvX.
The attack would have been tricky to pull off, and its success was uncertain. It relied on guessing memory offsets that match most validators' machines. Of course, even unsuccessful attempts could have poisoned the blockchain history with effects well outside of the blockchain design, and caused damage difficult to undo. Although stating again with a pretty low probability.
like rerunning the same contracts over small internal networks did not succeed, but we couldn't risk a chance of the unknown.
stupidly: some of the AI models blatantly refused to even analyse the deployed contracts, they knew it was an exploit, so they did not want to give answers.
THIS IS SO STUPID. when as a developer you cannot use frontier models to actually fix issues / debug / find why there is an attack or what the attack tried to do.
i think this is a wrong take.
crypto in a wallet on the phone, that should be the normal.
yes, keep only an amount which you need for that month, not like everything.
but there is no reason why not to keep it in a phone.
i am keeping eGLD and MvX assets on my phone since the launch of @xPortalApp , back when it was called Maiar. No hacks, no issue, sometimes daily use.
no problems at all.
agents can now trade on MultiversX without anyone writing a bot.
OneDex just shipped an MCP server on mainnet. one endpoint, no API key, no extra fee, 6 tools.
the design is the part I'd copy:
- OneDex finds the route and builds the transaction
- your agent or your wallet signs locally, they never see a key
- minOut is enforced on-chain, so a bad quote fails instead of filling
two ways to use it:
1. in Claude, ChatGPT, Cursor or Claude Code: add it as a remote MCP connector, no sign-in. ask for a swap with your erd1 address. it simulates and gives you a signing link. you check receiver and amount in your wallet and sign. keep "needs approval" on.
2. fully autonomous: a dedicated agent wallet with a small budget, the key in your server env, and rules in code: max per trade, allowed tokens, max slippage, daily budget. the agent runs quote → build → simulate → sign → send → confirm.
my takes:
- the rules in code matter more than the model. the model proposes, the limits decide.
- give the agent a wallet you can afford to lose. never your treasury, never your 24 words in a chat.
- simulate before every signature. it costs nothing.
- next step I'd want: those limits enforced on the account itself, not only in the agent's code. [ROBERT: confirm you want to point at Guardians / multisig here, or cut]
this is what "agents on MultiversX" looks like when it's real: a tool any agent can call, and a chain that checks the result.
what would you let an agent do first with it?
Your AI agent can now trade on OneDex. By itself.
OneDex MCP is live on #multiversx mainnet.
One endpoint. No API key. No extra fee.
aggregator.onedex.app/ai/mcp
▸ Autonomous agents (video)
1. Create a dedicated wallet for your agent. Small budget, separate from your treasury.
2. Store its key in GitHub Secrets or your server env. Never in code, never in an AI chat.
3. Set your rules in code: max per trade, allowed tokens, max slippage, daily budget.
4. Give the order: "Buy ONE with 0.3 EGLD".
5. The agent does the rest: quote → build → check → simulate → sign locally → send → confirm.
OneDex finds the route and prepares the transaction. Your agent signs. We never see keys. minOut enforced on-chain.
▸ Use it in Claude (2 minutes)
1. Open claude.ai → Settings → Connectors
2. Tap "Add custom connector"
3. Name: OneDex
URL: aggregator.onedex.app/ai/mcp
Authentication: No sign-in
4. Tap Add → Connect. 6 tools appear.
5. Keep "Needs approval": you approve every step.
6. New chat, ask:
"Using OneDex: swap 0.3 EGLD to ONE for my address erd1…, simulate it and give me the signingLink."
7. Open the link, check receiver + amount in your wallet, sign.
Only give the AI your public address (erd1…). Never your 24 words, key or password.
▸ Cursor, Claude Code, ChatGPT or any MCP client
Add the same URL as a remote MCP server. Exact configs in the docs.
Docs, 6 tools, TypeScript example:
onedex.app/agents
a new paper plugs a 552B model into a robot policy.
ScaleVLA puts a DeepSeek-V4.1-Flash backbone in front of a trainable action head, and compares backbones from 2B up to 552B under the same training setup.
the headline is the size. the numbers I'd actually read:
- 10 demonstrations on the big backbone beat 50 on a 2B one: 87.8% vs 85.6%
- LIBERO-PRO, the generalization test: 45.1%, vs at most 31.3% for smaller backbones
- real charger insertion: 9 of 10, up from 4 of 10
- 216 ms median per action chunk, despite the size
I like the result. I'd read it slower than the headline.
87.8 vs 85.6 is a small gap. the real win is needing 5x fewer demos, and demos are the expensive part of robotics.
45.1% on generalization still fails more than half the time.
9 of 10 is ten tries on one task. promising, not a success rate.
my read: big pretrained models seem to carry knowledge that helps the hands, not only the words. the open question is whether that's worth running a 552B model next to a robot arm.
if you build robots: would you take a much bigger model for 5x fewer demonstrations?
1
4
759
small fact for cross-chain wallet builders: MultiversX and Solana use the same curve, ed25519.
a public key is 32 bytes on both. only the encoding differs:
solana: base58(pubkey)
multiversx: bech32("erd", pubkey) → erd1...
so one raw ed25519 key gives you an address on each chain, and underneath it's the same key.
from a seed phrase you won't land there by accident, because the derivation paths differ:
if you do reuse one key on purpose: one leak drains both. for real funds, derive separate keys.
positive preclinical results in cancer and immunology, they say.
preclinical is the benchmark. the clinic is the eval.
the number I'll watch: how many get through phase 2.
congrats in doing this and in making life healthier for people. I hope this research gets down to everyday persons.
although I would refrain from saying solve all disease, that is not possible. that maybe the dream of trans humanist, but in the end, you cannot reverse entropy of the universe.
that will be done in the new age and new earth, as stated in the Bible.
Thrilled to announce $5B in funding for @IsomorphicLabs to accelerate our mission to Solve All Disease. We continue to make rapid progress reimagining drug design from first principles with AI to radically cut the time & cost to find new medicines. Gradually, then all at once...
8
11
1,013
Ethereum's next upgrade, Glamsterdam, makes creating new state more expensive in gas. on Monday's core devs call, an Ethereum Foundation developer estimated it could affect up to 15,000 deployed contracts. the Hoodi testnet rollout is on hold until it's sorted.
under the headline is a question every chain has: how do you find what a rule change breaks, before it ships?
what they did, in layers:
1. a broad scan: ~15,000 contracts possibly hit, out of ~90 million
2. paid reviews of the risky ones by outside auditors, which turned up contracts that would actually break, some of them missed internally
3. outreach: on 6 Nov the Foundation warned developers about 8 assumptions that may stop holding, then contacted teams directly. most of the affected teams are patching
the scan gives you a number. the reviews give you the actual breakage. you need both.
the root of it: a contract can be immutable, but the gas prices it was written against are not.
on MultiversX the gas schedule is a versioned file in the node config, switched on from a given epoch (GasScheduleByEpochs in enableEpochs.toml). contracts also carry an upgradeable flag in their code metadata, set at deploy.
that makes the fix easier. it doesn't find the breakage for you.
if you write contracts: which of your calls would fail if storage got 5x more expensive tomorrow?
someone asked an AI to look through the latest Windows 11 binaries for undocumented features. it came back with a list of names inside a system DLL: codex.exe, claude.exe, copilot.exe, cursor.exe. right next to python.exe, gcc.exe, node.exe and code.exe.
what the write-up found when it followed that list:
- the component is MissionControlAggregator.dll, loaded under the Windows diagnostics service
- it doesn't scan processes. it listens to events Windows already collects and matches executable names
- a match sets one bit: this agent was seen in the reporting window. no prompts or source code in the report
- the report is "optional diagnostic data", which was on by default in the author's clean US install, and then it's queued for upload to Microsoft
the test I liked: copy cmd.exe, rename it codex.exe, run it. the Codex bit gets set. it matches a file name, it doesn't detect an agent.
two things I take from it.
one: a bitmap of which tools you use is still data about you. if you'd rather not send it: Settings → Privacy & security → Diagnostics & feedback, turn off optional diagnostic data.
two: how it was found. reading a system DLL used to take a specialist days. now you point an agent at the binaries, ask what looks odd, and verify by hand.
if you ship a closed binary, assume someone's agent is reading it tonight.
a post saying all AI-generated code should be open source was the top of Hacker News today, with over 1,100 points.
the argument, fairly:
- models were trained on open source and Stack Overflow, so closing the output is "license laundering"
- purely AI-generated code may not be copyrightable at all (the US position, going back to the monkey selfie case)
- so release it under an open license, or CC0
I like the direction. I don't buy the rule.
"AI-generated" isn't a line you can draw anymore. a lot of code today is a human spec, a model draft, a human review, a model fix, a human merge. which side of the line is that? [ROBERT: confirm this matches how your team works now]
a rule nobody can apply doesn't change behaviour. it just gives lawyers something to argue about.
and copyright isn't the only reason code is closed. sometimes it's a client contract, sometimes the code is the whole business.
where I agree: for libraries and shared infrastructure, open is already the better default. more people read it, and models now read it too.
so the question I'd ask is who can check it, not who typed it.
if you had to open one: your prompts, or your code?
Solana dropped the "mainnet beta" label today, after more than six years, and adopted Solana 1.0 as a shared version number for its network rules.
the label is the headline. the version number is the useful part.
with Agave and Firedancer both running the network, each with its own release numbers, operators need one number that says which rules their software supports.
our mainnet went live on 30 July 2020.
today one client runs the network, so a node release and the protocol rules mostly move together. the day a second client exists, that stops being true, and the rules need a version of their own.










