DEV Community: Bhavik Thakkar

Groq deleted every Llama model last week. My Electron app didn't notice.

Bhavik Thakkar — Sat, 22 Aug 2026 07:09:01 +0000

Last Sunday, Groq switched off every Llama model on its free and dev tiers.

My desktop app runs on Groq. Every AI button in it had been calling llama-3.3-70b-versatile since launch. On August 16 that model stopped existing.

Nothing happened. No error reports, no broken installs, no bad-review-shaped Monday.

That's not luck, and it's not a brag about my architecture — it's about four hours of unglamorous work I did a month earlier. Here's what that work actually was.

## The thing that makes desktop different

I found the deprecation notice in a changelog in July. If BEBO were a web app, this is a twenty-minute fix: change a string, redeploy, everyone's on the new version before lunch.

Desktop doesn't work like that. The code is on their machine, not mine. Someone who installed BEBO in June and never looked at GitHub again has no idea a deadline exists. Do nothing, and their app just… stops working one Sunday, with no explanation and no path forward.

So the job was never "pick a new model." It was four jobs:

Pick a new model
Make the failure survivable if the new one has a bad day
Get existing users onto the new version at all
Update every place the old model was named

Number 4 took the longest. We'll get there.

Picking the replacement

My constraints were narrow, which made this easy:

Still free, no credit card — that's BEBO's entire pitch
Fast enough that a desktop utility feels instant
Good enough at short writing tasks: summarize, fix grammar, simplify

I moved to openai/gpt-oss-120b. On Groq's LPUs it runs around 500 tokens/second, which keeps a typical task at about a second end to end. The free tier allows 1,000 requests/day.

Worth putting that in human terms: 1,000/day is roughly 40 tasks an hour, sustained,forever — far more than anyone puts through a writing utility. My older docs quoted a higher figure that didn't survive a check against Groq's current rate-limit page, so v2 ships the number I can point at. More on that sweep later.

The decision I'd repeat: a list, not a swap

Here's the part worth stealing.

I didn't replace one hardcoded model with another hardcoded model. I made the model an ordered list:

const GROQ_MODELS = [
  'openai/gpt-oss-120b', // primary  — best quality, ~500 tok/s
  'openai/gpt-oss-20b'   // fallback — lighter, ~970 tok/s, separate quota
];

And the request walks it:

for (const model of GROQ_MODELS) {
  try {
    return await callGroq(model, prompt);
  } catch (err) {
    if (isRetryable(err)) continue; // rate limited / busy → try the next one
    throw err;                      // real error → surface it
  }
}

Three things this buys me.

The 20B model draws on a separate quota. If someone exhausts the 120B allowance, BEBO drops to the smaller model instead of showing a dead button. Users notice dead buttons. They don't notice 120B vs 20B on "fix this paragraph."

It catches the thing that started all of this. Look at what else trips the fall-through: a 404, or an error mentioning decommissioned or deprecated. If Groq retires gpt-oss-120b next year, BEBO doesn't break — it walks down the list and keeps working while I ship an update. I wrote that check the same week I was hand-migrating off a retired model, which is the only reason I thought to write it at all.

The next migration is a one-line diff. The real lesson isn't "use GPT-OSS" — that recommendation has a shelf life too. It's that a hardcoded model name is a single point of failure with someone else's deprecation calendar attached to it. A list costs nothing and turns the next announcement into a config change.

Getting existing users across

A migration nobody installs is not a migration.

So v2.0 also shipped an in-app update checker that pings the GitHub releases API, plus a "What's new" popup on first launch after updating. That's the only channel I have to reach someone who installed the app and moved on.

One small thing that made this much less painful — I made the installer artifacts version-less:

BEBO.the.PET.Setup.exe   ← not BEBO.the.PET.Setup.2.0.1.exe
BEBO-portable.exe

Now releases/latest links from the site, the README, and the in-app updater never rot. I don't have to remember to update download links across five surfaces every release — which means I won't forget to.

The unglamorous part: your docs are the product

This is where it actually got long.

llama-3.3-70b wasn't only in ai-service.js. It was in the README. The website hero. Two FAQ answers. The pitch deck. The LinkedIn carousel. The app's own footer label, rendered on every launch.

And a spec-sheet PNG with the model name baked into the image, where no text search would ever find it. I did a full pass across every surface, regenerating images. It was boring and it took longer than the code did.

But code being right while the marketing is stale is its own kind of bug — and it's the one users hit first. Someone landing on a page promising Llama 3.3 and downloading an app running GPT-OSS has been misinformed, even though the app works perfectly.

If you take one process habit from this post: when you change a dependency, grep your docs as hard as you grep your source. Then go look at your images.

While I was in there

Since v2.0 was already a disruptive release, I fixed what v1 left rough:

Colour-coded action buttons — each of the six tools has its own accent, so you hit the right one without reading
Dark / light theme that remembers your choice
Remappable global shortcuts — all three, from inside the app
Voice input via Windows' own dictation (Win + H) — zero new APIs, zero new cost; the OS already does this well, I just had to add a hint and get out of the way
Multi-monitor support — BEBO wakes on whichever screen you're actually on
MIT license + a GitHub Actions build pipeline

One of those had a hidden dependency. BEBO's "hide" shortcut used to be Ctrl+Shift+H. Once I started pointing people at Win+H for dictation, a near-identical hide key became a trap. Moved it to Ctrl+Shift+B. Shortcut choices are product choices, especially when you're borrowing the OS's.

The honesty fix

v1's README said BEBO had "zero telemetry." True when I wrote it.

In v2 I added an anonymous install counter, because I wanted to know whether anyone was actually using this thing. The tempting move is to add the counter and leave the old sentence alone. Nobody reads READMEs that closely.

I rewrote every place that claim appeared instead. BEBO now states exactly what it sends: a version number and a random id, once a day. Never your text, never anything personal. One tick-box in settings turns it off.

Same instinct as the "14,400 requests" number I'd published without checking. A counter is worth having. A claim you've quietly outgrown isn't.

What I'd tell past me

Watch your upstream. I found this deadline in a changelog, not from an angry user. That was luck, and luck is a bad monitoring strategy — subscribe to your providers' deprecation feeds.
Never hardcode a single model. A list with a fallback is barely more code and deletes an entire class of outage.
Ship the docs with the code. Including the images.
A deprecation is a good excuse. BEBO v2 is a much better app than v1, and it exists because a vendor forced my hand. The deadline was the reason; the polish was the opportunity.

Deadline day was completely uneventful. That was the whole goal.

If you're running BEBO v1

Your AI buttons stopped working on August 16. The fix takes under a minute and your saved key still works:

Download: https://github.com/bhavik8025/BEBO-the-PET/releases/latest

BEBO is free and open source — issues and PRs welcome.

bhavik8025 / BEBO-the-PET

🤖 BEBO the PET — An animated AI desktop companion that lives on your Windows desktop. Always on top, always ready. Click to open a sleek AI panel powered by GPT-OSS 120B via Groq. Summarize, humanize, simplify, draft emails, fix grammar & ask anything. Built with Electron + Node.js.

🤖 BEBO the PET — AI Desktop Companion

A tiny animated AI pet that lives on your Windows desktop. Click it, get superpowers.

Website: https://bhavik8025.github.io/BEBO-the-PET/
Download: https://github.com/bhavik8025/BEBO-the-PET/releases/latest

What is BEBO?

BEBO is a desktop AI productivity assistant disguised as an adorable animated pet. It lives in the corner of your screen at all times — always on top, always ready. One click opens a sleek assistant panel powered by GPT-OSS 120B via the Groq API, letting you summarize documents, write emails, fix grammar, simplify complex text, humanize AI-generated content, or ask anything — all without switching windows or opening a browser.

Built entirely with Electron + Node.js, BEBO runs natively on Windows with zero browser needed.

Features

🐾 Animated Desktop Pet

Lives permanently on your Windows desktop — always on top, always visible
Smooth CSS animations — idle float, happy bounce, thinking pulse, excited wiggle, and more
Fully…

View on GitHub

Has an upstream deprecation ever broken something you'd already shipped? I'm curious how other people handle the "users have the old binary" problem — it feels like the part of shipping desktop software nobody warns you about.

I built a free AI desktop pet for Windows powered by Llama 3.3 70B

Bhavik Thakkar — Mon, 01 Jun 2026 08:07:08 +0000

I built BEBO the PET, a free open-source AI desktop companion for Windows.

The idea is simple: instead of opening a browser every time you need quick AI help, BEBO lives on your desktop as a small animated assistant. Click it, and a compact panel opens with focused writing tools: summarize, draft email, fix grammar, simplify text, humanize AI-written text, and ask general questions.

Website: https://bhavik8025.github.io/BEBO-the-PET/

GitHub: https://github.com/bhavik8025/BEBO-the-PET

Download: BEBO the PET v1.0.0 for Windows

Why I built it

I kept running into the same tiny productivity friction: I wanted AI help, but I did not always want to open a browser, switch tabs, sign in somewhere, paste text into a large chat window, and then switch back to what I was doing.

Most AI tools are powerful, but they still feel like a separate destination. I wanted something closer to a desktop utility: always nearby, fast to open, and focused on the small writing tasks people repeat every day.

That became BEBO.

What BEBO does

BEBO currently has six focused actions:

Summarize: turn long text into a clear short summary
Draft Email: turn notes or intent into a professional email
Fix Grammar: clean grammar, spelling, and punctuation
Simplify: rewrite complex text in plain language
Humanize: make robotic AI text sound more natural
Ask AI: use a general prompt when the fixed tools are not enough

It also supports keyboard shortcuts, a system tray menu, draggable positioning, and a resizable assistant panel.

The stack

BEBO is built with:

Electron for the Windows desktop app
Node.js for the main process and app logic
Vanilla HTML, CSS, and JavaScript for the pet and assistant panel
Groq API for fast inference
Llama 3.3 70B Versatile as the model behind the AI actions

I kept the frontend simple on purpose. For this kind of app, speed and reliability matter more than framework complexity.

How the app is structured

The app uses two main windows:

A transparent pet window that stays on the desktop
An assistant panel window that opens near the pet when needed

The pet communicates with the main Electron process through IPC. When the user clicks BEBO or uses a shortcut, the main process toggles the assistant panel. When the user runs an AI task, the panel sends the input to the main process, which calls the Groq API and returns clean plain text back to the UI.

That structure made the app feel more native and less like a webpage wrapped in a desktop shell.

A small UX decision I cared about

I did not want BEBO to become another giant chatbot window. The panel is intentionally focused around tasks people actually repeat:

"summarize this"
"make this email sound professional"
"fix this paragraph"
"explain this more simply"

That constraint helped keep the app lightweight.

What I learned

The biggest lesson was that desktop AI tools need a different rhythm from web AI tools. On the desktop, the assistant should feel fast, nearby, and low-friction. If opening the tool feels heavy, people will just go back to the browser.

I also learned that small product details matter a lot in Electron apps: panel positioning, always-on-top behavior, tray actions, keyboard shortcuts, and clean IPC boundaries all affect whether the app feels polished.

What I would like feedback on

I would love feedback from developers and Windows users on three things:

Is the desktop-pet interface useful, or should the app become more minimal?
Which AI actions should be added next?
Should BEBO stay a lightweight utility, or grow into a larger productivity assistant?

The project is free and open-source, so issues, ideas, and pull requests are welcome.

Website: BEBO the PET
GitHub: bhavik8025/BEBO-the-PET