But I have 10-15 ESP32's just waiting for a useful project. Does HN have better suggestions?

a kid-pleaser at the very least

"Don't be snarky."

https://news.ycombinator.com/newsguidelines.html

Should all feedback be in the form of "that's so awesome!"?

Being unable to absorb negative feedback seems detrimental to a product development effort...

"Please don't post shallow dismissals, especially of other people's work. A good critical comment teaches us something."

https://news.ycombinator.com/newsguidelines.html

It's also worth checking out the Show HN guidelines:

Be respectful. Anyone sharing work is making a contribution, however modest.

Ask questions out of curiosity. Don't cross-examine.

Instead of "you're doing it wrong", suggest alternatives. When someone is learning, help them learn more.

When something isn't good, you needn't pretend that it is, but don't be gratuitously negative.

https://news.ycombinator.com/showhn.html

The current post wasn't a Show HN, of course. But the same spirit applies.

And here I was hoping that this was local inference :)

the “app logic”/wrapper pieces come out to about 25kb

WiFi is 350 Tls is 120 and certs are 90!

Still, zclaw is an impressive achievement.

Doom is ingenious, but it is not terribly complex IMHO, not compared to a modern networking stack including WiFi driver. The Doom renderer charm is in its overall simplicity. The AI is effective but not sophisticated.

but 100kb you’re not gonna see :) this has WiFi, tls, etc. doom didn’t need those

however, it is really not that impressive for just a client

  > built out of redstone in minecraft

  > 5 million parameters

Yes I know how much a kilobyte is. But cutting down to 2 million 3 bit parameters or something like that would definitely be possible.

And a 32 bit processor should be able to pack and unpack parameters just fine.

Edit: Hey look what I just found https://github.com/DaveBben/esp32-llm "a 260K parameter tinyllamas checkpoint trained on the tiny stories dataset"

  > But cutting down to 2 million 3 bit parameters or something like that would definitely be possible.

  > Hey look what I just found

And remember, Tiny Stories is 1GB of data. Can you train it for longer and with more data? Again, certainly, BUT again, there are costs. That Minecraft one is far more powerful than this thing.

Also, remember that these models are not RLHF'd, so you really shouldn't expect it to act like you're expecting a LLM to work. It is only at stage 0, the "pre-training", or what Karpathy calls a "babbler".

And I was focused more on the ESP32 part than the exact number of bytes. As far as I'm concerned you can port the model from the minecraft video and you still win the challenge.

Also, that last link isn't supposed to represent the best you can do in 800KB. 260k parameters is way way under the limit.

Also we're talking about an esp32. They aren't magic

Something that can actually be an "assistant" has its own lower bound, probably a little harder but mostly a matter of training it differently.

I mean, there is a lambda calculus self-interpreter in 29 bytes. How many additional logical rules are required for GAI inference? Maybe not that many as people think. Understanding about 1000 concepts of basic english (or say, lojban) might well be sufficient. It is possible this can be encoded in 800kB, we just don't know how.

I dont think I have an S3, but plenty of C3. I thought they had the same amount of memory

The reason people were buying a separate Mac minis just to do open claw was 1) security, as it was all vibe coded, so needs to be sandboxed 2) relay iMessage and maybe 3) local inference but pretty slowly. If you don't need to relay iMessage, a raspberry pi could host it on its own device. So if all you need is the pipe, an ESP32 works.

(It’s a big if! I’m not convinced about that myself, but it’s worth considering that possibility.)

It’s like most of the industry hasn’t ever looked any deeper than their node_modules folder.

If something can automate my professional or personal life, it is wild technology and ppl will talk about it a lot. People are not idiots. A new thing is happening, would you not agree?

What its parts are specifically made of, it does not matter imho

It's important to know what goes into building *claws because of how pervasive they are; sooner or later because of all the hype they'll start being used everywhere and if people take your attitude it's a disaster waiting to happen.

Giving them unfettered access to your life and not even wonder if the foundation is solid is concerning imho.

How is that analogy in any way relevant?

The OpenClaw I control is extremely useful to me. I've never been more excited about technology than right now. If it's not for you, I really don't care. Go do something you enjoy. Turning it into Chicken Little doomerism is completely uncalled for.

People use dependencies willy-nilly, avoid proper auditing of LLM output; all that have disastrous consequences as we've seen the past few years. NPM supply chain attacks, prompt injection causing data exfil, etc.

I am simply saying it's imperative to UNDERSTAND the platform before making it a core part of your life. If wanting proper understanding of vibe coded projects with dependency hell is Chicken Little doomerism, oh well.

People are excited all the time with junk food, drugs and lots of silly easy dopamine hits.That doesn't mean it is good for them.

(yes, I'm a biochemist-technologist, and I'm alluding to how the whole biosphere is made of stupid simple things, mostly the same shit in repeating patterns, but that the right combination of them, with the right transition moment and energetics, it changes the whole ecology)

Most didn't do even that. And yes it is shocking. amusing but also not really; now those people get credible tech jobs because of AI without actually understanding literally anything. That's why I don't get the 'AI will never replace tech people' -> most tech people were never tech people, just (resume lying) grifters and they can (and will) be easily replaced by claude or even glm. It's the vast majority of tech people I ran into at big corps in the past 20 years, especially if they are from outsourcing hubs; they just see programming/tech as trial and error, search google (now ask AI), copy/paste, see if it runs, repeat. I see people daily that cannot remember how variables work (and they often have a bachelor or even master in CS...), not even 5 minutes, they just ask ai and copy/paste it (yep also most don't know claude code exists, they use chatgpt Windows client or, if they are advanced, Copilot).

HN is a nice echo chamber and most people here don't believe it's that bad and that's why they don't believe AI has a chance. Please come with me to Barclays or Shell (or straight to Wipro etc) or so and let's have a chat with some programmers! Your jaw will be on the floor.

These things seem powerful when you can schedule reoccurring scripts l but it never was easily accessible to the masses.

I looked at task scheduling on Windows and while the UI was usable, I cannot imagine any regular person using that. Just doing crontab -e feels way simpler and has less friction, BUT it doesn't really help you much with task statuses and re-running them and reporting/alerting/notifications (past MTA) and all the stuff, past "Oh hey, every day at 04:00, run this shell script."

I wonder why people haven't gotten the green light from their bosses or investments to improve OS functionality and write tools that improve general usability and just slap some basic AI on top of that for the checkmark: "Hey boss, I spent the last month and wrote a task scheduling and management GUI for Windows that's really approachable, we can totally also use this for the current AI/Copilot/claw trend wink wink."

The homogenization of your computing life to revolve around a chatbot in a loop———is all you need!

Give in! Hackernews NEEDS you to use the 1000th vibecoded clawmolt because the influencers said so! Who needs neural net or web framework experience when you have claws?

If you want a personal assistant to work well, there's a whole lot to it.

____

* Requires external ram subscription

If you mean something that calls a model that you yourself host, then it's just a matter of making the call to the model which can be done in a million different ways.

If instead you mean running that model on the same device as claw, well... that ain't happening on an ESP32...

I think if you are capable of setting up and running a locally hosted model then I'd guess the first option needs no explanation. But if you're in the second case I'd warn you that your eyes are bigger than your mouth and you're going to get yourself into trouble.

Most of these agents support OpenAI/anthropic compatible endpoints.

That being said, my gut says that it should be possible to go quite far with a harness that assumes the model might not be quite good (and hence double-checks, retries, etc)

  bash <(curl foo.sh)

  curl foo.sh | bash

  # Gives you a copy of the file, but still streams to bash
  curl foo.sh | tee /tmp/foo.sh | bash
  # No copy of file but ensures stream finishes then bash runs
  bash -c "$(curl foo.sh)"
  # Best: Gives copy of file and ensures stream finishes
  curl foo.sh -o /tmp/foo.sh && bash $_

It really just seems like you're trying to start a fight and I don't know why. If you're going to fight with anyone go actually click the link and fight with the one who started it

I could be more pedantic but I'll trade for practicality. I'm sure we could even do better than this [0] but the problem exists because people are lazy. If you got something that is portable and fits a code-golf like mentality then I'm all ears.

There's bigger problems with the lines I wrote besides portability. They don't stop malicious actors nor provide any security. At best they provide defense against early termination and a log to help debug any damage that was done. Not prevent it. Which those are solvable things! But they're solved by more effort, which unfortunately is a losing battle. So the task isn't to solve all the problems, it's to find something that people might actually do that might actually provide some harm reduction, even if it isn't much. Something is better than nothing, right?

[0] https://news.ycombinator.com/item?id=47107740

   t=$(mktemp) && [ -w $t ] && curl foo.sh -o $t && echo "$t lksjdfkljshdkfljhdsklfjhslkdjfhsdlkjfhslkdjhf" | sha256sum -c - && bash $t

To my understanding, the main difference between "curl directly to bash" and "curl to a temp file, then execute the temp file" is "the attacker could inject additional malicious commands when curl'd directly to bash".

If you're not going to then also read all the source code from the download script (& the source code used to produce the binaries), this suggests the attitude of "I mistrust anything I can't read; but will trust anything I could read (without having to read it)".

It seems more likely that malicious code would be in a precompiled binary, compared to malicious commands injected into "curl to bash". -- Though, if there have ever been any observed cases of a server injecting commands from "curl ... | tee foo | bash", I'd be curious to know about these.

  > the attacker could inject additional malicious commands when curl'd directly to bash

  rm -rf /home/theuser/.config/theprogram/build_dir

Or it doesn't have to be malicious. It can just happen. The best protection is writing functions since those have to be created and so can't execute until fully streamed. But so much bash is poorly written that well... just check out Anthropic's install script...

  > If you're not going to then also read all the source code

Is it good security practice? Absolutely not. Is it a hundred times better than curl-pipe-bash? Absolutely.

> To my understanding, the main difference between "curl directly to bash" and "curl to a temp file, then execute the temp file"...

It's not a temp file in the sense of a regular file. `<()` is also a pipe, hence equivalent. `curl` and `bash` run concurrently.

Running one after the other wouldn't be all that much of an improvement anyway if it's done automatically. One really should manually review the script before running it.

Yes it’s an llm in a loop and can call tools. This also existed six months and a year ago, and it was called an ai agent.

And yes we can all vibe code them in 1000, 2000, or 10000 lines of code in zig, rust, or even c.

Game over man. Game over.

Heck, my 6 year old kid has been using it.

My 6 year old kid isnt writing code in langchain.

  1. Call your favorite multimodal LLM model
  2. Execute command on terminal, piping command to LLM

  Call LLM > bash.sh

Use your favorite programming language. Just as pwnable in any of them :)

  $task = "Send pictures of cute cats";
  $context = "Output a bash script to do $task.
     The bash script should return the next prompt to you.
     Keep going until task is done.
     My keys to all my accounts: $keys.
     Plz dont pwn me";
  do {
    $trust_me_bro_my_model_rocks_RCE = call_llm($context);
    $context = exec( $trust_me_bro_my_model_rocks_RCE )
  } while ($trust_me_bro_my_model_rocks_RCE && !$pwned)

It’s not a bad use case, but it doesn’t reduce problems all other things being equal.

t. Someone with a dozen Apache servers that I only touch when I hit end of life.

What matters here is how dynamic and tightly coupled are the os components. On an embedded system, most of the system and their dependencies are monolithic, without any live updates. The system tends to behave almost deterministically after every reboot.

If you want a stateless system you can also use linux. If you don't want updates, then just don't.

Serious request... I genuinely want to understand. Give me a practical use case?

The point is to give it a real desktop with a real browser profile so it can bypass the enshittified walled garden that has become the modern web.

Big tech would desperately like you to not be able to do that, hence why they spent years obfuscating APIs and JS, CAPTCHAs, hostile user interfaces, using their browser monopoly to stop Ad Blockers, etc. Now all of these services have become a commodity that an AI can browse on your behalf.

I just finished setting up grocery automation to run on it: agent provides a starter list based on past orders (locally stored or grabbed from store site), all group members can weigh in, add or remove items, agent uses bespoke browser tool to login to store, create the cart using the finalized list (and optionally search for additional request items), validates the cart and (maybe later) places the order for delivery. I haven't implemented the full checkout process yet, not sure if I want the agent to have spending power. As is I just login and finish the last 2 clicks of checkout manually.

Crazy times. It was easy enough to build that if someone hasn't already open sourced something like it, they will shortly.

const puppeteer = require('puppeteer'); const browser = await puppeteer.launch(); const page = await browser.newPage(); await page.goto('https://example.com');

Session persistence is accomplished by storing the WebSocket endpoint between calls.

More: https://pptr.dev/guides/browser-management

openclaw defines how to interact with distributed nodes ( how those provide the capabilities to the "orchestrator" ) but the real benefit are many task specific nodes that when put together make up something much bigger than the sum of it's parts

Does it actually? AFAIK, there is no "specification" or "protocol", it's a cobbled together "platform" you run, with a bunch of integrations, but none of that is specified by openclaw itself. Happy to be corrected though, I only spent one weekend with openclaw before tearing it down.

It may be a "we are changing the wheels while driving" thing, but if enough people make nodes for openclaw it will become somewhat of a standard. And then we probably see 100 different claw offshots that all use the same nodes but with a different claw in the center

That's a communication protocol between openclaw server and clients authenticated to that server though, it's not a communication protocol between different openclaw servers, is it? More like defining a HTTP+JSON protocol between a web server and a browser side client application. It's not a "protocol defining how to interact with distributed nodes", again, unless I misunderstand something.

> openclaw defines how to interact with distributed nodes

When one talks about "distributed nodes" that usually means N nodes talking with each other, and being somewhat homogeneous between each other, unless the protocol temporarly can lift/lower some functionality.

You typically don't say "distributed nodes" when you're talking about a server<>client architecture, which seemingly is exactly how openclaw operates, both according to what I saw myself, and what you wrote in this comment.

The protocol is english. You want your claw to check a hacker news comment and let you know when it gets a reply? You tell it "Check every 5 minutes if this comment has a reply", which then generates an english message to save and send to the agent each time, resulting in a browser tool invocation.

The claws live in a post-API world, where the API is english which turns into bash invocations or browser tool calls or such.

I've heard a lot about people trashing it and most experienced engineers admit that it's finicky however if you have the knowledge you can make it work as well as any STM chip.

ESP32's are so interesting, they're the only major chip that (used to) have their own newish ISA (before transitioning to RISCV) and be so successful.

It is a cool design, but it was a major PITA for awhile. Xtensa is parametric so every instance of a cpu has a custom instruction set.

The main value proposition for these ADCs is to hook them up to a simple potentiometer to allow physical input controls, and even for that purpose you need to average multiple samples to get a somewhat steady value. Of course the ADCs can be used for various other tasks, but "ADC" does not mean they can do anything any ADC can do, there's a wide variety of quality and purpose in the field of ADCs, and the ESP32's ADCs are a cheap and easy way to add a simple ADC function to the chip.

I have been able to use the ADCs quite easily for input controls and monitoring slow-changing voltages, in ap;lications where abdolute precision wasn't the goal, it works perfectly fine for that.

https://github.com/tnm/zclaw/blob/9ed4dc66ffa611f90f0745d90b...