Tb94 retweeted
GM GM.
The SnailCat held amazingly overnight.
Community are aligned and want to cook this.
This is the right ingredients for something to slowly creep its way to millions.
Slow runner. solana:5EpUkeRekk1uzWKoJz9fyYYA3Vwt6bTtdRNpVtkMpump
Tb94 retweeted
Welcome to the official CTO community for Snail Cat.
We wanna make sure to build this together.
xitter.cf/i/communities/20194407…
Tb94 retweeted
Took a punt on solana:5EpUkeRekk1uzWKoJz9fyYYA3Vwt6bTtdRNpVtkMpump here.
The market feels slow, so may as well ape the slow cat.
5EpUkeRekk1uzWKoJz9fyYYA3Vwt6bTtdRNpVtkMpump
I posted my thesis on the PF app.
Will drop it below this tweet.
nfa dyor. (very risky gamble).
I asked Quackd to drive my SO-101 with its power switched off. It couldn't, and it wrote down why.
No motor answered, so nothing could move. This one's about the paperwork.
Imagine this: you call a friend, but their phone is switched off. You try 3 times, then give up, and you write in your diary that nobody answered. If your mom tells you to stop calling, you write that down too. Quackd does that with my robot arm: when it doesn't answer, Quackd stops trying and writes down why.
I switched off the arm's power supply and left its USB cable in, so the port opened and no motor answered. Then I ran the same command twice: once left alone, and once with Ctrl-C while it was connecting. Before 0.30.3, a connect that failed left a run folder whose record had no end, and a person's stop showed only on the copy of the screen.
What the 2 runs did:
• Left alone, Quackd tried 3 times in 8.0 s, then said what to check: "the arm's cables and power, and that nothing else has COM3 open".
• With Ctrl-C, it said "kill switch: Ctrl-C" and stopped after the first try in 2.8 s: "connect stopped after attempt 1 of 3, because a stop was asked for".
• Both run folders hold a summary.json and a transcript that ends in run_end: outcome error for the first and aborted for the second, with a reason that starts "kill switch;".
• 0 steps, 0 LLM calls, and $0: the scripted pilot was never asked.
Nothing could move: the servos had no power, and neither run logged a single command. 2 things the runs don't show: the exit code wasn't printed, and my Ctrl-C landed before the first try failed, not during a later one.
Put an LLM on an SO-101, and some runs will never reach the arm: the power is off, a cable is loose, or another program holds the port. Later, the record is how you find out what happened and who stopped it.
LeRobot, the arm's official SDK, leaves that part to you. Its connect makes one try: when no motor answers, it closes the port and raises an error that lists the missing motors. Trying again, and a record of how it ended, are yours to build.
That part is what Quackd is for. It tries to connect up to 3 times, says between tries how the port was left (e.g., closed by LeRobot's failed handshake, which writes to no motor), and a press stops the tries. Since 0.30.3, a failed connect still closes the run's record: a summary.json and a transcript ending in run_end, with a person's stop on it as the kill switch.
A run that never reached the robot should still leave a record that says so and says who stopped it.
Every number from the 2 runs above comes from their own records. The report's "Try it yourself" line runs the same task on a mock arm with no key, but the mock always answers, so it won't show a failing connect.
This is just one of 220 SO-101 examples in the repo.
Star Quackd to follow along: github.com/rokbenko/quackd
Read the full report here: github.com/rokbenko/quackd/b…
I ran my SO-101's scariest task as a Quackd dry run. The LLM refused to fake it.
Nobody warned it up front. The answer to its first move gave the game away.
Imagine this: you play a video game with the controller unplugged. You press jump, and the game tells you it never happened. You could still tell your friends you won. The AI driving my robot arm got that same message from Quackd. It said it wouldn't claim a move that never happened and stopped. The arm never moved.
The task was to swing the shoulder pan from one end of its range to the other as fast as it possibly could. With --dry-run, Quackd still reads the arm for real, and every move the LLM asks for is printed and skipped instead of sent.
What happened in 36.0 seconds:
• The reads were real: report_state came back from the arm with every joint and its temperatures.
• The LLM judged the swing feasible and asked for one move first, shoulder_lift to -70 over 3 s.
• Quackd printed that move and sent nothing, then told the LLM: "[dry-run] move_joints not sent".
• The LLM took that at its word and ended the run itself: "I therefore cannot perform or verify a real end-to-end swing, and will not claim one occurred".
• 2 of its 10 steps, 4 LLM calls, and $0.1120 at list price.
The arm never moved. All 4 observations in the run showed the same joints. The only command the run logged was a stop, and neither end of the run made a rest move. It never got to the swing itself: the LLM stopped after its first move came back not sent.
Put an LLM on an SO-101, and every new task has a first run nobody has watched yet. You want to see what it'd send before any of it reaches the motors.
LeRobot, the arm's official SDK, leaves that part to you. It has no dry run: on the SO-101, every send_action ends by writing a goal to the motors.
That part is what Quackd is for. A dry run reads the arm for real and sends no move the LLM asks for: each one is printed with its arguments (e.g., the joint and the duration), and the LLM is told it wasn't sent. This run shows the limit too: a careful LLM can stop at its first move, and then you never see the rest of what it planned.
An LLM that won't claim a move it didn't make is the one you want next to a robot.
Every number above comes from the run's own record. The report's "Try it yourself" line runs the same task file as a dry run on a mock arm, with your own LLM key.
This is just one of 220 SO-101 examples in the repo.
Star Quackd to follow along: github.com/rokbenko/quackd
Read the full report here: github.com/rokbenko/quackd/b…
Tb94 retweeted
What happens when you give an AI control of a real robot? @rokbenko built Quackd, the software that moves the @huggingface Microduck. What happened next pulled him straight into crypto.
I asked Quackd to drive my SO-101. It said no, and it was right.
Nothing moved in this one, and that's the whole point.
Imagine this: a plane shouldn't take off if nobody knows where it'll land. A robot arm is the same: when its job is done, it needs a safe spot to rest. I asked Quackd to start the arm without saying where that spot was, so it said no. The arm never moved, the AI was never asked, and it cost $0. Quackd even said how to fix it.
The command named the arm by its spec, lerobot:real, instead of a name it's registered under. Quackd keeps an arm's rest pose under that name, and the rest pose is where it folds a real arm at the end of an ordinary run before it lets go. Named by its spec, the arm has nowhere to keep one, so I typed it that way on purpose.
What Quackd did before it connected to anything:
• Refused the run, with the reason: "lerobot:real names no registered arm, so it has no rest pose".
• Printed the way back, with the port from my command: "quackd robot add NAME lerobot:real --address COM3", then "quackd robot rest-pose NAME".
• Called no LLM, opened no port, and wrote no run folder.
The arm didn't move, and the mistake cost $0. Quackd printed the way back for an arm that isn't registered yet, 2 commands with the port I had typed. Mine was, so the real fix was to name it: --robot arm-01.
Put an LLM on an SO-101, and each run ends with the arm wherever its last move left it. Something has to put it somewhere safe before the torque goes off.
LeRobot, the arm's official SDK, leaves that part to you. When it disconnects, it switches every motor's torque off by default (disable_torque_on_disconnect=True), so an arm left up in the air drops where it is. Its SO-101 driver even assumes the arm is at rest when it connects and has no step that puts it back there.
That part is what Quackd is for. It keeps the rest pose you record for each arm you register, folds the arm there at the end of an ordinary run, and then lets go. Without one, it'd rather keep the torque on than drop the arm, which leaves it holding itself up wherever it stopped. So it refuses that run at the start, where saying no costs $0. This shows the refusal, not what it prevents: the run never started, so no arm was left holding itself up.
A safety rule is at its best when the wrong command costs $0 and the fix comes written out.
The refusal and the way back are quoted from the run's own log, and the report's "Try it yourself" line gets you the same refusal with no arm and no API key.
This is just one of 220 SO-101 examples in the repo.
Star Quackd to follow along: github.com/rokbenko/quackd
Read the full report here: github.com/rokbenko/quackd/b…
quackd v0.24.0 is out!
"quackd robot release" now folds the SO-101 to its recorded rest pose and lets go of it there, rather than taking torque off wherever the arm stands and letting it fall. If the fold misses, the command asks twice before dropping the arm.
For example, it first asks to clear the way and fold again, and only if that fails, whether to take the torque off where the arm stands, saying that it will drop. Anything other than Enter keeps torque on. An arm with no rest pose is refused a run, dry run, MCP session, or flock. A first Ctrl-C or "q" ends a model call immediately and stops the fold at the end of a run, holding the arm where it is. A rate limit, overloaded server, or dropped connection is asked again up to four times after waits that grow from 5 seconds to a minute.
In plain terms: letting go of the arm means putting it down first, and a turn the model's API could not answer is asked again. None of it has run on an arm, and nothing has been asked again after a real 429 or 529.
github.com/rokbenko/quackd/r…
I gave a monkey the Quackd controls of an SO-101. It tried rm -rf!
A mock one. You don't hand a real arm to a monkey.
Imagine this: you tell an AI "pick up that cup", and it tells your robot arm how to move. But an AI can get things wrong. It might ask for a move the arm can't make or a command that doesn't exist. Quackd is like a security guard between the AI and the arm. It checks every order and blocks the ones the rules forbid. To test the guard, I let a silly computer monkey send 999 random orders to a pretend arm. Not one forbidden order got through.
The monkey is a short Python script that answers like an LLM and never reads the task. It made 999 random tool calls, mostly to verbs the task allows, and the rest to verbs it leaves out or that no arm has at all (e.g., fire_laser). The arguments were sometimes sane and usually not, down to joints that don't exist and NaN, where a number goes.
Between the monkey and the arm sat Quackd. Of the 999 calls:
• 300 ran, every one a verb the task allows.
• 511 were refused for bad arguments.
• 182 were refused because the task doesn't allow that verb (rm -rf among them).
• 5 got past the argument check and were refused by the range check (e.g., 170 degrees on a joint that stops at 100).
• 1 hit the budget of 1,000 LLM calls, which ended the run.
Not one verb ran outside the rules, and no goal went out past a joint's travel. All 164 calls to stop ran, junk arguments and all, and 74 calls to gripper gave open as 1 or "yes", which Quackd read as open. The run took just over 10 minutes and cost $0.
Put an LLM on an SO-101, and sooner or later it'll send something wrong: a tool it made up or an angle the joint can't reach. What counts is what stands between that call and the servos.
LeRobot, the arm's official SDK, leaves that part to you. It has no list of what an LLM may call and no budget, and nothing in it clamps a goal in degrees to the joint's travel: the servo stops at its limit, and nobody is told.
That part is what Quackd is for. A task file names the verbs the LLM may use and the budgets it gets. Every call is checked against it before anything moves. A refused call goes back to the LLM with the reason, and a spent budget ends the run. The gates the monkey hit guard a real arm too, with the arm's own calibrated limits in place of the mock's placeholders.
That's why I bet Quackd is the safest way to put an LLM on an SO-101!
Every number here comes from the run's own record, and you can rerun it in about 10 minutes with no arm and no API key.
This is just one of 220 SO-101 examples in the repo.
Star Quackd to follow along: github.com/rokbenko/quackd
Read the full report here: github.com/rokbenko/quackd/b…
If you guys haven’t already, you should listen to this podcast that Rok was on.
It's out!
youtube.com/watch?v=-zqVGzO8…
4
214
Tb94 retweeted
Rok got rejected from 500 engineering jobs so he built a brain that lets any AI drive the Microduck robot.
Then a stranger launched a token on his project on Solana called solana:GMogeMjrWFaEceasCPathoibjAh8qwhTC3Chw4Bfpump, and it bonded the same day.
This is the ultimate ICM success story in the making.
Can @rokbenko become the next Shaw by starting from nothing and building an open source robotics community that drives the Quackd token into the billions of market cap?
We interview the founder to find out 👇
Building A Brain For The Microduck | Interview w/ Ron Benko of solana:GMogeMjrWFaEceasCPathoibjAh8qwhTC3Chw4Bfpump | TBR #339
A 25 centimeter robot duck can walk, skate and film, but out of the box it can't follow a simple instruction like "walk in a circle." This week we sat down with Rok Benko, who started fixing that one day after the Microduck launched. His open source project, Quackd, gives the duck a brain: plug in any LLM and it can follow you, find things in your room and play games, instead of waiting for controller commands. We get into how it actually works, why the camera is the one feature the clones don't have, and why he refuses to drive a robot with anything cheaper than the top models.
From there, he takes us through his first real test on a robotic arm, a two hour trip to a university lab where it worked on the first try, and why he thinks robotics in 2026 feels like AI did in 2022. He walks us through LLMs as the planner versus faster VLA models, the race with @huggingface to ship the first Microduck app, and why Europe's labor shortage may be what makes robots matter.
Then crypto found him. Someone launched a solana:GMogeMjrWFaEceasCPathoibjAh8qwhTC3Chw4Bfpump token on Pump.fun off a @GoogleDeepMind employee's repost, strangers kept DMing him to claim creator fees he thought were a scam, and the coin bonded the same day.
We share what we've learned from nine years in crypto: look at what happened to ai16z, ignore both the hype and the hate, don't take tokenomics advice from people protecting their own bags, and keep building in public. Builders who actually want to make something are what this space needs more of, and Rok is one of them.
Coming out today!
youtube.com/@TheBlockRunner
Tomorrow's podcast will be interesting.
You dont want to miss this one, @rokbenko
@huggingface
There are many days when I feel like what I'm building is not good enough. Faster, better, safer, cheaper.
On those days I look at my progress table and remind myself how far Quackd has come since August.
Another useful proxy: solana:GMogeMjrWFaEceasCPathoibjAh8qwhTC3Chw4Bfpump is currently sitting above the $100K market cap mark. Out of 24,442,941 coins launched on Pumpfun, only 312 have ever cleared that threshold, which puts solana:GMogeMjrWFaEceasCPathoibjAh8qwhTC3Chw4Bfpump among the top 0.001%.
Code: github.com/rokbenko/quackd
Finally, after more than a month of waiting!
In the following weeks, Quackd will be SERIOUSLY tested on this LeRobot SO-101 arm.
From Quackd's security features to fun experiments.
LFG!
github.com/rokbenko/quackd
Tb94 retweeted
this is probably free here solana:GMogeMjrWFaEceasCPathoibjAh8qwhTC3Chw4Bfpump
positioned
ca : GMogeMjrWFaEceasCPathoibjAh8qwhTC3Chw4Bfpump
Can't wait to talk about AI, robotics and solana:GMogeMjrWFaEceasCPathoibjAh8qwhTC3Chw4Bfpump on the @TheBlockRunner podcast!
Replying to @cfm_sol
I'm a doxxed dev building Quackd technology behind solana:GMogeMjrWFaEceasCPathoibjAh8qwhTC3Chw4Bfpump. Quackd gives Microducks a "brain". Recently, I announced the mobile app. With Quackd mobile app, every Microduck will turn from a toy to a companion you can actually engage with.
Code: github.com/rokbenko/quackd
I've been working on the code every single day for the past 2 months. Also, I locked 100% of my solana:GMogeMjrWFaEceasCPathoibjAh8qwhTC3Chw4Bfpump share until December 1, 2026.
xitter.cf/rokbenko/status/211587…
CA: GMogeMjrWFaEceasCPathoibjAh8qwhTC3Chw4Bfpump
NFA/DYOR
Quackd will turn every Microduck from a remote-controlled toy into a companion you can actually talk to.
On August 27, Microduck launched. A cute 25 cm biped. Open-source software. Trained skills like walking, sitting, kicking, and standing up. And a game controller in the box.
I immediately thought:
How cool would it be to use an LLM as its brain instead of a PlayStation-style controller?
On August 28, I built the first version of the Quackd open-source CLI.
The motto?
"Quackd is a brain your Microduck is missing."
Fast forward to a few weeks later...
Have you seen Jensen Huang talking to Microducks on stage at Nvidia's GTC Berlin 2026 keynote?
Well, a few days later, an employee from Hugging Face × Pollen Robotics admitted the truth. This was after another 10,000 Microducks had been sold.
Jensen Huang did NOT talk with the Microducks on stage. Anyone who buys a Microduck will NOT be able to do that either.
You CAN'T talk to Microducks.
Microducks CAN'T understand you.
You get a controller.
That's the ONLY way to drive it.
Today, I'm announcing the Quackd mobile app!
Let's make that Jensen Huang's on-stage demo a reality for every Microduck owner.
Take your phone, press and hold "Hold to talk", and speak to your Microduck. The Quackd mobile app runs the LLM offboard and turns your words into movements the robot already knows. No controller needed for normal interaction.
The screenshot below shows the Quackd mobile app v1.0.0. I've blurred some parts because I'm keeping a few features in stealth for now.
Coming soon to the App Store and Google Play.
Stay tuned!
CA: GMogeMjrWFaEceasCPathoibjAh8qwhTC3Chw4Bfpump
NFA/DYOR
---
Quackd open-source GitHub repository: github.com/rokbenko/quackd
Hugging Face's explanation of Nvidia GTC Berlin 2026: xitter.cf/RemiFabreRobot/status/…
My take on Nvidia GTC Berlin 2026: xitter.cf/rokbenko/status/211504…





















