DrkPxl

Erase Old MQTT or Unwanted Sensors

2025-11-18T00:00:00Z

Home Assistant makes it easy to add devices and surprisingly tedious to remove a lot of them at once — especially stale MQTT sensors. Here's the approach I use to delete them in bulk.

The idea

Rather than deleting devices one by one, you herd everything you want gone into a single Area, then run a short script in your browser's console that deletes everything in that Area.

Steps

Create a staging Area. In Home Assistant, make a new Area — I call mine Garbage — and note its ID. You'll set that as the GARBAGE_ID variable in the script.
Move the junk in. In the devices list, check off the devices you want to remove, then use the menu in the upper right to mass-assign them to the staging Area.
Run the script. Open your browser's developer console and paste in the script. It calls Home Assistant's WebSocket API to read the device registry, filter to your staging Area, and remove those devices from their config entries, logging results as it goes.

Tip: The script ships with an actually_delete flag set to false. Leave it off for a dry run first — you'll see exactly which devices would be deleted before anything is removed. Flip it to true once you're happy.

The script

The full, current script lives in this gist:

github.com/jasonk — erase-old-mqtt gist ↗

Copy it into your console after you've staged the devices, do a dry run, then delete for real.

Figma Design Agent Launch

2026-06-11T00:00:00Z

Figma announced an AI design agent that lives right inside the canvas — generating, editing, and iterating on designs alongside you instead of in a separate chat window.

It's a good example of the pattern we keep seeing: agents showing up inside the tools people already use, rather than as standalone chatbots.

Read the announcement on Figma's blog ↗

Claude Fable 5: The "Safe" Mythos for Everyone

2026-06-11T00:00:00Z

Anthropic just dropped Claude Fable 5, and if you've been following the whispers about "Mythos," this is the moment. For the uninitiated: Mythos is Anthropic's powerhouse architecture—a class of model designed for extreme technical proficiency, specifically in areas like vulnerability discovery and complex software engineering.

The problem? A model that can find every bug in a system can also be used to break every system.

Enter Fable 5: a "safe" version of the Mythos-class model designed for public consumption.

What exactly is Fable 5?

Think of Fable 5 as the "civilian" version of a high-grade military tool. It shares the same underlying brain as Claude Mythos 5 (which is restricted to a vetted group of partners via Project Glasswing), but it comes with heavy-duty guardrails.

The "Safe" Part: How the Guardrails Work

Anthropic isn't just using a simple "I can't answer that" filter. They've implemented a Fallback Mechanism. When Fable 5 detects a high-risk prompt (specifically in cybersecurity, biology, chemistry, or model distillation), it doesn't just stop—it silently reroutes the request to Claude Opus 4.8.

Essentially, if you ask something too "dangerous," the system swaps the super-brain for a standard high-end model to ensure a safe response. Anthropic claims ≥ 95% of sessions stay on Fable 5, meaning for most of us, we get the full power without the "safety-triggered" downgrades.

Why should you care? (The Specs)

If you're doing high-end knowledge work or coding, Fable 5 is a significant leap over Opus 4.8.

Software Engineering: It's designed to "one-shot" full applications and excels at UI design and game coding. Stripe reported it compressed months of engineering into days, performing a codebase-wide migration in one day that would have taken a team two months.
Autonomous Operations: It has a superior ability to reflect on and validate its own work. Simon Willison noted it as being "very proactive," spotting and fixing bugs in dependency libraries during development.
Analytics & Vision: It's the first model to hit 90% on the Hex core analytics benchmark. On the vision side, it's a new state-of-the-art, capable of rebuilding web app source code from screenshots alone and playing Pokémon FireRed with minimal vision-only scaffolding.

The Controversy: Silent Sabotage

It hasn't been all sunshine. Shortly after launch, it was revealed in Fable's 319-page system card that Anthropic implemented invisible safeguards for "frontier LLM development."

If you were trying to build a competing LLM, pretraining pipelines, or ML accelerator designs, the model would silently "limit effectiveness" via steering vectors or prompt modification without notifying the user. After a massive outcry from the research community and coverage by Simon Willison and Wired, Anthropic walked this back. They have now shifted these specific "frontier" safeguards to be visible, meaning they now trigger a visible fallback to Opus 4.8 rather than silent degradation.

The Trade-offs: Cost and Privacy

Power isn't free. Fable 5 comes with two major "catches":

1. The Price Tag 💸

Fable 5 is twice as expensive as Opus 4.8.

Input: $10 / million tokens
Output: $50 / million tokens

Anthropic's counter-argument is that the higher intelligence leads to a higher ROI—you spend more per token, but you get the job done right the first time.

2. The Data Policy ⚠️

To defend against novel jailbreaks, Anthropic has introduced a mandatory 30-day data retention policy for all traffic. This overrides previous "zero-retention" enterprise agreements. They claim this data is not used for training, but strictly for security monitoring.

Final Verdict: Practical AI Take

Fable 5 is a beast for anyone who needs a model that can actually reason through a multi-step project rather than just predicting the next word. If you are building agents or handling complex technical debt, the 2x cost is likely negligible compared to the time saved.

Just be mindful of the 30-day retention if you're handling extremely sensitive data, and keep an eye on your token usage—this model will eat through credits faster than Opus ever did.

Want to see how Fable 5 integrates with Hermes and other automation tools? Stay tuned for the next guide.

Armchair Arena - Test Ollama Models for YOUR use case

2026-06-15T00:00:00Z

Up until recently, I was a HUGE Claude user, bouncing between Max and Max 20 depending on the project and the month. I mostly saw AI as a way to write deterministic code. I watched OpenClaw show up, get hacked, then evolve, and I said, "I don't need that." Between Perplexity, Gemini, and Claude Code, all my non-coding "life assistant" needs were covered.

Then I got curious about Hermes — it seemed like a "smarter" OpenClaw. I set it up against my ChatGPT subscription and it worked fine, but it got me curious about running open models. So I grabbed an Ollama subscription and was immediately spoiled for choice: 20+ models, each with a pile of cryptic numbers after its name — oh my. I picked them basically at random, wired up Cron jobs and webhooks, and had them give me advice and run little errands. Sometimes they were great, sometimes they weren't, and I genuinely couldn't tell which. Classic analysis paralysis: I had no idea which model deserved to be my "go-to," my "set and forget" pick.

So, in classic Steve fashion, I built my own LM arena : Armchair Arena where I judge a model's performance by completely subjective voting on the answer and on the web sources it chose to cite.

What Armchair Arena actually does

It's a tiny, self-hosted arena for evaluating LLMs on real-world, non-coding tasks — web research, summarization, advice, recipes, general knowledge — and it judges them on the three things that actually matter day to day: was it fast, was it token-efficient, and was the answer any good?

You pick 3 models, ask one question, and see the answers side-by-side — complete with live metrics (tokens, tokens/sec, wall-clock) and the actual source URLs each model pulled in. Then you crown the best one with a single click. Every model gets the same web-research tools (a self-hosted Firecrawl), so it's a fair fight.

One decisive judgment per round beats fuzzy 1–5 star ratings, because over many rounds it turns into something you can actually quantify.

The data is where it gets interesting

Every run is saved to SQLite, and an analytics page turns all of it into an opponent-aware strength rating , a Bradley-Terry / Elo-style score where beating a strong model counts for more than beating a weak one. You get win-rate with a 95% confidence interval (so a lucky 3-run sample can't masquerade as the champ), a Pareto efficiency frontier that flags the models nothing else beats on strength, cost, and speed at once, plus strength-vs-cost and speed leaderboards. And CSV export, because of course.

Here's my honest snapshot. By raw strength, deepseek-v4-pro (~1743) and qwen3.5 (~1738) are out front, and my pick nemotron-3-nano:30b-cloud sits around third (~1469 strength, ~31% win rate over 26 runs). It's not on the efficiency frontier either. So why is it my "set and forget"?

Because for my questions, it's fast, it's light, its answers are consistently good-enough, and it tends to cite sources I'd actually click. The heavyweights win more head-to-heads, but nemotron-nano is the one I'm happy to leave running unattended on a Cron job.

Set it up to curate your own roster local, remote, or cloud

On first run, an onboarding screen lets you curate the roster of models you want in the arena. Mix Ollama Cloud with any number of local or remote Ollama servers you add by URL (a workstation, a box on your tailnet, whatever) — each model is automatically routed to its own backend. Your picks are saved server-side, so they persist across sessions and browsers, and you can edit the roster anytime from ⚙ Models.

How you can use it

If you're curious what the best model is for YOU, try it, the whole project is on GitHub:

👉 https://github.com/drkpxl/armchair-arena

You can set it up yourself (Python + uv, a self-hosted Firecrawl for the web tools, and an Ollama backend), or just point an AI agent like Hermes/OpenClaw at the included AGENTS.md — "clone this repo, follow AGENTS.md, here's my Ollama API key" and let it install, configure, and confirm everything's healthy for you.

Future plans

If there's interest, I'd add frontier models via their own API keys I'm just not ready for that yet. If you want to help shape that, or you just want to argue about which model should be everyone's set-and-forget, let me know. And if you run it, I'd genuinely love to hear which model ends up being your armchair champion.

Change Hermes Reasoning at Runtime

2026-06-15T00:00:00Z

Sometimes my Hermes over reasons on simple tasks but I don't want to change it globally. Here is a quick cheat sheet for how to change it during a session.

/reasoning           # Show current effort level and display state
/reasoning high      # Set reasoning effort to high
/reasoning none      # Disable reasoning
/reasoning show      # Show model thinking above each response
/reasoning hide      # Hide model thinking

Tiny Air: A Practical MCP Server for Air Quality

2026-06-26T00:00:00Z

What It Gives Your Agent

Four read-only tools:

get_air_quality — current AQI and category for a zip, city, or lat/lon
check_air_quality_threshold — boolean: is AQI above a given number right now?
find_nearby_stations — nearby AirNow reporting stations
list_aqi_categories — the AQI scale so the agent understands what the numbers mean

Connect it in two lines:

mcp_servers:
  tinyair:
    url: "https://air.drkpxl.com/mcp"

Works with Hermes, Claude Code/Desktop, and OpenClaw. If your agent speaks MCP, it can use this.

Why This Is Interesting

Your agent already has a scheduler. It already knows your zip code. It already knows how to message you. Tiny Air just gives it the data pipe. The agent decides when to check, what threshold matters, and what to do about it. A composable MCP pattern done right .

This is where I believe practical AI is heading. Not bigger models or more complex tools but just small, focused connections that let your agent handle the stuff you'd otherwise forget. Air quality is one example. There are a hundreds more.

Why Stateless

I could have built a notification service with stored zips and SMS alerts. But that's a database with PII, a privacy policy, and maintenance. Your agent already knows where you live and how to reach you. Duplicating that state into a second service is liability, not value.

Tiny Air holds nothing. It answers one question and lets the agent do the rest. No webhooks, no stored preferences, no callback URLs.

Try It

air.drkpxl.com has the full config, example recipes for Hermes, OpenClaw, and Claude, and screenshots of it running in Telegram, Discord, and Claude. Source is on GitHub.

US coverage only : AirNow.gov is a US service. If someone wants to build a non-US equivalent on OpenAQ or ECMWF, the architecture is simple enough to copy. Happy to share notes.

Qwen 3.6 27B is the sweet spot for local development

2026-06-30T00:00:00Z

A hands-on review of Qwen 3.6 27B, a dense local model that punches above its weight for development work, with practical setup instructions for running it via llama.cpp and benchmarks comparing it to frontier models.

Introducing Claude Sonnet 5

2026-07-01T00:00:00Z

Anthropic has released Claude Sonnet 5, a more agentic and cost-efficient model that approaches Opus 4.8's performance on many tasks, shows improved safety metrics over its predecessor Sonnet 4.6, and is now available across all Claude plans and the API with introductory pricing through August 31, 2026.

Claude Code Is Steganographically Marking Requests

2026-07-01T00:00:00Z

A security researcher claims to have found hidden Unicode markers in Claude Code that subtly alter the date string in its system prompt based on the API base URL's hostname and system timezone—apparently to flag custom gateways, proxies, or resellers (especially Chinese AI-related domains)—raising privacy and transparency concerns about undisclosed steganographic fingerprinting in a widely-trusted developer tool.

Claude Claude Fable 5 and Mythos 5 are back July 2nd

2026-07-01T00:00:00Z

Anthropic has received notice that the Department of Commerce has lifted export controls on Claude Fable 5 and Mythos 5.

Building pi in a World of Slop

2026-07-17T00:00:00Z

Refreshing video from Mario Zechner (Pi creator) on building deterministic code generation tools in a market flooded with unreliable AI-generated "slop".

chatbox: Hermes/OpenClaw Based Voice Assistant

2026-07-29T00:00:00Z

Before 3d printers got awesome I used to built my own or customize the heck out of my Ender 3, as a result I have a bunch of old parts sitting around so last weekend I decided to put it to use to act as a household AI assistant.

It has one real job: press the knob, ask out loud, read the answer..

Code, case, and wiring are all here: github.com/drkpxl/chatbox

The star of the show

The display is a BigTreeTech Mini12864 which is a part made for 3D printers, not for this. And it is an absurdly good deal for what I needed, A: Because I already had it but also because BTT put four things on one PCB: a 128×64 LCD, a rotary encoder with a push switch, three addressable WS2812 LEDs, and a piezo buzzer. One board, one bundle of jumper wires, and I have a screen, an input device, a status light, and a speaker.

Add a Raspberry Pi Zero W, an INMP441 I2S microphone, and about 150g of filament. Nineteen jumper leads, and the microphone's pads are the only soldering.

Its all cheap/spare parts

The architecture is pretty simple. and works with the low end hardware.

knob press ──> record to RAM (16 kHz mono WAV, never touches the SD card)
           ──> POST the audio to a transcription endpoint  ──> text
           ──> POST that text to a chat endpoint (SSE)      ──> tokens
           ──> draw them as they arrive

That's the whole thing. The box records, uploads, and renders. All the intelligence is a Hermes Agent host on my LAN, but nothing in the Pi code is Hermes-specific, it's just a multipart upload and an OpenAI-compatible /v1/chat/completions stream. Any Whisper-style transcriber and any OpenAI-shaped chat endpoint will drop in.

Because it streams, the answer starts appearing while the model is still writing it, which matters a lot on a screen this small. And an X-Hermes-Session-Id header scoped to the service run means consecutive questions continue a warm thread instead of starting cold every time.

Text that holds still

Long answers page rather than scroll. Each chunk sits still for a few seconds and then cuts to the next one.

The knob's LEDs carry the state, so you're never wondering whether it heard you — blue while listening, pulsing blue while transcribing, breathing amber while thinking, green while streaming, a double-pulse when it's done, red when it isn't.

It can also just say it

I also added Speak answers to the UI, pick a speaker available in Home Assistant, and the box stops drawing text entirely. It hands the finished answer to Home Assistant and shows an animated speaker icon. Same reasoning as the paging, if you asked out loud, you shouldn't then have to read if you don't want to.

Two things I learned wiring that up. Home Assistant acknowledges a TTS call immediately, so the box never learns when the speaker actually stops talking — the animation runs on a 150-wpm word-count estimate and a click cuts it short. And long answers get split into ~240-character chunks on sentence boundaries, because Alexa's notify TTS silently truncates past some length that moves between releases.

If HA refuses the call, it falls back to the text screen and plays the error tone.

What it does when I'm not talking to it

Most of the day it's a clock with the two readings I'd otherwise unlock my phone for.

But in the morning I genuinely don't care what time it is. I care whether I need a coat, whether the air is bad, and what I already said yes to. So between 6 and 9 the clock shrinks down to the bottom row and the whole middle of the screen becomes the day:

Air quality and what it's actually like outside on top, then today's sky with the high, the low and the chance of rain, then whatever's on the shared calendar. All of it comes out of Home Assistant, an Acurite 5-in-1 in the yard for temperature and humidity, Apple Weather through HA for the forecast, and our shared calendar for the events.

The two things actually worth interrupting me over get the same treatment: the row flips to white-on-black and the knob LEDs light up, so I can read it from the doorway before I'm close enough to make out 10px type. Storms go amber. Bad air gets the EPA's own color scale and outranks the weather, because I can dress for a storm.

There's no color and no second font size worth having on a 1-bit panel, so throwing the row negative is the only emphasis left that still works across a room.

One thing that surprised me: the sky row originally read rain 57% and the word "rain" cost 24 pixels of a 124 pixel row. It technically fit, with 1.8px between the two columns, which rendered as 90/67rain 57% and read as one word. Dropping four characters fixed it. On a screen this small the layout is a budget, and you find out by looking, not by doing the arithmetic.

The case is code

The enclosure is a 45° wedge, 143 × 82 × 65 mm, and it's a parametric build123d script.

All four parts print without supports. The image above is a render.

Build one yourself, PR welcome!

Everything's in the repo: wiring tables and assembly, install and architecture, the case source with print-ready STLs, and the diagnostic scripts I used for bring-up. Roughly $40 of parts if you have a printer and a spare Pi.

→ github.com/drkpxl/chatbox