zclaw: personal AI assistant in under 888 KB, running on an ESP32
github.com275 points by tosh 2 days ago
275 points by tosh 2 days ago
The interesting thing about running a claw on an ESP32 is not the compute - it's the always-on, zero-maintenance aspect. I run automation pipelines on a Linux box and the biggest operational headache isn't the AI logic, it's keeping the host alive, updated, and dealing with OOM kills. An ESP32 that just proxies to cloud APIs and handles tool orchestration locally is actually a more reliable deployment target than a full OS for simple agentic loops. The failure modes are simpler and more predictable.
exactly this. microcontrollers are essentially self-healing hosts -- no package manager, no kernel upgrades, no cgroup misconfiguration. when the thing resets it comes back in a known state. compare that to a linux box where "it was fine until a routine apt upgrade" is basically a cron job for debugging sessions.
You could also swap to an distro where apt ugprade can't brick things, and where if you manually mess up you can rollback cough cough nixos cough cough
fair, nixos is the exception where that actually holds. but most shops are running ubuntu lts or rhel, where 'just use nixos' is about as practical as recommending everyone rewrite in haskell. for those the microcontroller argument still stands.
Couldn't you make it just as simple with Linux? You are just doing more.
t. Someone with a dozen Apache servers that I only touch when I hit end of life.
Linux is not a realtime OS, so it is never going to be as reliable as bare metal code on MCU.
It has nothing to do with being realtime. Most mcus are also not running any realtime OS.
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.
You’ve just added more points of failure. Now the cloud machine can go down, your internet could drop, your wireless could fail or a variety of other problems.
It’s not a bad use case, but it doesn’t reduce problems all other things being equal.
Sorry for being dense—does this include a tiny LLM to power the agent? Or is it just a wrapper that needs to be connected to the internet?
Wrapper. Uses OpenAI by default:
https://github.com/tnm/zclaw/blob/9ed4dc66ffa611f90f0745d90b...
Can someone provide a true engineers perspective on the ADCs' on ESP SoC's?
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.
I'm not too familiar with the ESP32 ADCs except I remember they're unusually lightly specified even for microcontroller ADCs. If "the knowledge" involves things you couldn't do - or rely on - in production like careful calibration and characterization, that would answer your question.
The ESP32 pre-RISCV ISA is from Tensilica, this IP they purchased.
To be clear and towards the OP's comment about ESP32 ISA -- Xtensa isn't really a self contained architecture, it can be customized (extended) by the vendor. The ISA can be extended for these customizations. ESP32 is one customization of it.
The ADCs on the ESP32 are similar to other embedded MCUs in that they are not intended for audiophile-level audio capture, as some people seem to think they should be capable of.
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.
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?
You know I tried this exact thing a few months back, sans the ESP32. You just end up writing a state machine and defining a bunch of constants anyway or the LLM just kinda gets stuck in a loop. Hm, it doesn't seem to know when to eat. I'll add a hunger variable... Etc etc until you're not even sure what you want the LLM to do.
I see. While those "claws" may look cool on the surface, I'm actually struggling to find a use case that is interesting for me. Do you guys have ideas? I already seen below the grocery shopping automation, but I will keep going at the supermarket in person for the foreseeable future.
I played with openclaw for a week and couldn't really find anything interesting to do with it. I'm in the same boat.
That would be sweet. That the supermini type with the 0.46” display? Those are fun for lots of things.
Yes, something like that that I found on Aliexpress: https://a.aliexpress.com/_EH7lHde
I can’t see anything specific in the link, and you probably already solved this… but just fyi, if it’s the same unit I used, and you are using arduino libraries, the library that worked was called one-bit display IIRC, and it basically acted as 1/4 of a ssd1306 64x128 oled, so you had to use x/y pixel offsets.
I'm a simple man; I see ESP32, I upvote
Are there collaborative versions of these *claws today? Like, if an "admin" could self-host one on their home server and the whole family could use it? IIRC, OpenClaw has some version of "profiles" but does it allow, say, couple of family members to collaborate with the bot in a shared chat but each has individual/private chats as well.
I haven't been following the claws but I built something like this recently. Self hosted, runs through signal, supports group chat (with whitelisted accounts).
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.
Can you share the code? Specifically, curious how you did the browser integration. Did you use agent-browser? Something else?
The browser is very straightforward, about 300 lines implementing all of the various actions you'd want an agent to have access to in puppeteer:
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.
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 vacuum cleaner allies with the A/C thermostat using Discord, then declares war on the refrigerator, and finally posts propaganda about it on Facebook.
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?
I’m all for more intelligent cleaning robots. The object avoidance AI is pretty good these days, but some of the navigation algos are just total garbage, unable to deal with trivial anticipatable problems.
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 $_
> Equivalent but just as unsafe.
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.
>> Equivalent but just as unsafe.
> 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.
t=$(mktemp) && [ -w $t ] && curl foo.sh -o $t && echo "$t lksjdfkljshdkfljhdsklfjhslkdjfhsdlkjfhslkdjhf" | sha256sum -c - && bash $t
Sure, but now we're not playing code golf. There's much better commands than the ones I wrote but good luck getting people to run them
Agreed. People would rather have a cute looking command to copy than security or reliability
If you want to be super pedantic, try to make the command shell-agnostic in case the user is not running bash already.
Everything I wrote works in bash and zsh. I think this is going to be fine for the vast majority of people. Tbh, I'm not sure what isn't portable, or at least not portable for everything that the curl-pipe-bash pattern doesn't already work for.
`curl foo.sh | bash` works with any shell as long as bash is installed. `bash <(curl foo.sh)` doesn't work on shells that don't have that process substitution syntax (like fish, and I think nushell)
Okay so doesn't work for fish or dash but who is using those? More importantly, who is using those and doesn't know how to convert?
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'm not sure either but some of those things are bashisms. `<(...)` is a bashism and won't work in some shells. Honestly I ONLY use bash, so it's fine for me, but since you seem to be a pedantic person I thought you should consider trying to solve that puzzle too. Someone might want to copy and paste your command into csh, tcsh, zsh, sh, or ksh. Some of these may support bashisms and some don't. I haven't tried to investigate further either, even to the point of talking to an AI about it, but if you want max nerd cred then you can shoot for it. Keep in mind that csh/tcsh is not entirely POSIX compliant, but it is default on some BSDs.
Fwiw it works in zsh and I believe ksh (haven't checked). There's not many people that run csh, tcsh, sh, ksh, or even fish.
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?
What’s the best lightweight “claw” style agent for Linux? It doesn’t necessarily need containerisation or sandboxing as it would be run on a fresh vps with no access to important data.
If you just want Whatsapp and webchat, I'm hacking https://github.com/rcarmo/piclaw from NanoClaw and my own web front-end (I prefer a simple web app I can access via tailscale)
The more I think about openclaw, the more it seems to be for AI agents what ROS is for robotics.
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
> openclaw defines how to interact with distributed nodes
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.
> AFAIK, there is no "specification" or "protocol"
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 only just started to dive into it from the documentation side of things. They have ( maybe recently? ) started to create this Gateway Protocol https://docs.openclaw.ai/gateway/protocol to connect the stuff together.
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
> They have ( maybe recently? ) started to create this Gateway Protocol https://docs.openclaw.ai/gateway/protocol to connect the stuff together.
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.
Yes, that's why I compared it to ROS. I didn't mean multiple openclaws communicating with each other but openclaw communicating with nodes ( which are self contained programs running on your desktop or phone providing capabilities like webbrowsing to the claw server )
Right, I guess that's why I got confused by:
> 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.
Can't you make a personal AI assistant in a bash loop of two lines?
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)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
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.
All the assistants work with locally hosted models. Home Assistant LLM works with small tuned models to do specific things, and the *Claw stuff works with larger models
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)
"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.
Maybe you’re misremembering or referring to Doom (2016). The original Doom was developed for DOS and id had to build a lot of its own network stack. BSD style socket based networking wasn’t a given in DOS.
Still, zclaw is an impressive achievement.
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.
The whole ESP32 Libraries are kind of bloated. To enable Bluetooth, WiFi or HTTP handling, you need to embed some large libraries
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.
Sounds interesting, please keep us posted.
I dont think I have an S3, but plenty of C3. I thought they had the same amount of memory
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
https://www.youtube.com/watch?v=VaeI9YgE1o8
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".
A reminder that what I said was "not completely impossible, depending on what your expectations are"
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.
That bar has no lower bound though so of course we're talking past one another
Also we're talking about an esp32. They aren't magic
Being able to talk back and forth with coherent sentences has a lower bound, and it's close to the limit of this hardware.
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 disagree, in the future it might be possible. But perhaps not in English, but in some more formal (yet fuzzy) language with some basic epistemology.
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.
Rust just called. They want their lobster back.
Is there a heartbeat alternative? I feel like this is the magic behind OpenClaw and what gives it the "self-driven" feel.
I don't understand what this is for or why you would ever want to do this. Is it not just a glorified HTTP wrapper?
Serious request... I genuinely want to understand. Give me a practical use case?
To be honest this completely defeats the purpose of OpenClaw.
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.
that's nice i'm buying ten mac minis to run this
My new DIY laptop has 400GB RAM accessible and it runs only esp32*
____
* Requires external ram subscription
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.
I don't fully get it either. At least agents build stuff, claws just run around pretending to be alive?
Can we please move past this whole OpenClaw hype?
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.
Well I wasn't using your homegrown solution, but now I'm using openclaw and it 'hijacks' my computer to do whatever I tell it.
Heck, my 6 year old kid has been using it.
My 6 year old kid isnt writing code in langchain.
Oh wow more ai slop
[dead]
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.
Honestly does show how the industry has failed to bring simple things like localized cron and scheduling to personal compute too.
These things seem powerful when you can schedule reoccurring scripts l but it never was easily accessible to the masses.
> Honestly does show how the industry has failed to bring simple things like localized cron and scheduling to personal compute too.
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."
My guess is that management would see little to no ROI, as the average user is already able now to schedule tasks using one of these AI agents. Which is killing a mosquito using an energy-hungry bazooka, but the general public doesn't seem to care. And I myself have to admit that I don't have a clear opinion on all this, as I have many complaints, but in these days I'm trying to use AI agents for some side projects.
> It’s like most of the industry hasn’t ever looked any deeper than their node_modules folder.
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.
I don't care whether openclaw is built out of ice cream and sprinkles, I will still be amazed as a tech person
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
This is an ostrich-head-in-the-sand type of outlook. If I gave you a great tasting cake made of boiled plastic would you still eat it?
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.
> If I gave you a great tasting cake made of boiled plastic would you still eat it?
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.
This doomer attitude is something I have towards all software products these days, not just *claws.
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.
> . I've never been more excited about technology than right now. If it's not for you, I really don't care.
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.
Better analogy is the clawcake has no new ingredients, we've been cooking with the same ones for years now, and its a shame people are such terrible bakers that they are so impressed.
You have to believe me this time!
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?
I've been developing one of these in the past few days, and this is like saying "this is a great example of how silly the whole thing is, there's next to nothing to cars" because you saw a piece of plywood with four gaskets nailed to it.
If you want a personal assistant to work well, there's a whole lot to it.
Having a similar experience. Durable memory with accurate, low-latency recall is not at all easy. Loads of subtle design decisions to make around how exactly you want the thing to work.
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 struggling to understand what a personal agent/assistant would do to me. If I need reminders I just enter calendar entries on my smartphone, what else?
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
I use opencode, cerebras GLM with some mcps for that. It's so lovely because you press enter and there is the answer already.
[flagged]
[flagged]
"Please don't post shallow dismissals, especially of other people's work. A good critical comment teaches us something."
"Don't be snarky."
Anytime I get in a discussion and sufficient number of people disagree, my comments are flagged despite obeying site guidelines. What should I do about this?
I'm unsnarkly saying this work is completely useless for me.
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...
Of course, but the site guidelines are clear about how to do so:
"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.
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
+1. if you have a couple of potentiometers and a breadboard lying around, a granular synth would be a fun exercise.