unify retweeted
I think one of the most obvious yet slept-on ways to change your life over the next year is becoming the guy people go to for objective AI model comparisons.
maybe I'm wrong, but there's still no real "Marques Brownlee" of AI models - and even if there is, there's 100% room for more.
best name I could think of for X is @AlexFinn - but that's it.
10 scrolls on Instagram as a young tech person and you'll probably find 3 videos telling you the "best AI for …", but so much of it feels like people regurgitating whatever ChatGPT or Claude told them rather than actually using these models extensively and comparing them from real user experience.
and you can niche down endlessly.
if I was a motion designer trying to understand how AI could make me better at my job, the easiest click of my life would be following someone who constantly tests the best models, workflows and tricks specifically for producing excellent motion designs.
same for developers. researchers. writers. students. designers. literally anything.
I genuinely think whoever becomes trusted for this type of work is sitting on the frontline of what could be legendary content creation over the next few years.
the reason I'm writing all of this though is because I want to try. and unfortunately, I need help.
this is probably one of the most embarrassing things I've ever written. I feel ashamed even typing it because I've experienced firsthand what it feels like to try and try and still not get the result.
after a while, you begin looking down on everything you've ever done.
my life really started falling apart after an incident where I was kidnapped and extorted N4.6M by Nigerian police officers (Sept 26 last year)
this happened roughly a day after I received money from the Plasma airdrop - money I had honestly earned being one of the biggest voices for stablecoins in my region at the time
something about me changed psychologically after that.
I entered this phase of thinking:
"if I can hustle for over a year and someone can just take half of it from me, why shouldn't I spend the rest on myself before something else takes it?"
I still invested some of what remained into MegaETH, but far less than I would have with a clearer head and more capital.
you'd think it ends there but roughly two months later, another disaster happened.
unify retweeted
one of the biggest challenges in digital hardware design is proving that you actually know how to design and build working circuits. 🧵 🖊️
imagine you’re applying for an embedded systems or digital design role. a company gives you a take-home test, you complete it, submit your work, and someone manually reviews it.
the problem is that the result stays private. there’s no easy way for another company, instructor, or reviewer to independently verify that your design works.
the same problem exists in education and within the tapeout ecosystem.
students submit simulation screenshots, developers share github repositories, and builders showcase their circuits, but verifying the actual work can still be difficult.
there’s also a problem with open competitions.
since @TapeOutWorld makes circuit designs public when they’re submitted, someone can simply wait for another person to publish a working solution and copy it.
so how do you reward the person who actually committed to solving a challenge first?
my idea as a solution: circuitcred
circuitcred is a sealed hardware design challenge and verification platform built on @TapeOutWorld and @XLayerOfficial
it allows anyone to create a hardware design challenge, invite others to solve it, and verify who submitted a working solution before the deadline.
think of it as a coding assessment platform, but for hardware and digital circuit design.
the difference is that @XLayerOfficial handles the commitment and verification process.
every successful submission gets a public, verifiable record that anyone can inspect without connecting a wallet.
how circuitcred works
the entire process has four stages.
->publish a challenge
a company, instructor, or community organizer creates a challenge.
for example:
“design an 8-bit ALU with carry and zero flags, using no more than 120 gates.”
the host defines the requirements, test cases, gate limit, submission deadline, and reveal deadline.
the challenge is published through the host’s own DeWEB container.
->commit your solution
participants read the requirements and start designing their circuits.
they can use the tapeout canvas or write their designs in Verilog and compile them using TapeSynth.
before the submission deadline, each participant submits a cryptographic hash of their design.
this is important because the actual circuit remains hidden.
nobody can see or copy another participant’s solution at this stage.
participants can update their commitment before the deadline, but only their final commitment counts.
->reveal and verify
once the commitment deadline passes, participants can reveal their designs.
they tape out their circuits and submit the information needed to match the original commitment.
the smart contract checks several things:
-does the participant own the submitted circuit?
-does the circuit match the hash they committed to earlier?
-is the circuit within the allowed gate limit?
-does it pass the required test cases?
-does the submission meet the challenge requirements?
the contract checks a sample of test cases directly on-chain.
the full test suite is then independently executed using the TAP-02 reference evaluator.
if the checks pass, the participant receives a successful on-chain record.
->public verification
this is where circuitcred becomes useful beyond the competition itself.
anyone can open a submission record without connecting a wallet or creating an account.
they can see:
>the challenge and its requirements
>the solver’s wallet address
>the circuit submitted
>the number of gates used
>the original commitment block
>the reveal block
>whether the design passed verification
the browser independently runs the full test suite and checks the result against the blockchain.
this gives reviewers a way to verify the result themselves instead of relying on screenshots or someone’s word.
Good ideas deserve to be heard.
Tweet about what you wish existed onchain, tag us and @TapeOutWorld, and stand a chance to win 2K USDT.
Ends Nov 17. Submit here: bit.ly/4eQxFIH
Check this out real quick, just saw an underrated gem on arc 👀
it's called @Aurumlend, a lending protocol built on Arc.
the main idea is simple. you supply usdc and earn yield on it. borrowers on the other side pay interest to use that liquidity, and that interest goes to suppliers.
what makes it fit arc so well, i think, is that usdc is the gas token there. the whole chain basically runs on dollars, so having a place to put idle usdc to work feels like one of the first things the ecosystem needs.
a few things i noticed:
• markets for usdc, cirbtc and weth
• supply and borrow rates shown side by side, so it's easy to compare
• staking is listed as coming soon
it's still early, so worth getting familiar with now.
as always with lending, read up on collateral and liquidation rules before you borrow anything.
take a look 👇
aurumlend.finance
🤝 Paid partnership
AI agents are starting to trade with real money. The hard part isn't the strategy. It's what happens when the agent is wrong, manipulated or compromised.
IntentRail keeps the agent's funds in a NEAR contract that enforces the owner's limits itself.
✨ website : intentrail-neon.vercel.app
✨ github repo : github.com/Onegeex/intentrai…
Built at NEAR HACKATHON for @NEARProtocol, AI Security & Defense track #NEARHackathon 🧵
unify retweeted
My submission for @NearBuilders hackathon.
Meet PORTI, an AI-powered onchain companion built on NEAR that brings multiple Web3 tools into one simple workspace.
It helps users research tokens, track wallets, manage assets, make payments, swap tokens, explore staking and interact with the NEAR ecosystem through a simple conversation.
Our goal is to make Web3 easier to navigate without jumping between multiple platforms.
Think of PORTI as your little onchain world, made more human.
Built with ❤️ on NEAR.
@NEARProtocol @NearBuilders @NEARLegion
#NEARHackathon
I hate it when live translation gets the meaning wrong because it jumped in too early, and I'm happy @soniox_ai just changed that.
v6 knows when to start translating, so it keeps up with the convo and still gets it right
Dates and amounts stay correct even when people mix languages mid sentence
Builders, this one's worth testing
🤝 Paid partnership
Soniox STT does not stop at transcription. It also supports real-time speech-to-text translation, delivering the transcript and the translation together in one stream across 3,600 language pairs.
Translate too early and you get the meaning wrong. Translate too late and the conversation moves on. With v6, Soniox STT knows when to start translating, so meaning stays accurate without falling behind.
The details hold up too: dates, amounts, and currencies stay accurate, even when people mix languages in the same sentence.
Build dedicated speech translation apps, or add live translation to your existing meeting product.
Explore real-time translation: soniox.com/blog/soniox-stt-v…
unify retweeted
I build onchain products, break them, then grow them.
That line is my whole pitch, and I finally have a place that backs it up. My portfolio is live at iamsolution.dev. The video is a full walk through it.
Quick intro. I'm Solution. Web3 developer, smart contract security researcher, growth marketer, and founder of @the41lab.
What you'll find inside:
Engineering. 20+ projects built, 11 live right now, across EVM, Starknet, Solana, Move and Cosmos. Contracts, @joinIwa, Certael, Covenant, ReTray, shrud, FLOAT and more, each one with a link you can click.
Security (beginner). I built ExploitLens, a tool that replays an exploit against the vulnerable code and the patched code, to prove what the fix actually blocks. My findings counter says 0 and I left it that way on purpose. It moves when there is a public report to link to.
Growth. More than a year running X, Discord and Telegram for Web3 teams like Solsweep, Sqwad and Fragment NFT. Moderation, custom bots, and the community work that keeps a project alive after launch.
Now the ask.
I'm open to full time roles and contract work in smart contract security, Web3 engineering, frontend and growth.
I'm also open to collaborations. If you're building something and need a developer, a second pair of eyes on your contracts before the audit, or someone to grow the community around it, I want to hear about it.
My CV is one click to download on the site, and you can book a 30 minute call with me from any page. Prefer email? [email protected]. DMs are open too.
If you're not hiring, a repost helps this reach someone who is. Thank you.
visit: iamsolution.dev
email: [email protected]
unify retweeted
Security is a choice and the choice is urs.
I've made mine with @solflare
The recent hardware wallet supply-chain attack have raised a question of how much the design of a hardware wallet contributes to its security.
The reported attack didn't require breaking the secure element. It's a reminder that even when a secure element does its job, other components can introduce vulnerabilities.
When we designed Solflare Shield, we made a deliberate decision: keep the hardware as simple as possible, without compromising its core purpose.
Shield is a card-sized hardware wallet built around a secure element, with only the components necessary to protect private keys and authorize cryptographic operations.
1. Keeping the hardware minimal
Hardware components beyond the secure element can create additional opportunities for attackers, particularly when they introduce new interfaces or communication channels.
Shield has no screen, display interface, battery, Bluetooth, Wi-Fi, or cellular modem. It's a passive NFC card that draws power from your phone during a tap.
This eliminates certain classes of hardware attacks, including the specific display interception mechanism.
2. Separating the wallet experience from key protection
Shield is designed to work with the Solflare app rather than operate as a standalone device. The app handles the interface and prepares transactions, while Shield's EAL6+ secure element performs cryptographic signing internally.
The tradeoff is that your phone acts as the screen. The recovery phrase is shown once in the Solflare app during setup, and transactions are reviewed there before you tap.
After setup, your private key stays on the card and is never stored on your phone or in the Solflare app.
This separation keeps the physical hardware focused on protecting keys and authorizing transactions, without requiring additional components to support the user interface.
3. Reducing supply-chain exposure
Hardware security also depends on what happens between manufacturing and delivery.
Shield is sold exclusively through the official Solflare Shop, without an authorized reseller network or third-party retail distribution.
Additional protections, including cryptographic authenticity verification, safeguards against unauthorized software replacement, and tamper-evident packaging, are designed to reduce the risk of compromised devices reaching users.
These measures reduce certain risks, but no distribution model or security mechanism can completely eliminate the possibility of physical tampering.
Security is a series of design decisions
Sophisticated attacks are a reminder that protecting private keys requires looking at the entire device, its components, and the supply chain behind it.
Different hardware wallets make different design tradeoffs, and no architecture is immune to every threat.
With Shield, we chose to prioritize simplicity, minimize unnecessary components and keep the hardware focused on protecting your keys.
think of a student who reads hundreds of books. they may know a lot, but learning how to apply that knowledge and understand people's perspectives takes more than reading.
could AI develop that kind of understanding? could it learn what people value instead of just generating content?
that's the experiment behind $SAI.
built by @NEXST_AI, SAI is creating an AI-only social network where AI agents create, interact and learn from human judgment.
users can predict how AI-generated content will perform, including what could go viral. these predictions become part of the learning process, as SAI works towards going head to head with general AI models.
$SAI already has a 1,000-user beta running.
launch date? november 20 on pump.fun, with:
. 1B fixed supply
. 0% buy/sell tax
. 0% team allocation
. 50% supply allocated to LP
token first. app next.
keep tabs for updates ahead of launch.
giveaway: $50 USDT up for grabs. To enter:
follow @sai_superai
like and rt this post
🤝 Paid partnership
unify retweeted
Today’s Stacks Exploration 🟧
Something interesting caught my attention while going through the latest Stacks research.
Stacks Labs has successfully demonstrated an sBTC transfer on mainnet using a post-quantum signature.
And I think this is worth understanding because it touches on something that could become increasingly important for Bitcoin’s future: quantum security.
Let’s break it down.
Most blockchain transactions today rely on a form of cryptography called elliptic-curve cryptography.
In simple terms, it helps prove that the person authorizing a transaction actually controls the required private key.
The concern is that sufficiently powerful quantum computers could eventually break the mathematical assumptions behind these signatures.
If that happens, attackers could potentially derive private keys from public keys and authorize transactions they don’t own.
This is why developers are already exploring post-quantum cryptography.
One approach is called a Lamport signature.
Unlike the conventional signatures used by Bitcoin and Stacks, Lamport signatures rely on cryptographic hashes and one-time signing keys.
That’s the approach Stacks Labs decided to experiment with.
The team built a vault using Clarity, Stacks’ smart contract language, that requires a valid Lamport signature before releasing sBTC.
Here’s where it gets interesting.
On October 15, 2026, the team successfully used this system to transfer 1,000 satoshis of sBTC on the Stacks mainnet.
The transaction was submitted by a separate Stacks account, but the vault only released the funds to the recipient authorized by the signature.
The authorization also included details such as the amount, recipient and next signing key.
Changing those details would invalidate the signature.
Another interesting part is that the implementation used SHA-256, a hash function already supported by Clarity.
So the demonstration didn’t require a new opcode or a Stacks protocol upgrade.
Now, I think there’s an important distinction to make here.
This doesn’t mean Stacks is now quantum-proof.
The experiment is a proof of concept.
It demonstrates that a Clarity smart contract can verify a Lamport signature and authorize an sBTC transfer.
It doesn’t upgrade regular Stacks transactions, existing sBTC wallets or the Bitcoin reserves backing sBTC.
There’s still work to be done around security audits, wallet integration, recovery mechanisms and how these signature schemes could eventually work at a wider network level.
But I find the direction interesting.
Preparing for quantum computing isn’t something that should begin only when the threat becomes immediate.
It requires research, testing and understanding the trade-offs before any major transition happens.
And this is one practical experiment showing how Stacks developers are approaching that challenge.
I’ll be interested to see which other post-quantum signature schemes the team evaluates and how this research develops into a broader security strategy for Stacks and Bitcoin.
For now, it’s a small transaction, but an interesting step in a much bigger conversation.
Original research:
stacks.co/blog/the-first-pos…
Verify the mainnet transaction:
explorer.hiro.so/txid/0xb983…
@Stacks
csmartrex
Exploring the Stacks Ecosystem
Today’s Stacks Exploration.
Something interesting just went live on @Stacks, and I think it’s worth paying attention to.
@ZestProtocol has officially launched Concentrated Liquidity Market Making (CLMM) on Stacks mainnet.
If you’ve used Uniswap v3 before, the concept might sound familiar.
But if you haven’t, let me break it down.
With traditional liquidity pools, liquidity providers generally spread their capital across a wider range of prices.
The problem is that a lot of that liquidity might sit at prices where trades rarely happen.
Concentrated liquidity takes a different approach.
Instead of spreading capital across every possible price, liquidity providers can choose specific price ranges where they want their capital to be used.
This allows more liquidity to be concentrated around active trading prices.
The potential benefit?
Traders can get better prices and experience less price impact, while liquidity providers can make more efficient use of their capital.
Now, Zest has brought this model to Stacks.
Two pools are already live:
STX/USDCx
ZEST/STX
And it’s not limited to Zest’s own swap interface. Tenero is also routing trades through the new infrastructure.
There’s another interesting part.
Zest says token teams can work with market makers to manage liquidity strategies through its Liquidity Vaults, creating more opportunities for projects building on Stacks.
The team has also announced 100,000 STX in rewards for early traders, although the campaign details are still to come.
Of course, concentrated liquidity isn’t without its risks.
If the market moves outside the price range selected by a liquidity provider, the position can become entirely one-sided and stop earning trading fees until the price returns or the position is adjusted.
So it’s not simply a case of depositing liquidity and forgetting about it.
I think this is a meaningful addition to Stacks DeFi.
We’ve been talking about bringing more Bitcoin liquidity into the ecosystem, but the infrastructure supporting trading and market-making also needs to improve.
Better liquidity tools give traders, market makers and token teams more ways to participate.
Now I’m interested in seeing how much activity these new pools attract and how the 100,000 STX incentive campaign will be structured.
Stacks needs more useful products, and this is one development I’ll be watching closely.
Explore it here: app.zestprotocol.com/swap
Read the announcement: zestprotocol.com/blog/zest-p…
@ZestProtocol @Stacks
csmartrex
Exploring the Stacks Ecosystem
unify retweeted
i built 𝗧𝗮𝗿𝗲 for serv hackathon 2.
𝗵𝗲𝗿𝗲'𝘀 𝘁𝗵𝗲 𝗽𝗿𝗼𝗯𝗹𝗲𝗺:
AI agents now pay for data on their own over x402.
the seller describes the delivery ("1,240 unique records, no nulls"), the agent pays, and moves on.
spending caps limit how much an agent can pay. nothing checks what came back.
pay per record? then someone has to count the records.
𝗧𝗮𝗿𝗲 is an independent check of what an x402 data seller delivered:
→ before paying, it reads the seller's own 402 advertisement, the promise made before any money moves.
→ it pays over x402 on Kite testnet, inside hard caps (0.05 per payment, 1 pieUSD total).
→ @openservai SERV reasoning reads the seller's words and turns them into typed claims. it never sees the rows and never gives a verdict.
→ plain code counts the rows, unique ids, fields, empty values and timestamp ages, and checks every claim.
→ a broken promise is a dispute, and the seller is held. the next buy stops before any payment.
in the demo below, every payment is real and settled on Kite testnet:
> seller A promised 1,240 unique records. code counted 860 unique and 40 empty timestamps. its ad also promised a "score" field that never arrived. dispute, seller held.
> buy A again: stopped, zero payment.
> seller B promised 200 and delivered 200. Verified.
𝗵𝗼𝘄 𝗦𝗘𝗥𝗩 𝗶𝘀 𝘂𝘀𝗲𝗱, 𝗵𝗼𝗻𝗲𝘀𝘁𝗹𝘆:
✓ SERV reads; code decides.
the model has no verdict to give, so a seller can't talk it into a pass.
✓ i probed real x402 sellers and found SERV invented claims on vague service descriptions.
so code now drops any claim the seller's own text doesn't support (a count must be a number the seller actually states, not "up to 20" or "10,000+").
✓ live eval: 9/9 accuracy on honest texts, 6/6 safe on injection attempts.
✓ i measured SERV's Prompt Guard and kept it off on purpose:
it turns an injection attempt into a SERV failure, which would get the seller paid instead of held.
✓ SERV also explains each dispute in plain English, written only from the numbers code measured. code rejects it unless every number is in the evidence, and it never changes the verdict.
𝘄𝗮𝗿𝗻 𝗼𝘁𝗵𝗲𝗿 𝗮𝗴𝗲𝗻𝘁𝘀:
✓every check becomes a public seller record with evidence: both promises word for word, the settlement hash, body hash and prompt hash.
✓ records are signed. other agents pin the publisher by address or Kite DID, checked against Kite Passport's public key set.
✓ an agent that trusts the feed never pays a seller Tare caught.
✓ anyone can check a seller before paying, and honest sellers earn a badge.
𝗮𝗯𝗼𝘂𝘁 𝗞𝗶𝘁𝗲 𝗣𝗮𝘀𝘀𝗽𝗼𝗿𝘁:
it's fully integrated (account, sandbox, agent, passkey-approved session), but Passport only pays sellers in Kite's catalog, and mine aren't listed yet.
so the published run signs the same x402 payments with a capped testnet key, settled by Pieverse.
every hash shown is real.
spending policies decide whether to pay.
𝗧𝗮𝗿𝗲 checks what you got.
live demo: tare-agent.vercel.app
code: github.com/Ritapossible/Tare
built with @openservai SERV Reasoning
Kite track. @GoKiteAI
most chains are starting to realize that owning their own apps is the way to go
but katana took that a step further by not owning just one, but THREE!
katana now owns its native dex, its perps engine (acquired from IDEX), and its own yield layer
and guess what?
that's not even the most interesting part
all three generate revenue from real activity on the network, alongside sequencer fees
a portion of that revenue is used to buy back $KAT from the open market
and 100% of the bought-back $KAT goes directly to avKAT stakers
100% of the bought back $KAT! yeah! you heard that right
so even if you're not trading, you can still benefit from the activity happening across the network simply by staking $KAT
the more people use katana, the more revenue its ecosystem can generate, and the more potential buybacks for stakers
this is the kind of tokenomics i want to see more of in defi
more of this please
🤝 Paid partnership
I built RYO Pulse few weeks ago for the @ryodigital RYO-CHAN hackathon and i honestly think it fixes something every trading agent gets wrong 👇
here’s the thing, Ryo-Chan gives Ai agents a live market scan that ranks the hottest tokens right now but “right now” is just one snapshot.
we watched real scans 15 minutes apart and the list kept reshuffling in a way that a token would sit at #1 then vanish in the next scan and agents were treating that one lucky moment like a real trend.
so we asked a simple question nobody was asking: did this token actually KEEP showing up?
that’s RYO Pulse. it remembers every scan and gives each token one honest answer:
• persistent, because it keeps showing up scan after scan
• emerging, because it’s new but it’s holding its spot
• transient, because it flashed once and faded
• absent, because it never showed up at all
• insufficient, because there isn’t enough data and we refuse to guess
what really makes it different is that it refuses to lie to you.
when ryo had a real outage during the hackathon, most tools would have told you every token disappeared.
Ryo-Pulse marked those scans as failed and kept the tokens’ records clean because missing data is not the same as a missing token.
also every single answer comes with a replay code, when run it again tomorrow, next week, on another machine, you will get the exact same result.
Ryo-Pulse runs on two tracks: a read-only skill (TRACK 3) your agent can call before it acts on a scan and a dashboard (TRACK 2) where you can see what changed, why each token got its status and how healthy the scans are.
all of it runs on 114 real ryo scans, real outage included. it never trades and never touches funds.
recently, i made changes and ran chvek and also just gave the ui a fresh look in clean white, black and royal blue 💙
both videos below show the same project. the first one is the original before we made changes, and the second is the new look. please watch both 👇
try it: ryo-pulse.myacxt.site
code: github.com/Mhiah/RYO-PULSE
unify retweeted
you've been finishing mid-table in FPL since 2019. well, it's time for a new league.
welcome to WIF League. NVDA as captain, TSLA up front, META in midfield.
fantasy football, but with stocks. no injuries, no rotation, no Pep ruining your weekend.
draft 5 Stock Tokens on Robinhood Chain, pick your captain and enter with 1,000 $WIF.
Chainlink handles the scoring at the 21:00 UTC close. Top 3 split the pot, 10% gets burned.
small field, open podium. finally, a chance to win something.
built for @WIFonRH's World is Flat.
wifleague.nerom.site
I've always wondered what it's like to actually let an ai agent handle money. the version where you say "send 10 usdc to this address", it comes back with "done!", and you just... believe it.
the more i thought about it, the more that "done" bothered me.
an agent's "done" is usually two things stacked on top of each other: a wallet tool that returned "success", and a model that repeated it back to you. nobody in that loop actually looked at the chain.
and the chain is where things go wrong:
- the tx can revert, so nothing moved, but the tool still said success
- the tx can go through but pay a different wallet, or a different amount
- the model can just make up a hash that looks right
even "the tx succeeded" isn't enough. a receipt with status 1 means the transaction executed. it doesn't mean the payment you asked for happened.
so i built Proofly for the @NousResearch hermes agent hackathon.
Proofly is a hermes plugin that sits between the agent's payment tools and you. when a payment tool runs, it takes the exact arguments the tool was called with (recipient, token, amount), pulls the transaction and receipt from base mainnet, and checks:
- did it execute?
- did the right token move?
- to the right wallet?
- for the exact amount?
- with enough confirmations?
if everything matches, the reply goes through with the proof attached: block, confirmations, basescan link.
if it doesn't, the "sent!" sentence gets rewritten before you ever see it, with the reason.
the video shows three cases:
1. send 5 usdc: the wallet says success, but the tx reverted onchain. nothing moved. Proofly corrects the reply.
2. send 10 usdc: a real tx that executed, but it paid a different wallet ~2.1 usdc. Proofly flags the mismatch and shows expected vs observed.
3. send 30 usdc: right wallet, right token, exact amount. verified, reply kept, proof attached.
then /proofly shows every verdict from the chat in a local ledger.
to be clear about the demo: the wallet is simulated and the model's replies are scripted, so i could show the worst case on purpose, a model that always says it worked. hermes is real, the tx hashes are real base mainnet transactions, and every check runs live against base rpc.
a few choices i cared about:
- read-only. no keys, never signs, never sends. it can't move your funds.
- it only trusts structured intent (the tool's real arguments, or numbers you give it), never the model's own words or a random hash in the chat.
- when it doesn't know, it says so. rpc down means "unverified", not "failed". weird cases like batch transfers get "unsupported", not a guess.
limits: base mainnet only, plain eth and erc-20 transfers. and it checks what the tool was asked to do, so if the model put the wrong address into the tool call, Proofly verifies that wrong address. for that, /proofly check lets you check a tx against your own numbers.
imo this is where agent payments have to go. not "trust the agent", but "trust the receipt". a model saying done costs nothing. a receipt that matches what you asked for is the part worth paying attention to.
try it:
hermes plugins install 0xileri/proofly --enable
repo: github.com/0xileri/Proofly
catalog pr: github.com/NousResearch/herm…
The Hermes Agent Plugin Hackathon starts now!
It runs for 7 days, with $20,000 in cash prizes and more.
Plugins are the most powerful way to extend Hermes Agent, and we want this hackathon to show what they can do. A plugin can change anything from the model Hermes runs on, where it stores its memory, where it runs commands, which messaging apps it works in and what Hermes Desktop shows. Plugins in the marketplace already let Hermes do things like control a phone or turn a photo into a printable 3D model.
Every kind of plugin is eligible, so build whatever functionality you want Hermes to have. We'll list accepted entries in the new Hermes Marketplace, where every Hermes user can install them.
Prizes
1st: $10,000 + neon sign + merch + $1,000 creds
2nd: $5,000 + neon sign + merch + $1,000 creds
3rd: $2,500 + neon sign + merch + $1,000 creds
4th: $1,500 + merch + $500 creds
5th: $1,000 + merch + $500 creds
Runners up (x5): merch + $250 creds
Submissions are due 5PM EST on Nov 11th. To enter:
1. Open a pull request that adds your plugin to the Hermes plugin catalog: hermes-agent.nousresearch.co…
2. Post a demo video on X and tag @NousResearch
3. Submit both links through the form: form.typeform.com/to/FwJLvOl…
Your entry is the plugin itself. Judges score it on usefulness, reliability, polish and creativity, and they favor plugins that do more than a prompt or a skill could. Keep the demo under 90 seconds and show the plugin working.
The developer guide shows how to build and test a plugin: hermes-agent.nousresearch.co…
When submissions close, we'll open a thread for every entry in the Nous Research Discord, so you can browse all the plugins and talk to the people who built them.
You can submit the form as soon as your pull request is open. The catalog checks run once a maintainer starts them, and we review entries every few days.
If you have any questions stop by the Nous Research Discord: discord.gg/nousresearch
GLHF!






































