I've released Lightwhale 3, which is possibly the easiest way to self-host Docker containers.
It's a free, immutable Linux system purpose-built to live-boot straight into a working Docker Engine, thereby shortcutting the need for installation, configuration, and maintenance. Its simple design makes it easy to learn, and its low memory footprint should make it especially attractive during these times of RAMageddon.
If this has piqued your interest, do check it out, along with its easy-to-follow Getting Started guide.
In any event, have a nice day! =)
We got tired of browser frameworks restricting the LLM, so we removed the framework and gave the LLM maximum freedom to do whatever it's trained on. We gave the harness the ability to self correct and add new tools if the LLM wants (is pre-trained on) that.
Our Browser Use library is tens of thousands of lines of deterministic heuristics wrapping Chrome (CDP websocket). Element extractors, click helpers, target managemenet (SUPER painful), watchdogs (crash handling, file downloads, alerts), cross origin iframes (if you want to click on an element you have to switch the target first, very anoying), etc.
Watchdogs specifically are extremely painful but required. If Chrome triggers for example a native file popup the agent is just completely stuck. So the two solutions are to: 1. code those heuristics and edge cases away 1 by 1 and prevent them 2. give LLM a tool to handle the edge case
As you can imagine - there are crazy amounts of heuristics like this so you eventually end up with A LOT of tools if you try to go for #2. So you have to make compromises and just code those heuristics away.
BUT if the LLM just "knows" CDP well enough to switch the targets when it encounters a cross origin iframe, dismiss the alert when it appears, write its own click helpers, or upload function, you suddenly don't have to worry about any of those edge cases.
Turns out LLMs know CDP pretty well these days. So we bitter pilled the harness. The concepts that should survive are: - something that holds and keeps CDP websocket alive (deamon) - extremely basic tools (helpers.py) - skill.md that explains how to use it
The new paradigm? SKILL.md + a few python helpers that need to have the ability to change on the fly.
One cool example: We forgot to implement upload_file function. Then mid-task the agent wants to upload a file so it grepped helpers.py, saw nothing, wrote the function itself using raw DOM.setFileInputFiles (which we only noticed that later in a git diff). This was a relly magical moment of how powerful LLMs have become.
Compared to other approaches (Playwright MCP, browser use CLI, agent-browser, chrome devtools MCP): all of them wrap Chrome in a set of predefined functions for the LLM. The worst failure mode is silent. The LLM's click() returns fine so the LLM thinks it clicked, but on this particular site nothing actually happened. It moves on with a broken model of the world. Browser Harness gives the LLM maximum freedom and perfect context for HOW the tools actually work.
Here are a few crazy examples of what browser harness can do: - plays stockfish https://x.com/shawn_pana/status/2046457374467379347 - sets a world record in tetris https://x.com/shawn_pana/status/2047120626994012442 - figures out how to draw a heart with js https://x.com/mamagnus00/status/2046486159992480198?s=20
You can super easily install it by telling claude code: `Set up https://github.com/browser-use/browser-harness for me.`
Repo: https://github.com/browser-use/browser-harness
What would you call this new paradigm? A dialect?
This is mainly a UX experiment for me. And also the reason it isn't a Chrome extension: once you have a chat bar that understands intent, the URL field is redundant. You shouldn't have two places to tell the browser what you want. I didn't want to bolt an agent onto an existing browser's chrome and end up with duplicated controls everywhere — I wanted full freedom to redesign the shell from scratch, decide what stays, what goes, and what a browser even looks like when the agent is the primary interface.
Download for macOS: https://usenimbus.app
Launch video: https://youtu.be/dj23-XIiB1oRoboAPI is a unified API layer that abstracts all of that into one clean developer experience. One SDK, one API key, any robot — simulated or real hardware.
You can connect a simulated robot and read live telemetry in under 5 minutes:
pip install fastapi uvicorn roslibpy
uvicorn api.main:app --reload
curl -X POST localhost:8000/v1/robots/connect -d '{"robot_id":"bot-01","brand":"simulated"}'
curl localhost:8000/v1/robots/bot-01/sense
The architecture is pluggable — each robot brand is a separate adapter implementing a common interface (like a payment gateway in Stripe). Adding a new brand means one file.
Currently supports: simulated robots and any ROS2 robot. Boston Dynamics and Universal Robots adapters are next.
Would love feedback from anyone working in robotics — especially on the API design and what's missing for real-world use.
The aim of CCM is to be able to fully manage all Claude Code configuration files, both globally and those in your project.
Some neat features:
- Manages your CLAUDE.md, rules, hooks, agents, memories and so on.
- Elevate memories to rules
- Copy/Move any asset from one scope to another, or elevate it to global scope
- Install marketplaces and plugins
The full app is embedded right on the site as a demo so you can try it out.
I'm happy to receive feedback, I know it's not perfect. Thanks for taking a look.
In a way, it is similar to what an antivirus does for a computer, but applied to human cognition.
This simple project is mainly an MVP proof of concept.
I want to turn this project into an entire ecosystem to give people more control, detect PSYOPS, election manipulation, and give people more awareness.
Right now all the marketing companies are getting very good an influencing people, and this is going to get worst with LLMs.
All the innovation is going into marketing, and nothing is going into giving people more control over their devices and their lives.
I want to build this ecosystem to serve as a counterweight, ensuring we don't live in a future where big companies control people's behavior. (not gonna let them do that)
this is the website: https://www.falsoai.com/
these are some test examples that you can try:
News
https://edition.cnn.com/2026/04/22/us/epstein-files-sex-traf... https://www.bbc.com/news/articles/cn0ep28drllo https://edition.cnn.com/2026/04/21/economy/us-retail-sales-m...
YouTube
https://www.youtube.com/watch?v=2sQbK6EH9yg&t=2379s https://www.youtube.com/watch?v=pDxCC5-C9Tg&t=128s https://www.youtube.com/watch?v=MZPVPCIeUpg
Thanks for taking a look. I would really appreciate any feedback and suggestions!!! :)
Here's what I did:
1. Built a proxy that intercepts Codex's calls to OpenAI and rewrites them on the fly.
2. Replayed 3,807 rounds of SWE-bench Verified traces through it: avg prompt 44k → 6k tokens (-87%).
3. Posted it to HN to get the next reduction applied to my confidence interval — starting with the inevitable "How about accuracy?"
npx -y pando-proxy · github.com/human-software-us/pando-proxy
For context, I'm a surgical resident in the UK by background and am currently taking a year out of training to study a masters in computer science. My daughter just turned one. There are two things she really loves: the first is particular soft toy that she just can't live without, and the other is a good story book.
Her grandparents live hours away and I didn't want her to forget what they sound like between visits. I wanted her to hear them whenever she missed them.
My parents brought my brother and I up with incredible stories and books from all sorts of cultures, many of the stories being passed down from their parents before them. I didn't want my daughter to miss out on that.
Finally, I was sick of missing storytime with her when I had to leave for night shifts. I wanted her to hear my voice before she slept every night.
For all these reasons, I decided to build Storyfriend. It's her favourite soft toy with a custom made speaker-module inside. I combined my surgical skills with the skills I was learning as a CS student. Along the way I dipped my toes into the world of 3D printing, CAD and electronics design.
When she hugs the toy, it plays stories read by her grandparents. She can take the toy with her anywhere and hear the stories anytime she wants - it works offline and has internal storage. It meets my wife's strict no-screen rule (which is getting harder to stick to as the days go by). I've recorded some of the stories that we would read together, so that on nights when I'm working she still has me there to read her a bedtime story.
The bit I'm most pleased with: grandparents don't need an app. They just call a phone number. The audio routes through my server and pushes to the toy over WiFi. My own 86-year old grandmother in a rural village in another country can do it by just making a regular call via her landline, as she has done for many years - no help needed, no apps required, no smartphones involved.
Hardware is a BLE/wifi module with a MAX98357 chip and custome battery management system, all soldered together, placed in a 3D printed enclosure and placed into a compartment that I stitched into her cuddly toy. Firmware pulls new messages when connected to WiFi and stores them on an SD card.
So far I've sold a few hand-made units to parents and grandparents who resonated with the project.
Site: https://storyfriend.co.uk
Would love feedback on the technical approach, the product itself, or anything else. Happy to answer questions about the build
I built this project to solve a problem I personally struggled with — using too many tools and losing focus.
The idea is simple: Instead of adding more tools, reduce them and focus on what actually matters.
This is still early, and I’d love your feedback.
For a visual intro, here’s a YouTube video demonstrating the features and use cases: https://youtu.be/Jz0l_izoA1w
I started this project because I wanted a few small AI-powered apps for myself — a bookmarks tool, a calorie tracker, a TODO list — but deploying N separate apps with N deployments, URLs, and auth configs is too much effort for a single-user use case. So I built one container that holds all the apps, runs them at the same URL, and lets the agent inside modify them. If I want to change my bookmarks app, I don't open Claude Code and push to a repo — I tell the agent, and it edits the HTML directly. Not great for a large SaaS with lots of users but works great for a single-user app.
Each app is just an HTML file but with access to a filesystem API, full network access and full agentic capabilities.
Since then, Lilo has grown to also support a filesystem/workspace that can hold more than just apps. You can upload PDFs or screenshots and have the AI analyze and organize them for you. The AI also remembers key details about you in a “LLM wiki” style tree of markdown files. It’s a full-on personal assistant.
Inspired by OpenClaw, I added support for additional channels like WhatsApp, email, and Telegram. Now I take a photo of my lunch, text it to Lilo, and the calorie tracker updates. If I didn't eat the pizza crust, I text "didn’t eat the crust" and it adjusts the entry. Cal AI couldn't do that. And unlike say a calorie tracker WhatsApp bot, I also have a nice visual interface to look at my meals.
This combo of personal assistant + personal apps is very powerful. And very flexible. The UI is nice for glancing at data. The chat is nice for operations the UI doesn't cover. I don't have to build a search into every app, I can just ask the agent.
Lilo is open source and alpha software. Bring your own keys. The setup is not the easiest (a lot of API keys and you need to self host). All security advisories for LLM apps with network access apply here. But at the start, since there is no personal data, no data exfiltration is possible but credential exfiltration certainly is. Your entire workspace can be backed up and versioned using a git repo so the data is durable.
I’d love to hear feedback, and hope people find this as useful as I have.
We just finished our first major build of TurbineFi, an AI-assisted workflow for building, backtesting, and running prediction market strategies. There are over 1,000 community strategies you can try out, there's a backtesting engine integrated in the workflow, and you get your own sandbox to execute the trades 24/7. Currently live for Kalshi, Polymarket coming soon.
We developed a custom DSL to make compiling AI-assisted strategies more deterministic than raw python generation, so creating a strategy takes seconds even on low-tier models (thinking of migrating to a self-hosted model soon to reduce costs).
We also worked with Locus (YCF25) to do the sandbox provisioning, so that we never manage keys for users. When a user signs up with their email, Privy creates a wallet for them, and then that wallet uses the X402 agent payment protocol to pay for their own server. We created a deployment harness around it that accepts and runs new code via a hosted API, so once it's up, every deployment is authorized by EIP-712 signatures. It keeps everything non-custodial, and code deployments happen in seconds. And users don't really realize they're using crypto rails.
Turbine also includes weather and crypto historical information, so you can do things like fading the BTC-15min UP markets when it's cold in NYC, and backtest and run it in seconds. Adding sports data soon.
There's a 7-day trial if you want to poke around. Would appreciate feedback on which strategies you'd want to try first, so we can make sure we have the infra to support them. Thank you!
for the past two weeks i've been building a protocol that lets you prove what an AI agent actually did. not just log it. prove it. signed receipts before and after each action, hash chained, verifiable by anyone.
this week microsoft merged my code into their agent governance toolkit. twice.
happy to answer questions about how it works.
It comes with 90+ reusable components built on top of Shadcn UI plus 60+ chart variations from Recharts, all documented in the included Storybook. There is also an optional Node.js backend which enables the full Better-Auth flow, and a separate, lightweight version of the starter with just the layout and the core setup.
Live version: https://demo.nellavio.com/
Storybook: https://storybook.nellavio.com/
All links: https://nellavio.com/
Tech stack: Next.js 16, React 19, Tailwind 4, Shadcn UI, Recharts, TanStack Table, Zustand, Better-Auth, next-intl. License: MIT
Happy to hear any feedback