hckrnws

This is a great example of how silly this whole thing is. There’s next to nothing to these claws. Turns out that if you give an llm the ability to call APIs they will.

What’s most shocking to me about the whole OpenClaw hype is how little people in tech seem to know about computers…

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

If it turns out that there is significant value in everyone having their own personal agent running 24/7, we might end up needing a lot more compute than anticipated.

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

I am using a claw. I am not ready to give it access to much but web and cron plus a chat channel is useful and feels more light touch than typical AI sessions and UIs

Wow, the rare

  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 $_

If you want to be super pedantic, try to make the command shell-agnostic in case the user is not running bash already.

"LLM backends: Anthropic, OpenAI, OpenRouter."

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

Sure. Why purchase a H200 if you can go with an ESP32 ^^

Blowing more than 800kb on essentially an http api wrapper is actually kinda bad. The original Doom binary was 700kb and had vastly more complexity. This is in C after all, so by stripping out nonessential stuff and using the right compiler options, I'd expect something like this to come in under 100kb.

Doom had the benefit of an OS that included a lot of low-level bits like a net stack. This doesn’t! That 800kB includes everything it would need from an OS too.

yah my back of the envelope math..

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

WiFi is 350 Tls is 120 and certs are 90!

> vastly more complexity.

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.

yeah i sandbagged the size just a little to start (small enough to fit on the c3, 888 picked for good luck & prosperity; I even have a build that pads to get 888 exactly), so i can now try reduce some of it as an exercise etc.

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

haha well I got something ridiculous coming soon for zclaw that will kinda work on board.. will require the S3 variant tho, needs a little more memory. Training it later today.

right, 888 kB would be impossible for local inference

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

It's not completely impossible, depending on what your expectations are. That language model that was built out of redstone in minecraft had... looks like 5 million parameters. And it could do mostly coherent sentences.

  > built out of redstone in minecraft

  > 5 million parameters

I have a couple ESP32 with a very small OLED display, I'm now thinking I could make an "intelligent" version of the Tamagotchi with this. Do you HN crowd have other cool ideas?

That would be sweet. That the supermini type with the 0.46” display? Those are fun for lots of things.

Relevant: https://github.com/sipeed/picoclaw

Genuinely curious - did you use a coding agent for most of this or does this level if performance take hand written code?

An esp32 image that makes http api calls is like, the first thing you do with an esp32, it's what they're made for

Rust just called. They want their lobster back.

That's a crab. Get your crustaceans straight!

Thanks for looking out for us.

Really looking for a minimal assistant that works with _locally hosted models_. Are there any options?

Depends what you mean.

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.

It really depends on what resources you have qwen-code-next will run them but you will need at least 64gb of memory to run it at a reasonable quant and context.

Most of these agents support OpenAI/anthropic compatible endpoints.

Why are you looking? Just build one for yourself.

The bottleneck here is usually the locally hosted model, not the the assistant harness. You can take any off the shelf assistant and point the model URL at localhost, but if your local model doesn't have enough post training and fine tuning on agentic data, then it will not work. The AI Assistant/OpenClaw is just calling APIs in a for loop hooked up to a cron job.

Exactly. OpenClaw is good, but expects the model to behave in a certain way, and I've found that the local options aren't smart enough to keep up.

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)

My new DIY laptop has 400GB RAM accessible and it runs only esp32*

____

* Requires external ram subscription

Is there a heartbeat alternative? I feel like this is the magic behind OpenClaw and what gives it the "self-driven" feel.

I think you can use C++ on esp32, that would make the code more readable

Serious question: why? What are the use cases and workflows?

The various *claws are just a pipe between LLM APIs and a bunch of other API/CLIs. Like you can have it listen via telegram or Whatsapp for a prompt you send. Like to generate some email or social post, which it sends to the LLM API. Get back a tool call that claw then makes to hit your email or social API. You could have it regularly poll for new emails or posts, generate a reply via some prompt, and send the reply.

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.

I’m running my own api/LLM bridge (claw thing) on a raspberry pi right now. I was struggling to understand why all the Mac mini hype when nobody is doing local inference. I just use a hook that listens for email. Email is especially nice because all the conversation/thread history tracking is built in to email already.

yeah i still can't believe many people bought a mac mini just for the claw hype

I don't fully get it either. At least agents build stuff, claws just run around pretending to be alive?

They do build things. The same things.

for fun!

I don't really need any assistance...

Me neither.

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

desk rover - https://www.huyvector.org/diy-cute-desk-robot-mo-chan

a kid-pleaser at the very least

Build a synthesizer

Why do you have so many? eWaste..

I need 1, but they come in packs of 10.

No, no, but we insist!

This is absolutely glorious. We used to talk about "smart devices" and IoT… I would be so curious to see what would happen if these connected devices had a bit more agency and communicative power. It's easy to imagine the downsides, and I don't want my email to be managed from an ESP23 device, but what else could this unlock?

A highly opinionated thermostat?

Or how about a robot vacuum that knows not to turn on during important Zoom calls? Or a fridge that Slacks you when the defroster seems to be acting up?