Hyperfocus Bear — writing

Claude Opus 5.5 agent went bananas trying to generate a blog post graphic

2026-10-01T00:00:00Z

My blog post header picture was supposed to be a joke. I wanted to generate something that fits the article subject and is a bit absurd. I explained that to my Corporal Claude, running Claude Opus 5.5, and he wrote perspective math, typed six different fruits, and invented the banana-shaped moustache. Then a picture it had already thrown in the bin turned out to be the best thing that happened during that experiment.

The card that needed a banana

On rustedvino.com every guide has a card picture, and every card is made the same way using RustedVINO server, because that is the point: Bear eats his own cooking.
A small chat model writes the prompt, an image model draws it, here is the process: let an LLM write your image prompts, then check what it assumed.
All that happens on my laptop, on RustedVINO, with no cloud anywhere. The writer is Bielik 11B (v3 int4), a Polish model (bielik is Polish for the white-tailed eagle), and the painter is FLUX.1-schnell (int4). The laptop is a Lunar Lake with the Arc 140V iGPU, running RustedVINO 0.7.0 - typical Bear's toolbox.

The guide that needed a card was about exactly this job: not every local LLM can write your image prompts. Because guides on rustedvino.com are written by an agent under my supervision from material which I provide I ordered Corporal to come up with an idea for the picture. Corporal missed home apparently so his primary idea for the picture was a typewriter with a blank sheet.
Perhaps he wanted to write a letter to his mother but inference engine had jammed.
His request to Bielik:

an old rust orange typewriter on a dark steel desk, a sheet of blank white paper rolled into it, one crumpled blank sheet lying beside it, cold steel blue light from one side, no people, no robots, no characters, no text or letters on the paper, near-black background

Bielik instead of helping made the case more complicated by answering a bit too long and not sticking to requested format: Corporal asked for 30 to 60 words, and for the prompt only, no chatter. Bielik spat out: "Here's your refined prompt in English for Flux:" followed by 96 words:

A vintage rust-orange typewriter sits on a dark steel desk, its mechanical keys slightly worn and dusty. A neatly folded sheet of blank white paper is inserted into the platen, while a crumpled blank sheet lies discarded nearby. The scene is illuminated by a stark, cold steel-blue light emanating from a hidden source, casting sharp shadows across the desk. The background is nearly black, with no human figures, robots, characters, or any text visible on the papers. The focus is on the texture of the typewriter, the metallic surfaces, and the quiet solitude of the object.

That is the very failure the guide describes, performed live for the camera and proof that eagles can't count well. I had shown earlier in the guide how to add a cleanup step that removes the chatty line. Corporal used my method and FLUX drew three variations with different seed among them s7 - a lovely orange typewriter with a blank sheet in it.

The card before the joke: Bielik wrote the prompt, FLUX.1-schnell drew it (seed 7).

I looked at it and thought: my Corporal got sentimental, what this white sheet is missing is a banana.

The long way round

I told my agent, Corporal Claude, what I wanted "I like s7 but what misses on that white card is banana. I think it could be a good joke, banana picture written on typewriter" Let's make a joke, Corporal: it is obvious a typewriter doesn't print pictures, isn't it? I didn't expect that the shortest and well established command chain in the universe - Bear -> Corporal - can go so wrong. Language models are really great nowadays but they still don't always get the joke and my slightly simplified English with "written on typewriter" has pushed Corporal into the ASCII jungle.

Corporal thought about it for a while and he decided that FLUX surely can't type characters on paper reliably. Image models are bad at generating letters, everyone knows that, even me. That's why I suggested banana picture. But Corporal concentrated his fire on protecting poor FLUX from struggling with writing. He decided he'd do it. He wrote a Python script and generated ASCII art in a monospaced font. He carefully warped it in perspective so it lies flat on the sheet, blended into the paper so it looks inked. Real engineering no one asked for. I'm deeply convinced I couldn't write that perspective transform myself, and I know even better we didn't need it at all. I was not watching generated pictures one by one, I trust my Corporal's judgment - most of the time.

Here is what came out, each one checked at the size the card is actually shown, 400 pixels wide:

an outline banana: a faint squiggle;
a crescent filled with the word "bananabanana": a wedge;
Being unaware how bonkers my Corporal is I typed in the console: "make a big banana there, it must be absurd", a big crescent of the word "banana": a fruit bowl, or a melon slice;
then spotting his ASCII art acrobatics I said "don't make it a word, make it a picture", proper shaded typewriter art in @, # and %: a moustache, then a boat, then a grinning mouth.

Six typed bananas at card size. Python, a monospaced font and perspective math; no model involved.

Six bananas. Not one of them was really the banana I had asked for. Corporal Claude picked the boat and wrote me an honest list of its limits.

So I asked the question I should have asked ten minutes earlier:

How hard can it be to generate a damn banana?! ;-P

Twenty-seven seconds

Not hard at all, it turned out. Corporal Claude asked FLUX for a bold ink drawing of a banana on white paper. Three clean bananas came back, about 27 seconds each, on the same laptop. Laid onto the typewriter's sheet, it read instantly: a banana, typed. Done, more or less.

Twenty-seven seconds: FLUX's ink banana, laid onto the sheet.

But that was not the end.

The one that got thrown away

Somewhere in the middle of the intense fight with typewriter art, Corporal Claude had also asked FLUX for something sillier: a giant banana rolled into the typewriter instead of a sheet of paper. He looked at the results and set them aside. His verdict: "the banana sits beside the paper", and there was some garbled lettering.

After my Corporal's failure I opened all graphics anyway. In one of them a real, ripe, yellow banana stands up in the typewriter, in front of the blank sheet, lit like a product photo. It has no explanation and no apology. It's just a banana that has clearly been typed. I laughed out loud: there it is - the essence of the absurd.

The one that got thrown away, and became the card. 26.9 seconds on a Lunar Lake laptop.

That is the card now. It took 26.9 seconds to draw.

What the banana taught me

The agent solved the wrong problem, and solved it well. The perspective math worked. The typing looked inked. It was the right answer to "how do I put typed characters on a photographed sheet", which nobody had asked. The real split was simple all along: code for compositing, a model for pictures.

The agent misjudged its own rejected picture. It saw a defect: the banana is beside the paper, not on it. I saw the joke. Humour is still a human call, and I'm glad it is.

My short sentences steered more than its long iterations. "It must be absurd." "Make it a picture." "How hard can it be?" Each one changed the direction more than any of the six bananas did. A manager doesn't need to know perspective transforms. He needs to know what he wants and say it in one line.

Deadpan works, cartoon doesn't. The drawn banana is fine. The real banana in a believable typewriter is funny, because it pretends nothing is wrong.

Check it at the size people will see it. Several of the typed bananas looked decent full size and became squiggles on the card. Corporal Claude checked every one at 400 pixels, and that, at least, he got right from the first minute.

The same day - a unicorn code 404

A few hours later I made a picture for this site's "not found" page (404). The same method: I manage, Claude rolls in the dirt, Bielik writes, FLUX draws. I wanted a picture of a teddy bear digging head-first in a toolbox or as an alternate picture of unicorn inside of sport sneaker. At generating bear image everything went wrong. Bielik translated the Polish "klucze" (wrenches) as "keys", and FLUX drew four bears sitting politely in the box, none of them digging, some of them twirled and garbled.
I didn't even try to suggest what Corporal should do with those, I was afraid of another ASCII art chase. Machines keep the nouns and lose the joke.
Meanwhile the unicorn series came out of FLUX and the winner in my eyes was the other idea: a sleepy plush unicorn who has moved into an old sneaker.

Multimodal models are great and they can analyse a picture, but many times they overlook important details or they don't get the joke without a human pointing at it. I'm happy we have our human side because I know how good the frontier models really are today. There is no doubt that with all knowledge concentrated in Opus 5.5 I have literally no chance of competing with it but... I can still beat it with my absurd sense of humour. So maybe it's not a competition at all. Water, fat and ions, working with numbers that breeze through copper and silicon: a new era of humanity.

Try a wrong address on this site and you'll meet a small unicorn in a shoe.

Disclaimer: all opinions, bananas, unicorns and questionable art direction here are ol' Bear's own. Intel makes good chips. Bear makes trouble, and lately he outsources some of it.

Hyperfocus Bear vs. Lunar Lake: Ollama, IPEX-LLM, and OpenVINO benchmarked on Intel Arc and NPU

2026-07-17T00:00:00Z

Finally I bought Lunar Lake.

Ol’Bear in Lunar Lake (generated with sdxl-fp16-ov on something you’ll see soon)

I always wanted to say that, who can afford lunar lake?
No one. There are no lakes on the moon.
HP named that device properly using AI in very center: HP OmniBook X Flip AI Ultra 7–258V/32GB/1TB.
It is slim, solid, aluminium machine. It does not overheat. You see HP, you can do it right (HP Envy T02 was an accident I think).
It works 8 hours on one battery charge. It has a gorgeous OLED 16" touch display. It “flips” so it can even be your tablet if you are Arnold Schwarzenegger’s son (because HP is 1.7kg).
It hides Intel secrets inside: Intel calls it AI PC. Its CPU has 8 cores (no HT), good modern iGPU (Arc 140V), and even 4th generation NPU 48 TOPS (int8) — who knows what it tops?
The not so wide known fact can be that Lunar Lake architecture for laptops has Unified Memory Architecture (UMA) and very fast RAM memory.
My model has 32 GB LPDDR5x, 8533 MHz RAM. The only disadvantage of UMA is the fact you can’t extend it, you need to live with what you started with.
I heard people are buying Macs or AMD Ryzen AI CPUs because of UMA. Silly you go Intel, buy Lunar Lake laptop for local inference.
If you’re developer, Intel offers AI development kit or you can use Intel OVMS server for serving LLMs.

For many Ollama will be way to go or rather tool to use.
It is easy to download and run under Windows and Linux. I chose to install on this laptop Ubuntu 26.04 along preinstalled Windows 11 Pro.
For today’s test Ubuntu will be my choice. I went to Ollama’s web page and downloaded standard package for Linux (1.3GB size). I can tell you that 90% of content in this package is completely not needed on this Lunar Lake laptop. Why is that so? Because it is Nvidia CUDA and AMD ROCm code. I decided to use it anyway because I know there is Vulkan support which you activate with OLLAMA_IGPU_ENABLE=1 and thanks to that you can use Arc 140V in this laptop to run inference.

For this test I used qwen3:4b Q4_K_M (2.5 GB) run on CPU first to establish a baseline and then using iGPU to see improvement.
As expected, CPU run results were not splendid, I almost fell asleep waiting for those:

Test	t/s	Peak t/s	TTFR
pp256	2.24	—	86.7s
pp512	2.18	—	156.6s
pp1024	1.72	—	283.0s

It got much better results though with iGPU, I didn’t manage to take a nap:

Test	t/s	Peak t/s	TTFR
pp256	14.58	—	2.81s
pp512	14.51	—	3.96s
pp1024	14.29	—	5.55s

One parameter so much acceleration.
Great, test finished. I proved that Ollama works with Lunar Lake iGPU trough Vulkan. Not so fast ol’ Bear. Why were you so upset with this 1.1GB of unneeded software? Does your laptop deserve a lean, fast engine maybe, optimised for Intel hardware and software stack? Hell yeah, it does.

Let’s look into Intel’s IPEX-LLM project. Not good. It is archived already on Github. But I’ll try it anyway because size matters — small size in that particular case. This package is only 143MB.

Fact is that this package is in very old version and I wouldn’t bother to run it for anything more serious than test. It uses the same model blob that Ollama has downloaded. I ran it straight on iGPU without wasting my time on CPU crawl:

Test	t/s	Peak t/s	TTFR
pp256	24.64	—	0.54s
pp512	23.83	—	0.86s
pp1024	25.22	—	1.70s

Hmm, wait a minute. It is genuinely remarkable difference.
Token generation speed almost 70% faster and prompt processing is 3–5 times faster than on new Ollama through Vulkan. Not mentioning the size difference which is enormous (relatively plays no role with today flash fast internet but still).

Some of you will know where is the secret. IPEX-LLM uses SYCL and Level-Zero (Intel’s GPU compute stack) and thanks to this adapts like a glove to the hand to Intel’s hardware.
It is like F1 car built for the driver by the team of engineers who pay attention to every detail to squeeze performance from every piston stroke.

I like my Intel hardware. I have a lot of it. I have a strong motivation to adapt. I like F1, tight gloves and piston strokes. KTM pistons are damn hot one, angry and brutal. I’m only the hot one.

You might ask the question: what do you intend to actually do about it, naughty Bear?
I might answer: the four people who actually read my article about spies know already, you will need to read it yourself. Brief summary for those who didn’t: Rust + OpenVINO = RustedVINO.

I can show you the table. Same LunarLake, same class model Qwen3–4b-int4-ov prepared by the OpenVINO team (and yes I know that it is not exactly the same quantisation method), it is not compatible with Ollama though.

CPU first, it beats Ollama because of OpenVINO usage:

Test	t/s	Peak t/s	TTFR
pp256	4.26	—	21.0s
pp512	3.85	—	42.9s
pp1024	3.34	—	96.4s

GPU now, it catches up with OpenVINO to where IPEX-LLM landed with SYCL:

Test	t/s	Peak t/s	TTFR
pp256	24.83	—	0.44s
pp512	24.71	—	0.49s
pp1024	24.55	—	0.76s

You can notice though the prompt processing for longer prompts is much better than it was on IPEX-LLM, faster roughly twice. It matters trust me, especially with agents and tools usage which bloats prompts to the limit.

Now a bit more showing off.
I have Intel’s AI PC here so NPU is a power-savvy way to run inference and actually Lunar Lake 48 TOPS 4th generation NPU is in the top of those others sold on the market. You get almost the same power like in newer Panther Lake 5th generation NPU for around 20–30% price discount.
Ollama can’t use it. IPEX-LLM can, through its own NPU acceleration path — but not the way rustedVINO does: serving it live over an OpenAI-compatible API.
What’s more significant, my server can run different models on CPU, NPU, and iGPU at once — and swap one out live, without dropping inference on the other devices. I haven’t found another server that does the live hot-swap part without a restart.

We just need a different model which is prepared for NPU (channel-wise not group-wise compilation).
I had a bigger version on disk Qwen3–8b-int4-cw-ov, here we go:

Test	t/s	Peak t/s	TTFR
pp256	17.24	—	1.50s
pp512	16.92	—	1.60s
pp1024	failed	—	—

Not bad for a model twice as big, isn’t it?
You will ask why there’s an error at 1024 token prompt.
It’s my programmer’s fault. Not really. Thanks to this test I discovered that my server should expose additional parameter at loading model on NPU, that is actually typical behavior when using NPU for inference, you need to set upfront the maximum size of the prompt so model can be compiled exactly to that limit. That’s the NPU’s world where energy saving matters more than flexibility.

What did we learn from all this? Step by step:

Using Ollama on Intel Arc and Lunar Lake works better when Vulkan support gets enabled.
Using OpenVino based server squeezes maximum performance from Intel’s hardware.
IPEX-LLM works with the same models which Ollama uses.
Models used for my OpenVINO server are not the same as models for Ollama, those are Intel prepared models downloaded from OpenVINO Toolkit account.
Bear has some server he didn’t share …yet.

Now I will share this server’s capabilities because I tried them out, hardened them and tested, I’m in the process of building a package for Linux and Windows.

This server is fully OpenAI API compatible, plus it has “Bear’s extensions”.

Feature	Status
`GET /health`, `GET /v1/models`	✅
`GET /health_generate` — 1-token GPU deep-readiness probe	✅
`GET /metrics` — Prometheus endpoint (same port)	✅
`POST /v1/chat/completions` (SSE streaming + non-streaming)	✅
`POST /v1/completions` — legacy raw-prompt completions	✅
`POST /v1/embeddings` — text embeddings (bge, e5, …)	✅
`POST /v1/rerank` — cross-encoder document reranking	✅
`POST /v1/audio/transcriptions` — STT via Whisper OpenVINO	✅
`POST /v1/audio/speech` — TTS (`SpeechT5`, Coqui VITS)	✅
`POST /v1/images/generations` — text-to-image (SDXL, FLUX.1-schnell)	✅
`POST /v1/images/edits` — inpainting + img2img (SDXL)	✅
`POST /tokenize` / `POST /detokenize`	✅
`GET /v1/realtime` — WebSocket voice flow (STT → LLM → TTS pipeline, barge-in, session history/retrieval)	✅
`ContinuousBatchingPipeline` engine — N concurrent streams in one GPU step	✅
NPU LLM engine — static `LLMPipeline` single-stream path (Lunar Lake NPU)	✅
VLM chat — vision-language models (`/v1/chat/completions`, image input or text-only)	✅
Exact `usage.prompt_tokens` via tokenizer bridge	✅
`stream_options.include_usage` — token counts on streaming final chunk	✅
Sampling params: `temperature`, `top_p`, `top_k`, `stop`, `seed`, `presence_penalty`, `frequency_penalty`, `repetition_penalty` (extension field — server applies a `1.1` safety-net default unless the client sends `1.0` to opt out)	✅
`max_completion_tokens` alias for `max_tokens`	✅
Streaming `<think>` strip — `ThinkFilter` removes reasoning tokens from output	✅
Non-streaming `<think>` strip — reasoning in `reasoning_content`, hidden from `content`	✅
Per-model `reasoning_parser` flag — `qwen3` / `gpt_oss` extractors	✅
`enable_thinking` field — explicit thinking budget for Qwen3-style models	✅
OpenAI tool/function calling — `tools` + `tool_choice` (`"none"`/`"auto"`/`"required"`/named function), stream + non-stream; native Qwen3/Phi/Llama3/Gemma dialect, plus Mistral and Qwen3-Coder XML dialects, auto-detected from the model's own chat template	✅
Structured output — `response_format` (`"text"` / `"json_object"` / `"json_schema"`) via OpenVINO GenAI's `StructuredOutputConfig` (xgrammar); chat only	✅
KV prefix caching (`enable_prefix_caching`, default on) — reuses KV blocks across requests sharing a prompt prefix; 49–83% e2e TTFT reduction on deep multi-turn/RAG prompts, measured on B50 and OmniBook (140V iGPU)	✅
MoE detection + `max_num_seqs` cap — prevents CB throughput collapse on sparse models	✅
Response headers: `x-request-id`, `x-server`, `x-api-version`, `x-server-version` (admin-only); CORS config	✅
OpenAI-compatible error envelopes on all error paths	✅
Prometheus push metrics: tokens/sec EMA, TTFT histogram, request duration histogram	✅
Fixed KV pool + slot-cap (`max_num_seqs`, `cache_size_gb`) → no deadlocks	✅
Admission wait-queue (`tokio::Semaphore`, `admission_queue_timeout_ms`) — every engine kind (CB, VLM, embed, STT, TTS, NPU), cancellation-safe	✅
Cross-pipeline device admission (`device_budgets`) — a second gate capping concurrency across different engine kinds sharing one physical device (e.g. LLM + VLM + STT + TTS + embedder all on one GPU); ships disabled by default (empty config ⇒ pure passthrough, zero overhead)	✅ (opt-in)
`finish_reason` correctly distinguishes `"stop"` (EOS) vs `"length"` (max_tokens)	✅
Runtime model add — `POST /v1/admin/models/add` (registers + loads, persists to config)	✅
Runtime model load — `POST /v1/admin/models/{id}/load`	✅
Runtime model evict — `DELETE /v1/admin/models/{id}`	✅
Runtime model deregister — `DELETE /v1/admin/models/{id}/register`	✅
Config reload — `POST /v1/admin/config/reload` (diffs disk config vs. live registry)	✅
Config/registry drift audit — `GET /v1/admin/config/audit`	✅
Voice-flow pin — `GET /v1/admin/voice-pin` (shared STT/LLM/TTS set for realtime sessions)	✅
Realtime session introspection/kill — `GET`/`DELETE /v1/admin/realtime/sessions[/{id}]`	✅
On-demand lazy load (all model kinds) — load fires automatically on first request	✅
VRAM budget tracking (internal; OV Cores are blind to each other)	✅
VRAM estimator: STT/embed/image charge weight-only (no KV pool reservation)	✅
LRU auto-eviction when a new model doesn't fit	✅
`domain_budgets` — per-domain VRAM isolation (llm / embedding / stt / image)	✅
Size/EU-aware STT placement — heavy Whisper routes to CPU, light to NPU/iGPU	✅
Capability-based device placement (`placement.rs` tier preference, no hardcoded names)	✅
API key auth (`api_keys`); distinct admin-scope keys (`admin_api_keys`)	✅
Crash handler — logs a marker + backtrace on native SIGSEGV/SIGABRT/SIGBUS/SIGILL before the process dies	✅
`--supervise` — crash auto-restart wrapper with backoff + restart cap (Unix only)	✅
OpenVINO GenAI C++ bridge (`ov_bridge/`)	✅
JSON config file (`/opt/vino/config.json`)	✅
No automatic fallback — wrong model ID → 404, not a guess	✅
666 tests pass (583 lib + 78 integration + 2 golden + 3 supervisor integration; 5 ignored + 2 ignored doctests)	✅

Clap if you like that idea.
I got sweat doing it.
Two long months and 536 commits.

Still counting: speculative decoding on the way, tested already with Qwen3 family gives 1.3 -1.7 generation acceleration for Qwen3-14B-int8 model on my Intel Arc PRO B70, so it’s worth it.

Disclaimer: All opinions, ideas, choices and rusted cans described here are exclusively my own. Intel makes good chips. I buy lakes, make trouble and solve some of it for myself. These are separate and independent activities.

Hyperfocus Bear Talks About AI and life.

2026-06-08T00:00:00Z

His life mostly.

Da Nang in the evening sunlight — no AI involved.

Everyone likes to talk about AI today. It’s like talking about it adds at least plus twenty points to your intelligence stat, and everyone wants to “max it out.” Many people even take a course or two and they are already certified AI experts. Usually certified by some Big Tech company with an AI product on the shelf.

Those who work hard to create AI for others often don’t bother to explain it, because no one outside will understand it that deeply anyway. Sometimes they explain concepts to each other and they even know what they are talking about and why.

It is not going to be that kind of pitch, though. I want to touch on the “non-techie” point of view. Programmers and people who work with AI on a daily basis perhaps understand it better, but they have no distance from it. Living with your nose inside a chat window or with your agent in your PC is not helping anyone build a healthy relationship.

Some of you might point out that I’m a programmer too, and I use AI. Moreover, I try to write about it.

Yes, it’s true. I have licencia poetica for that, my Dear Critic. Let me point out some unusual facts about me as a programmer.

I started using computers with a ZX logo on them. It was mainly Montezuma’s Revenge, though, I was 10 years old. Then I started to learn soldering and assembling simple electronics circuits. At 13 I was BASIC-ally attached to an Atari 65XE for some time. Then I developed a passion for Pascal on my PC with an Intel 8088 processor and a 20MB hard drive — it was 1991.
Some of you who used PC back then can even answer this unusual question: what advantage does an old HDD have over an old car downtown in a huge city? An old HDD is definitely easier to park. I guess that was the first trace of AI in the 90's, long before cars started parking themselves.

I was deeply into electronics for years. At sixteen I built custom wireless headphones with an infrared link and an FM-quality PLL decoder loop just to avoid winding inductors. Do any of you even know how that works?
Then, after reading a book about Magellan’s voyages and Sir Francis Drake’s “good deeds,” I pivoted my career and finished five years of physical geography studies to become a traveler and a pirate, of course, before Pirates of the Caribbean was even filmed.

River bank in Hoi An in the evening

It didn’t help much with becoming a pirate, but at least 25 years later, sitting in the medieval Vietnamese old town of Hoi An, drinking coffee and eating durian, I knew that Magellan had been here before me, and I knew exactly how fluvial sediments shape river deltas and why he actually sat somewhere else.

My Son UNESCO site

Shortly after, I took an Indiana Jones-style photo of myself, complete with a wet towel draped over my head, at the jungle shrines of My Son. If you want to know what real tropical jungle heat is, go to My Son in July.

Me as Indiana Jones

I have worked in more than half a dozen professions. I worked as a sales clerk. They kicked me out because I tried to help people to buy what they needed, not to sell the garbage electronics what my boss wanted me to push.

I worked in a flour mill. No, I didn’t blow it up. I just left, it was damn hard work.

I was a driver at a facility for disabled kids and youth. It was one of the most rewarding jobs emotionally. Those kids either love you or hate you, they cannot lie about their feeling. I felt loved.

I was an electrician and team leader on big sites for years. They say an electrician only makes a real mistake once. I made two, almost died, still here

Big site somewhere in this small world (or opposite)

I was a seed plant automation expert. I ran 4MW flame burners with enormous flames to dry 60 tons of highly flammable seeds like rapeseed, and I never actually burned anything down, although I saw a couple of others do it. Hot subject, I might say. Oh, and before I ran that massive dryer, I built it from scratch and put it into operation of course.

4MW gas burner flame. I know it looks hot.

I managed site logistics on sites where you needed a bus ticket to get around. I was out there pouring concrete on them at nights, mostly just to make things easier for the bus.

I speak five languages, and some of them even fluently. None to perfection, just classic “Pareto-good”.

Tea shop, Mardin Turkey 2012

I ate breakfast alongside Kurdish militants with grenade launchers at the table in Ceylanpinar Turkey 2012 — just 500 meters from the Syrian border, while shots echoed in the distance.

Mardin — ancient city in Kurdish part of Turkey

But I also met many Arab kids there, and despite all the war around them, they were still smiling.

Arab girl playing with Granny.

I’ve been lucky enough to try some food around the world.

I tried this what lives in the water

Mix of snail dish served in Vietnam

I tried those which can fly (not any more)

Whatever bird they chopped apart.

I tried those who tried to escape

Fried freshwater crab, of course not trying to escape.

I ate the weirdest breakfast on Romanian 7000 hectares farm.

Weirdest breakfast ever — no AI known at time of making this photo.

I’ve run into American tractors all over the world.

Me and John Deere- he’s that bigger one by the way.

With enough grip for absolutely anything, he doesn’t need AI at all.

I drove my car through the Moroccan desert alone at night to Marrakesh. But I didn’t just drive through; I sat down to share a meal and was welcomed like a family member in a local village where my colleague lived.

I watched my friend’s brother take part in a traditional Moroccan Fantasia 80 kilometers outside of Marrakesh, somewhere deep in the desert. Charging horses, blinding dust, and the deafening roar of synchronized musket fire.

Then, under the bare bulbs of the Marrakesh medina, I sat down with friends and ate a sheep’s head.

I made a couple photos around the globe, perhaps some of them even not bad

She just was there.

Those were just standing.

I lived two years in Russian Stavropol and almost stayed there — because of the money and the architecture of course. Not for any other reason.

Stavropol Russia 2018

Now please go to your software department and ask around. If you find a programmer like that, just let me know.

But let’s get back to the AI discussion. I promise I didn’t bring any grenade launchers back from Turkey to blow this miracle away.

Today anyone who wants to shine talks about AI.
AI this, AI that. Agents here, agents there.
Entire agent armies (no heavy arms involved, though)

It’s such a fascinating topic.

Will it kill us or empower us?

Will it make us poor, or will it create a guaranteed-income society? Both, perhaps?

Which “us” will benefit most from this revolution?
Big Tech?
Governments?
Ordinary people?

Unfortunately, “AI” is a container word.
It can be a badge you stick on a product with a weak NPU inside just to sell it at a higher price.
It can be a product for the masses, designed to make them dependent on yet another subscription — without which life is supposedly so much harder today.
A long time ago, young people stopped using libraries; now, some of them have stopped using their brains altogether.

We are starting to accept this situation, even when we understand that AI is usually just “Pareto good” at everything. Competent across the board, rarely exceptional at anything. Organizations have started replacing people with AI in ways no one would have dreamed of three years ago.

Of course, it’s done in people’s best interest. Nobody said it had to be the same people.

I have my own concept for explaining LLMs to non-techies. I usually say: AI is a concave stochastic mirror covered with smoke.

You “look inside” it with your magic prompt, and you receive a picture painted by a half-blind mental giant. If you are not an “AI magic” practitioner, you might sometimes think this giant is an idiot. And honestly, if you are not a real magician, you can’t tell the difference between the giant and yourself.

I do not intend to insult anyone who uses AI and LLMs in particular without knowing enough about their limitations.
“Knowing enough” here does not mean simply knowing that AI is imperfect. We are all imperfect by definition. Why would we expect AI trained on our imperfect knowledge, by imperfect brains, to be perfect?

Did I overlook something here? Perhaps stochastic mechanics and some probability rules. Nothing particularly easy to understand.

What’s in it for you?

Embrace this new tool wisely. Don’t reject it — there’s no way; you can’t stop a tsunami.
But even if you are good at surfing digital waves, ask yourself: where will that tsunami take you?

I’m afraid you will not like the spot.

The only hope is within us. We are the creators; AI is just a tool.

See my creation of CutieB here: /blog/the-cutieb-is-born

Hyperfocus Bear: The CutieB is born.

2026-06-07T00:00:00Z

The Star was too late but older Brother never fails

CutieB and Bigger Brother Undercover (coming soon)

They say if it ain’t broke, don’t fix it. I never believed that rule.
It’s boring and predictable, gives no space to break something and learn how to repair it just right after.

My TinyB PC I built last month was not broken. It was just not tiny enough. I felt the urge to make it really small to make my Intel Arc Pro B50 feel really cozy. How do you do that?

You just buy a small Jonsbo C6 ITX casing, I thought to myself.
I like Jonsbo’s aesthetics, quality, modularity — it just speaks to me.
So I bought that ITX casing even before I checked how hard it is to obtain an ITX motherboard. Call it “honey rush”.
The casing itself is small and cute as you see on entry photo and below. My new build immediately got its deserved name — CutieB.

Jonsbo C6 ITX on top of cardboard A3 format

Jonsbo C6 ITX “exploded”

Because I’m still waiting to become a millionaire (playing lottery doesn’t work well), the build of my platform was restricted by budget.

I hate budgets — they never work.

As usual in life, my broken genius is followed by incredible luck, I got used to it already. I found an ITX board, the last piece available in the universe — or I think so.

Gigabyte B760I AORUS PRO box

It was the Gigabyte B760I AORUS PRO, a beautiful piece of electronics, but it requires DDR5 RAM. So I decided to “go-scroogy” and buy only single DDR5 16GB RAM module.

GOODRAM GR4800D 16GB DDR5

Single-channel operation plays no significant role here; the Intel Arc Pro B50 won’t spill over into system RAM by design.

Gigabyte B760I AORUS PRO

Gigabyte B760I AORUS PRO — back panel.

This build also required a capable but not oversized CPU.
I love Intel CPUs they have all what I need - you can always find an adequate size for your use case.
This PC is mainly for local LLM inference on Intel Arc Pro B50 at that point so I decided to buy the i3–14100 with 4 cores, 8 threads (hyperthreading) and UHD730 iGPU unit. Remember that the i3–14100F version has no iGPU — just in case you think you can be smart and save something here (I told you — budgets rarely work).

After having a not-so-splendid experience with mounting Intel box fan at the last build (I have some thoughts in another article), I decided to buy this CPU as an OEM version without a fan.

The fan choice conditions were obvious and strict:

the fixing mechanism must withstand rhinoceros courtship.
Some heat dissipation will be needed too — rhinos in action can get intense.

So I got the Thermalright AXP90-X47.
I know, that name fits one of Elon Musk’s children well. I like the “Thermalright” part the most. I tested it. It allows to dissipate effectively 130W.

There is one important thing you shall not forget in your PC build, unless you like to jog while working to provide energy for all those elements.
Buy the right PSU.

In such a small build (ITX), your PSU shall be rather small, unless you want a small, cramped, hot PC. In that case, don’t bother with a custom build; you can buy an HP Envy TE-02 instead — it’s not the smallest, but nothing overheats better than that one.

I went for the Seasonic SSP-300SFX Active PFC F3 300W unit. Apparently Elon was nearby when they named it.

You can’t find a boxed version of that PSU, you need to live with OEM, but at least the additional mounting bracket was delivered in the set.
This PSU is not 80+ Gold standard, but in fact it works as good as one — I measured it, it consumes at standby half of this what Okame 650W +80 Gold needs. You can see the size difference when placed alongside a standard 500W ATX unit.

SSP-300SFB (300W) in front of 500W OEM PSU unit.

Having all those elements piled up, I started to assemble this little unit.
PSU mounting was the first step. Check, measure, check a second time, reassure. As they say — measure twice, cut once. Sometimes I even use that advice.

Bracket for SSP-300SFB inside of Jonsbo C6 ITX

I needed to remove one metal strip and fix the PSU adapter bracket on the casing frame. Everything fits well.

Then fixing the PSU to the adapter — I chose that way because it’s harder, obviously. Bear never chooses the simple path.

Fixing PSU to bracket requires bit of dentistry (remove elements) and acrobatics.

You can use this trick with magnet if you have small bolts to put in tight space:

I also forgot to put the mains cable in so it is easy to connect — don’t follow me exactly, there is a better way. I just unbolted one side of the white, perforated bracked which was in the way.

Easy-peasy — the PSU is whirring away. Hanging, I meant.

One thing which is not so well thought through in this casing is the air ducts to guide hot air or lack of it. The PSU effectively blends air inside the casing when the walls are closed (you can see that further in article). Hence I said earlier this kind of casing is not suitable for a big PSU and hot CPU/GPU units.

Let’s make the motherboard shine in this setup.
I confidently fixed it to the frame.
Good engineer never reads the manual, right?
We’ll come back to that in a moment.

The Gigabyte B760I AORUS is in place, CPU goes into the LGA1700 slot.
I love patterns — perhaps it’s my ADHD brain that makes me do that.
CPUs have patterns, tiny cute resistors on the bottom and hundreds of contact pads.

Intel i3–14100 bottom view in macro mode.

That love to patterns and my artistic soul made me to follow strictly(less) the instruction to apply thermal paste according to a pattern. This time I chose thermal paste over a thermal pad. It is easier to apply but is it really?

Instruction says:

Bear artist does:

Andy Warhol and Picasso are ready to invite me to a little Absinthe party, but I just left one. I tried to get back to reality and make this application more normal.

Normal application of thermal paste with some significant margin to spread under load.

Next step — heatsink and fan on. Beware, rhinos.

Thermalright — always right.

Set with Tour Eiffel elements.

Looking at the pile of elements delivered by Thermalright, I was hesitating for a while — what exactly can I do with that?
Beat Mr. Eiffel and build something bigger?
There are multiple elements delivered and the manual is not really very expressive about assembling.

A true engineer treats the manual as a Bible — you eagerly read it after you put yourself in trouble because of your own idiocy. I decided to give it a try anyway.

After some fiddling with bolts and bracket I got it right finally and identified which bolts and nuts need to be used and how the support bracket is fixed properly.

Thermalright support bracket

One note though — the thread sizes and nuts are really small here. Thermalright delivered a suitable adapter to tighten the nuts with a screwdriver. Don’t use the screwdriver, use the adapter and fingers. You don’t want to see that thread ripped off.
It will happen if your hands are like mine. I can rip off a thread on a 13mm hardened steel stud when I look in the wrong direction (after girls mainly) while tightening it with two fingers.
Do not over-tighten — let the spring force from the back plate do the job. It’s a capable back plate (1,5mm of steel) and you don’t need to juice that CPU, you only need good thermal contact.

I told you about my luck earlier — now you can see how good it really is. This fan fits on that board as tight as a Bear in a diving suit — I know, I tried diving.

Gaps on side of this heatsink are nonexistent.

No gap here either.

So now I shall place my single DDR5 RAM module. It was easy. Gigabyte, opposite to ASUS, didn’t reinvent the SDRAM slot (one side locks, brrr) — it just works. Thank you.

Then I put this fast ADATA LEGEND 900 NVMe drive inside.

ADATA LEGEND 900 NVMe

But first let’s stick the heatsink on it — it’s delivered as a separated piece.
Done, not completely straight as usual — recognisable “Bear Paw” signature.
Now, where is this NVMe slot?
Where did they hide it?
Manual shows no details.
Is that an NVMe slotless version?

No. There is an NVMe slot.
Exactly where placing it is most inconvenient — on the bottom of the motherboard, under the black anodised aluminium frame. You can see its edge on photo below — bottom right corner.

NVMe slot undercover — thank you Gigabyte.

So to put the NVMe drive there the whole motherboard must be removed. Good, I was already bored finishing this build.

I pulled everything out — luckily it does not require removing the CPU and calling rhinos to help.
I got the aluminium frame off and put my ADATA NVMe disk there.

Bottom view with aluminium frame detached.

I’m so proud I did not forget to place the heatsink on the disk chips.

Adata Legend 900 with heatsink

Now I just need to peel it back off, because Gigabyte made the whole frame to be a radiator for the NVMe.

Shame on you, silly Bear — never rush with sticking something on top of something else. At least Gigabyte’s quality and technical planning in the case of that board is really top class, everything foreseen. This motherboard is not cheap - 200,- Euro gross.

So here we are, last steps — connecting cabling around the board. Remember to check if you placed the main motherboard power plug correctly, all the way in.
The latch must be engaged properly. The strength required to do that is adequate to call for rhino’s help. Ask me how I know about checking it twice. Or better — don’t.

Last step to follow, add the tiny, noble resident of that digital house: Intel Arc Pro B50 16GB VRAM. Now it looks properly sized for the company and it’s workplace.

I got this CutieB as tidy inside as possible, I even separated audio cable from others just in case someone is curious enough to use front audio output. Nothing fancy really — I’m not an artist, as you might remember from my cat generating adventures.

This photo clearly shows the PSU-air-blender problem as well. Intake from the right, exhaust to the top — swirl, Baby, swirl. The wall-mesh structure helps here a bit, but I wouldn’t dare to run anything here that needs to work under serious, long-term load, unless there is an additional fan pushing air into this enclosure — a thing to improve in that build, clearly.

So we are done, now party time. The proper opening of a newly built house/PC in Poland requires putting into operation some disco lights and liquid celebration — alcohol free, of course, in case you ask.

Now a bit of testing alongside BBU — Bigger Brother Undercover.

You shall expect some continuation of this endeavour….

Disclaimer: All opinions, thermal paste art, clumsy paws, light color choices and questionable purchasing decisions described here are exclusively ol’ Bear’s own. Intel makes good chips. Bear makes trouble and solves some of it for himself.
These are separate and independent activities.

Hyperfocus Bear meets AI and gets split.

2026-06-03T00:00:00Z

We all know what slop means, I hope. During the last three years we’ve become experts at recognizing it, and we’ve started to hate it — because it’s everywhere, relentless, unavoidable. But I want to show you why I think it doesn’t matter as much as we fear, as long as you can recognize it and use it for something.

Let me start with a confession about my face.

I am not a natural model. I’m a substantial chunk of a guy — round-squarish head, excellent ears. The ears are genuinely exceptional: they provide great visibility, solid listening function is a secondary concern, structurally sound hearing aid included. When I walked into a photo studio for a short session, I was hoping to present myself in an original but natural way.

What I got was this portrait of a well-fed prince.

Peppa’s brother photo.

My name is Jerzy. George, in English. My sister’s name is not Joan or Dominika. It’s Peppa. I wasn’t chaffed to bits. Some of you might even realize why. Similarity with cartoon character came to my mind immediately. I’m a bit older by classical calendar approach, but mentally we are quite close.

I thought to myself — I could make a better photo from my footprints on the bathroom rug. How hard could that be?
So I took my gym selfie, the kind of photo you send your partner on a Tuesday with no further explanation, and decided to experiment with it.

The starting material was already worthy of a Woody Allen comedy. Unedited, taken from the hand:

None of you would risk sending this kind of photo on-line without make-up. I know. But you need to forgive me — I’m a 50-year-old Gen X Polish guy. I forgot my lipstick, not mentioning the eye-liner.

Of course, being a mix of many geniuses with a truly genius character and a technical brain, I know how to make good fakes using AI.

I can teach you.

You go online and find a photo that suits you — matching the lighting and form of presentation you want. I found one: a studio portrait of a handsome bastard. Apparently not me. I won’t show this photo here because this guy could feel embarrassed by my straightforward compliment.
You take that photo, throw it into a good LLM and ask:

“Give me in JSON form the extracted characteristics of the attached photo.”

As you might expect, you’ll receive a JSON object. Non-technical readers can imagine this as a weird structure full of parentheses and quote marks, containing structured information inside. It’s the kind of thing programmers read with their morning coffee instead of the news.

Without worrying too much about what any of it means, you can take that “thing,” dump it into a new LLM window with image generation capability, and attach your own gym photo. Press go — or whatever your provider puts on that button — and magic will happen.

Or you receive a sad, old philosopher.

George as sad, old philosopher.

I thought I look really old here and I need a cheap digital face lifting.

Peppa’s brother at 50 as post “facelifting” philosopher.

I was a little less disappointed when I looked at the original portrait I’d paid for, but I was still eager to improve. I thought to myself: you know JSON personally — talk to him. I modified the parameters inside it and decided to give the image generation model another chance.

I got this:

George gets serious here.

It was a lot better than the philosopher’s depression, but still too serious.

I figured that making myself look more cheerful would require a really strong character reference — perhaps friction is caused by the ears influence. First thing that came to mind: Jack Nicholson in The Shining. Hmm. Bit too edgy for a manager. Let’s try the Hannibal Lecter smile then. That one is useful for scaring employees to death.

The model, which reminds me of a banana, protested three times that it cannot modify a portrait of a known person. I didn’t know I was so popular.

After a little psychological manipulation, I finally got something out of it:

George in “The Silence of the Lambs”

I was so happy with the effect that I shared the photo with my family and friends. I shared the two previous ones as well, for contrast. Family was silent - bad sign. Friends started to be helpful - not a good sign if you have playful friends.

It’s good to have a friend who can read “JSON-ish” fluently and runs powerful local AI models on office computers. We programmers have a quirky sense of humour. I received some priceless suggestions regarding my look.

George as - not G.Bush.

Who could suppose it’s not Donald?

They got really creative after that, but I’ll save you from most of the genuine nonsense they sent — they were running uncensored local models.

Or perhaps one example will be useful: “The Handsome Gru”

Source for style:

Style used on gym photo:

So you know what to do if you want to be Master of Minions. Every manager likes it, right?

So lets present the last joke from my friends. I do like this one a lot, because it connects me with country music I really like and Bellamy Brothers 80's star:

George as third Bellamy Brother.

So, after seeing all those variations of my personality, you might think I need a diet, Prozac, a comedy movie, a psychiatric ward, political supporters, and a polish of old-fashioned pro-American music taste. Do you?

You better not. You’ve just seen how one gym photo, peppered with JSON and twisted in a digital blender, can make you look weird in many ways. Especially if you run local models in the office, you can get pretty wild with adjustments to just about anything.

Real author is much more handsome when smiling:

Almost like Bratt Pit

Or even better when simply having a better angle and not trying to look like Keanu Reeves. It’s mainly about the hair length, I think.

Jerzy Marek Majchrzak

If you like my style of introducing readers to technical subjects, look through my other articles.

The Hyperfocus Bear was born.

Hyperfocus Bear: Dirty Spies, a Rusted Can, and a Bad Idea

2026-05-26T00:00:00Z

You better be prepared for me Ethan..

When I see a tight gap with razor-sharp edges and darkness inside, I always want to put my paw there. It’s stronger than the survival instinct.
When I see that my custom-made solution can be made even better, although it is hopelessly risky, I say — how hard could that be?
Nothing is more interesting than going where no one goes because it’s not interesting for them.

I like empty space without people. The only empty space that scares me to death is my empty tummy. Most scary dream of every Bear — opening a honeypot and finding nothing. Not for me though.
It just isn’t. Ol’ Bear says to himself — I’ll find those damn bees and they will pay, honey.

What is the best way to track bees, you might ask? Run tests, of course — every manager Bear knows that.
Pure logic would bring you there if you are one. Ten years of being a programmer makes the matter much more obvious, though.
So I run tests. It’s all because my TinyB hive ruined my vision of a custom OpenVINO server which is fast.
I need to tell you now where all that comes from, because otherwise you might start to sting.

After I finished building my cute TinyB, what was a really fruitful adventure during which I found my pocket Unicorn, I installed my custom OpenVINO server on it.
Of course, after installing something new on something new, you need to do… a catwalk. So I did — to compare performance with my envious EnvyStorm and its Intel Arc Pro B60.

What happened later I wanted to blame on HP, but it didn’t work out.
My TinyB got splendid results in the fashion category and inference speed — 38 tok/s with Qwen3–8B, after using some fancy math that actually fitted into its VRAM throughput.
I was flabbergasted. Unicorn was bored — he just muttered: I told you.
I thought to myself that now we must run the same test to compare on the Intel Arc Pro B60. I expected a difference as big as the physical size of those cards.

Intel Arc PRO B50 on top of Arc PRO B60

There are disappointments, and then there are the results of my tests on the B60. I was completely shattered when I found that I had chosen the wrong card to build that server. That B60 is a huge, not-cute-at-all thing and it works at only 47 tok/s with Qwen3–8B.
I checked multiple times. I took the card out of the tight, ugly submarine and hugged it like my baby.
I talked to it for a while to distract her from the fact that Corporal Claude was making extensive reconnaissance around HP Envy — checking every bit and piece of the digital landscape to prove that our B60 was hurt by bad people from outside.

Claude responded: It’s not his fault. He’s family now.
Maybe we are not Italians from the South, but Polish stick together and accept Blue. Only Polish one on that team is Bear — but who cares today, it’s not 1955. A true soldier cares for country and family. Claude did his best.

I pointed him to Intel’s article about B580 performance to set the guidelines and find some reference for the defense line. We got some numbers on the map, we started tracing paths through the token desert.
Our poor B60 with my server produced 47 tok/s. The reference for the Intel B580 — same family, same silicon — was 70 tok/s.

Someone chained my baby’s legs when I wasn’t looking. Perhaps it was even a clumsy ol’ Bear of unknown origin. I have an allergy to blame-shifting Bears, so I asked Corporal to launch an intense offensive with simple Python scripts — to prove that my Python knowledge (level 2 on a 2000-point scale) was not the cause of the B60’s misfortune.

We tortured the whole system for perhaps three hours. Conclusions grew like mushrooms on warm… maybe not like mushrooms. Maybe like a pure engineering report. Surprised, huh? You can see that report here if you don’t believe me. Generally it’s a waste of time for a tech-ie. Don’t go there unless you’re a boring engineer.

Summary for non-techies then: my Python skills are great — I mean Claude’s, of course but I’m the manager.
True manager always shares success with his employees, right?

By being persistent and loyal towards Intel Arc Pro B60 we discovered something called a ceiling. Most of us have seen one once or twice. Some of us have even seen a glass ceiling. Some of you saw it in Python.

Those who read boring reports and have more points on the Python excellence scale will understand ol’ Bear’s nonsense talk here.
I ran another incarnation of Corporal Claude. Trust seems to not be deeply ingrained in Bears — opposite to intelligence.
A different Corporal was, of course, fresh — no digital mud on his uniform, head ready to accept the most challenging orders from a trustful manager.
Here we meet. Tears in my eyes. I like when people trust their managers. Just not too much.

I told him — I give you this link, it will burn in 30 seconds, you have a mission. It is possible.
This link was confidential, but I have a carbon copy here.
Then I ordered him to check if my other Corporal was loyal — he was also obliged to find some dirt on Unicorn.
They told me some of those Corporals were trained by KGB. They may be right, but the ones I meet are rather from MIT.

My second Corporal came back after reading the repo and reports prepared by his older brother in arms. He confirmed all suspicions and added his own conclusions.
It was all very confidential — as usual in case of a mission possible — so I had to finish him after that. I felt bad, but a secret is a secret.
Farewell, Ethan Hunt.

With those proofs in hand I started to think about revenge (Italian blood in Bear) — who can pay for that?
Intel?
HP maybe?
What can I even do about it?

Wait, am I hungry? Let’s look under my desk, see what we can find.
Nothing.
Only a rusted can.
At least it’s not rusted VINO, I thought to myself.
How hard could that be — to get VINO rusted. Is it even a good name?
RustedVINO…

I asked Corporal what he thinks about it and he answered with a metallic voice that Rusted is a blast, but Rust is really fast.
What do I know about Rust, though? One point more than about Python.
I installed Cargo to get into bodybuilding.
It was too light for me.
I read something about missing garbage collector.
I was afraid that whole garbage will be dumped on me.
I heard something about a borrowing pattern.
I’m not keen to lend anything to anyone.

I did one project in Rust — more ambitious than “Hello world!”.
It was an upgrade: “Hello world. Did you see Unicorn somewhere?”
So… how… hard… could… it… be?

Disclaimer: All opinions, ideas, choices and rusted cans described here are exclusively my own. Intel makes good chips. I make trouble and solve some of it for myself. These are separate and independent activities.

Custom OpenVINO Server — ol’ Bear and hyperfocus honeypot. Part 3.

2026-05-24T00:00:00Z

“Wakey, wakey, ol’ clumsy Bear — it’s me, Nicole.”
I heard that in my dream, whispered in a soft voice. Shoot. I’m in trouble now. My fierce Vietnamese partner will tear my ears off when she finds out about that romance. I woke up shivering.

No one by my side.
Hard to decide — disappointed or relieved?

Who the hell is Nicole? How did she land in my head?
The whole day those questions lingered in the back of my mind.
To suppress this returning, soft, tempting voice, I threw myself into improving my experimental server. I know you, ol’ Bear — if you get your hyperfocus honey pot, you won’t pay attention to voices anymore.

I fired up a dark window to “Honey Pot” street and brought to life my Shiny Bit-Brain Corporal Claude. I decided to do some testing with multiple scenarios to prove my router works well.

I was wrangling the server, curl-izing it by hand while Claude watched the logs. That gave good results — but when I asked Claude to generate curl commands for me, he was damn clumsy with formatting them (or maybe it’s just me), and I constantly stumbled on bash errors about some unrecognized command.
How hard can it be to understand, Bash? Take an example from Claude and use your wits. Bash didn’t, though.

So, using my deeply ingrained ingenuity — too late as usual — I told Claude to stop bombarding me, his manager, with silly tasks and go do the dirty work himself.
From that moment on, after each iteration that extended or corrected the server’s guts, I ordered kindly with sergeant’s confidence: “Fire the test and curl-ize this damn thing!” It’s like having your own platoon — except they don’t get wasted when you release them for the weekend.
Thank you Mr. Oliver Stone.

Step by step, bit by bit — maybe even byte by byte — we moved forward through the dense jungle of code. No GPS, just Claude and me.
Brothers in Arms.

I found an interesting article about Python that day — specifically a piece on [https://towardsdatascience.com/the-joy-of-typing/]. Coming from a C# background, my eyes practically wept tears of joy at the sight of actual typed variables and strict data validation in Python. It gave me a brilliant idea for an architectural refactor, just in case if some day I will need to look at the code written by Claude Code. So the refactor was scheduled and tests went on and on.

At some point during testing I noticed that my SVP panel had a serious flaw. It ran in the same process as the server, so whatever problem the server had, the panel caught it too — less intense than VD, but equally annoying to diagnose. Shared process, shared suffering. Time to get divorced.

SVP got its own life as a separate service, running as a sidecar alongside the main stormVINO server process.
From that moment it was easier to diagnose issues — server stats read from outside the main process were always available, even when the main thread was frozen. Positive side of an open relationship.

The next evening I didn’t have anything particular in mind, so I started fiddling with an image generation model.
It must be easy — I watched a YouTube video once where a girl used AI and it broke in the middle of the process. I got scared to death.
I don’t watch YouTube anymore.

But a private server is safe. No exotic beauties inside — I checked personally, because my HP Envy case is wide open constantly to let the Intel Arc B60 and my i7 CPU with its enormous cooler breathe. HP placed them so close together — NVMe drive wedged between that it’s practically submarine crew quarters — cozy, steamy, everyone breathing each other’s exhaust. Before the B60 joined the party, this loud, brutal monster RTX regularly pumped so much heat into the poor NVMe that the whole arrangement ended in thermal dead freeze.

Did I mention how hopeless the HP Blizzard motherboard is?
Did I add cramped casing to it?
Not using cramped, sealed casings with huge, powerful hardware should be as obvious as not bringing winter clothes to Da Nang in July.
Shame on you HP.

Graphics then. How hard could it be?

We went through discussion about cost of the project and decided to save on that functionality for now using sdxl-int8-ov (3.5 GB, INT8 quantized). Saving pointlessly on wrong features - very useful manager skill…
Twirly-whirly-wee and Claude made an endpoint for image generation.
Here we go Claude, make a curl query and ask for “a picture of a cute cat.” Resolution?

I don’t care as long as it’s visible. Picture came out:

INT8 quantization LSD peppered.

Claude, did your mum have a thing for Andy Warhol? No?
Alright than this model seems heavily overquantised.

Let’s invite something better to give birth to my second cat: sdxl-fp16-ov.
Now try again, but harder. I already lost my interest in YouTube.
Save the cats for me.

Better picture of a cat but still not perfect.

Hmm right, it’s not Banana at least.

Enough Picasso dressing for ol’ Bear — I’m not an artist anyway — finito!
The only movie I’d want a part in was that one with the Blonde Lady and the flying dress. Andy Warhol would be proud of my first locally generated cat ever.

Wait a minute. Lady… Voice… Nicole!
Yeay! I was dreaming about a voice assistant. How hard could it be?

Claude says it’s easy so we can do it.
Mostly him of course, I’ll command from comfortable chair using my management skills. “We have a beach to conquer, Soldier”

I described to Claude that I wanted a fully local loop: STT → LLM → TTS, equipped with web search — which was actually implemented already.
We started as proper experienced engineers do.

From end to start.
We implemented TTS first because I was rushing to meet Nicole.
Probably you heard them say: true love doesn’t always strike at first sound. I saved on dating expenses, used Piper TTS, and met some less interesting personas along the way. Disappointment level similar to Tinder usage, just without the photos.

So I went to my fidel Claude to talk about girls .
Corporal showed enormous discipline on duty, avoided private talks, but responsibly nodded his head towards something named Kokoro.

I didn’t know that this TTS model hides inside some American girl, perhaps that’s the one from the movie? Blonde. Whispering. Figures.
Honestly usually I’m into brunettes but it’s just a voice.

Kokoro has 15 female voices (11 US / 4 UK accents). There are male voices too, ladies — I think I saw Barry White in there. Enough languages to fill a Tinder favourites of a globetrotter guy. Check the full menu yourself.
I chose Nicole to be my…No I didn’t!
I chose Kore as my assistant, because I like Asian food cooked at home.

Alright, engineer with unfinished geography diploma— next logical step in the process then, the start of course: STT choice.
Lesson learned here, I don’t save on quality anymore, model chosen: whisper-large-v3-int8-ov.
Add a small mic button in the SVP panel — make it look sexy Soldier, Nicole deserves it! Kore I shall say.
Fix it with invisible wire, and let’s test.

Sweet and dandy my little corporal — ready to be pressed!.

Of course it works from the start.
Of course it doesn’t.
Let’s blame HP for that. No mic on the Blizzard motherboard.

It was exactly 1:30AM so I called Logitech Taiwanese office in Hsinchu because they were open already. Three minutes later my USB Logitech camera was conscripted as a microphone.

Thank you Logitech, shame on you HP.

Press — speak — and wait. Wait.
Why doesn’t it respond?
Because it’s a great listener?
Doesn’t like to disturb?
Maybe but I know life.

In reality the silence detection threshold was too high. Fix it, Soldier.
Now it’s better — and surprisingly it works on the first try. Then it breaks on the third, talking Romanian when I’m speaking perfectly good Polish. Not everyone is so optimistic about it.
Those who’ve met me personally know I talk fast and overuse silly comparisons, slightly spicing them up with the most known Polish k-word. But it wasn’t me.
Whisper likes to know upfront what language is coming, or it sets itself to auto-recognition mode. This mode confuses Polish with Romanian sometimes.

Honestly Claude — don’t make BS excuses about vowel clusters similarity confusing language auto-detection. What does it even mean? I think it was because I asked three times for ‘HP-grade’ casing craft courses. In Polish. Three times.

Alright, I agreed to chalk some directional arrows for Mr.Nosy Whisperer. Turns out, he needs to know upfront what language is coming to work optimally. Claude spun his silicon bit-brain and added a tiny toggle to the SVP dashboard — allowing me to switch between Auto / EN / PL modes and starting to feed the explicit language parameter straight to the Whisper pipeline. This solved the issue of Whisper misidentifying my spoken words. I told you it’s not my fault, Claude. Manager is always right, right?

There she is… I mean the voice function of course.

After a few clicks a new ghost appeared in the machine: even when Whisper decoded the Polish perfectly, the LLM server would occasionally decide to reply in English (or vice versa).

I’ve watched The Exorcist, and I know exactly what a machine speaking in multiple tongues means.

It was well after midnight, and since neither Claude nor I wanted to make enemies among spiritual beings, we called it a night and went to sleep.

I had a dream. White, ephemeral, tiny Angel was humming holy OpenVINO song. I asked for his name and he said: I’m TinyB.

Coming up in Part 4: How we performed a digital exorcism on the language-switching bug and finally achieved the holy grail: a fully local, voice-controlled assistant that doesn’t report back to Big Tech (and has Nicole’s voice sometimes).
Whatever more comes there is still in Hyperfocused ol’ Bear’s head.

Disclaimer: All opinions, thermal disasters, clumsy paws, voice choices and questionable purchasing decisions described here are exclusively ol’ Bear’s own. Intel makes good chips. Bear makes trouble and solves some of it for himself. These are separate and independent activities.

Hyperfocus ol’Bear — building Tiny-B hive with Intel Arc Pro B50 16GB

2026-05-24T00:00:00Z

Bears like honey. You can find honey inside a hive. Enough reasons for me to build one.

I was eager to try out Intel Arc Pro B50 16GB GPU because it’s tiny and it needs only 70W when you push it to make digital honey — I mean LLM inference.

Surely you read somewhere that this card is for professionals and it makes no sense to buy and use it in your PC. It’s too weak to play games and too expensive for watching YouTube. You need to be a mix of AutoCad fan and video cut freak to waste your money on it.
I’m none of those two, neither a mix of them — I like to waste money though. That sounds like a perfect challenge for ol’ Bear. I don’t believe what people say about honey taste before I put my clumsy hands in a honeypot.

Claude was woken up by me and he was immediately in good mood. Suspiciously good mood. Either he’s a real “X man” or he’s never met my ex-wife. We discussed briefly (somewhere between 4–5 hours) what options we have. I was thinking through. I was thinking around. Under and above. Checking prices, making twists. Luckily Claude is an angel and didn’t lose patience. This thinking session brought nothing apart from inflated DDR5 RAM prices and my budget concerns.

Next day I had already a much clearer path drawn in my smooth shaved head. It was even easier to push forward because I found some 50€ discount offer on Intel Arc Pro B50 16GB in Polish PC parts provider x-com.pl. GPU final price ~400€.

I’ll buy an older motherboard with DDR4 support. It must be an Intel chipset though — I like resizable bars and Intel Arc likes them even more.
I have two 8GB DDR4 modules which I plugged in EnvyStorm — my main PC with Intel Arc Pro B60 24GB. I can use those two in the new PC — EnvyStorm stays with 64GB in that case. That way I save 500€. That would be the approximate cost of 2×16GB DDR5 RAM. Additionally, older motherboards with DDR4 support can be sourced cheap now. In the case of local LLM usage, VRAM size and speed matter most — system RAM much less, as long as you don’t spill the model into it. Finding a cheap motherboard was not easy but I got an ASUS H610 for 70€. So good deal, ol’ Bear.

Let’s find some CPU brain for that MB. I started to tackle this subject discussing options with my corporal Claude.
My conditions were a pure contradiction, mixed with high technical demand and low price expectations. Human nature manifestation at its peak. We started from “power-savvy and minimalist”, ended at “must have 10 cores and GPU 770”.

Intel, please — can you fill that niche with something for me? Cheap of course.

Finally I decided to buy i5–13500. Not cheap, nor accessible.
Luckily X-COM.pl had a boxed version for 300€ (only). Why not — let’s make that Tiny-B a bit more capable to deal with my stormVINO server multi-GPU flow.

So MB checked. RAM checked. CPU checked. Intel Arc Pro B50 checked.
It shall be named Intel Arc Cutie Pro B50.

Dang it is cute and tiny.

So now PSU — or power supply for those who don’t like tech talk mystery. I calculated with Claude and we decided that 300–400W with 80 Gold class will do the job. I was looking for it. Looking. Still looking.
I found Unicorn.
I found Elvis Presley’s shoe.
But no such PSU. Unicorn looked as cute as Intel Arc Pro B50 and he was not much bigger. I hired him immediately onto our team because Claude winked at me with mad intensity and I always wanted to have pocketsize Unicorn. How about you?

Stop praising unicorns and get back to the drawing board.
I wanted TinyB to be power efficient and silent. The idea is it will run 24/7 practically as a server for my personal website where you all can go and talk to my stormVINO server.
When you go there and my website is down, that’s because I’m broke and TinyB is off because you didn’t like my writing. So PSU with 80-Gold class was a must.
If you slept on electronics workshops or signed up for art lessons instead (silly you) — I remind you that a PSU works most efficiently when under load around 40–80%. Remember that if you plan to buy a new one for your PC. Calculate power consumption of all elements and buy a PSU with roughly 20% more power — not too much.

I needed perhaps 200W maximum with CPU and GPU pushed to their limits. That’s why I selected Okame 650W 80Plus Gold. I like to break my own rules.
If you’re not in Poland you might never have met this brand. It’s a Polish brand produced in China. High quality though — modular cabling and good electronics (I’ll prove later how good, really). It is not cheap of course — middle price, let’s say around 70€.

Okame 650W 80Plus GOLD

As usual, when I’m in “Toys for boys” shop my expense discipline lands in a dumpster. Alright — if you have spent already 840€ for internals, ol’ Bear, we won’t save on casing.
At first I was planning to squish all that in a micro ATX casing and seal with hot glue to make it hot and dead-freeze (HP proven way). But my Okame 650W PSU had ruined my plan because it required more space. I started to look for a bigger casing. I found a gem.
That company which produces it overlooked the HP workshop “How to make cramped, sealed casing for boiling NVMe drives”.
I chose JONSBO D41 White.
It looks like it was designed by a Scandinavian studio in Shenzhen. It breathes like the HP Envy T02 casing never will. It’s practically a frame inside a sieve. It’s so ephemeral that you can accidentally swoosh your leg through it and not notice. And it looks damn good in white.
Price — only 70€. Bought.

Jonsbo D41 dissection.

High quality connected with attention to details

Altogether roughly 910€. If I were to buy a separate 2×8GB DDR RAM this machine would be an almost exact 1000€ box.

That’s cheap like a box of peanuts — people buy this for fun every day, right?

Intel, why am I so crazy about those Arc Pro B-chips?
I have B60.
I have B50 now.
I have a 650W PSU.
I have Unicorn and Elvis’s shoe.
What do I miss?
Arc Pro B70 32GB eventually.
Arc Pro B65 32GB?

Those last two will do.

I can give you Elvis’s shoe. I keep Unicorn for myself, because we like to watch TinyB together (cute dang thing) and my faithful corporal Claude is into Unicorns.

I ordered all these treasures and it took four long days to deliver them to me. After two days already I was on the phone to ask where my package was. They said they were looking for the i5–13500 CPU because Intel doesn’t produce them anymore. Shame on you Intel.

Finally I got that package on Friday afternoon, delivered to my office.
I thought: “I’ll take it home to think about it” — and 4 hours later TinyB hive was humming under the table.
I’m not so clumsy as you think. It took me so long because Corporal knows nothing about photography, Unicorn was disturbing and I was trying to prepare something you can see here.

It’s over. It was boring enough — you don’t want to read more, right?

Luckily for those more patient readers I have the whole process in photos. I was thinking about filming it but Marilyn Monroe rejected my offer to take a main role and I look really bad in a white dress.

Of course I started from the end, like a proper engineer with five years of physical geography.

I unpacked the PSU because it looked really premium from the outside. So it did inside too.

Then I checked this overpriced CPU I was striving to find. Then I got my sticky paws on the Arc Pro B50.

Intel Arc Pro B50

Because it’s so tiny I decided to invite B60 on the catwalk to compare Beauty with the Beast.
It’s hilarious difference.

Then I unpacked the Asus motherboard. It was really well made. Especially the CPU fixing mechanism drew my attention.
I hooked a city bus to it to check how strong it is. The bus was ripped in half. The CPU holder was laughing.

I decided to install the CPU on the MB and the fan on top of it. I have the Intel original fan. My Unicorn looked at it and mumbled something like “made by HP” but I pretended not to hear it. I decided to apply a better thermal pad on it — was it the right decision? Hard to say, but it’s my decision so you will live with it.
I thought I might need some tool for that.

Kizlyar hunting knife works best with stubborn things.

Claude said that Unicorn is afraid of knives so I used a credit card.
I know how dangerous it is to take photos of cards and publish them online, that’s why I put tape on it and you can’t read anything.

Always undercover, chameleon mind inside a Bear.

It was easy to clean the original thermal paste.

No jokes any more (for a while). Copper is very soft, softer material needed as scraper to avoid scratching.

Cleaning with isopropyl to get rid of residue.

Almost too easy.
I know why — because later it was damn hard to apply the thermo pad I bought. Nature likes balance — geography taught me that.
I tried first putting the thermopad on the fan.

Cleaned and ready for action.

10 minutes invested in cutting square to circle, proof for inborn talent in action.

I did a great job — Unicorn had spoiled it.

Unicorn at work.

At the second approach I proposed we put it on the CPU then.
Unicorn was flabbergasted. I was clumsy.

Bear knows better. Bear loves to cut the corners.

Bear has clumsy paws. It doesn’t matter, I’ve had a lot of time to get used to it.

Luckily I’m ol’ Bear and I got it “Pareto right” as usual.

“Pareto-good” thermal pad application. TinyB by Bear.

Then the fan on. How hard could it be?

And here, after I wrangled with fan for a while, I reminded myself what Unicorn had mumbled earlier.
Intel — let’s have this off the table.
Please add good fans to good CPUs.
This one you gave me is like Barbie house - cute but plastic to the square.
I know it’s not your fault — someone swapped it. That must have been the same person who swapped the Asus metal NVMe holder and left me this:

I almost dumped it into the trash with the packaging leftovers. It seems completely unusable. Luckily I found my deeply (really deeply) ingrained intelligence grain and solved the puzzle immediately, after half an hour.

Lexar NM790 inside of TinyB

Then only memory was left to install. I believe memory works better when seasoned beside a high quality PSU for a while. You can clearly see I follow my beliefs. I gave it a shot.

And I realized that the same guy who planned the NVMe holder was probably team leader in DDR4 socket development. He forgot that you shall not improve something that works — unless you’re an ol’ Bear of course.

I last assembled a PC when dr. Alban’s “It’s My Life” was global and the most controversial song known was “Let’s Talk About Sex” by Salt’n’Pepa.

I’ve seen some memory slots here and there through my life. But not that kind of pointless invention. It has a lock only on one end of the DDR module. The slot is as tight as a baby’s grasp. We don’t want to hurt any babies here, do we? You start to think that they designed it to sell more DDR modules and motherboards because during installation I broke three. If you buy a new motherboard check if there is no smiling Baby with Arnold’s grip on the box. Avoid that one if you see it.
Finally I got it right. I was so exhausted that my hands were shaking, hence the bad focus on photo below.

So we got to the end — I said to Unicorn. Where is he actually?

Oh Cutie! It’s dangerous to go inside of HP Envy T02, you can suffocate or be fried immediately. Luckily it was off. Remember that Unicorns and submarines never show in the same fairytale. Let’s check how tight it is in there. When I look at HP from the outside it seems attractive, then it starts heating up and things get complicated. Situation escalates, bells ringing. And you need to open the casing from the side to rescue the crew from imminent death.

HP Envy T02

You can see NVMe frying pan inside. Tiny radiator on SSD absorbs more heat than it releases.

So we got this ugly submarine-thing out of our view. It could have been Yellow Submarine at least.

Ready to invite TinyB on the show photo-wall.

My eyes full of tears and teardrops not splashing on JONSBO casing, just passing through without making it wet. Such a good ventilation!

There is one thing worth checking which I promised you because of my oversized PSU in TinyB. Power consumption measurement.
I had no time for extensive testing so I measured only at idle to check how much my Okame 650W spoiled energy consumption rating. I wanted to use something very professional to measure it. So I used “pareto-good” mode and a small gadget from Lidl (for American readers — Lidl is like Walmart — you just don’t drive there with a Dodge RAM, you use a Fiat Panda).

I started with TinyB. Great result — 47.5 Watts for displaying Linux Mint desktop.

Next one HP Envy T02 . It has of course a bigger PSU (800W), much stronger CPU and Intel Arc B60 draws 40 Watts only for turning a fan and blinking two LEDs. Intel cut LEDs out to save energy though and fan is not spinning at idle. The same desktop on Linux Mint needs 106.3 Watts.

I think I know which machine will land in the office one day.
Me and Unicorn love TinyB. You might ask why not bring HP to the office on Monday?
Plan is simple. I need to test TinyB with Intel Arc PRO B50 and my stormVINO server. Then I might ask HP Envy to lend Intel Arc PRO B60 to TinyB and do some more tests.
You might think — your oversized PSU is still an overkill.
I might say you don’t know life, babe. I’ll give you a lesson.
B. 7. 0.

King has died, long live the King.

Disclaimer: All opinions, thermal disasters, clumsy paws, submarine color and questionable purchasing decisions described here are exclusively ol’ Bear’s own. Intel makes good chips. Bear makes trouble and solves some of it for himself. These are separate and independent activities.

Custom OpenVINO Server — A Birthday Gift to Myself: How to Celebrate Your 50th Anniversary with the Best Wine — Part 2

2026-05-19T00:00:00Z

Part 1 got some kind attention from the OpenVINO team at Intel — thank you [@Adrian Boguszewski]

If you landed here first, [Part 1 is here ←]

There is this drive inside my head that makes me think I can make things better. That’s exactly why I broke all those toys. But with age and experience I break things less often — and sometimes I actually make them work better.

My attempt to fuel Claude Code with a local server taught me that I shouldn’t try to replace things which are genuinely better and in a league of their own. I shall stay humble. So I did.

I planned to build automatic routing capabilities that would not limit my server to the local GPU only. Humble as every Monday, I started convincing my Claude Code programmer that we could do it.

I explained that I had seen traffic routing once, and that I had already experimented with OVH AI Endpoints. I experienced how easy their service is to use. Is it though? For me — an IT guy with experience — it’s easy. But what about others? This service has one genuinely huge advantage: it complies with European GDPR regulations.

I imagined there are companies — perhaps three — who need exactly that, right?

Somewhere out there, small company staff are stitching together their local inference server with wire and duct tape, just like me, because someone convinced them that Intel Arc B-series GPUs are awesome. People do it every day, right?

To avoid staying locked in my home office in my little bubble with Claude, I decided to take a trip to the office and talk to my friend. He is a pragmatic programmer with a 35-year career. He kindly offered me double coffee and a single face-slap, and put on the table a dozen existing software solutions — and even a photo of a small ARM-powered system from a popular GPU producer.

I told him that I like to play CP2077 on those cards because the volumetric lighting makes Night City neons look awesome — but when I’m not playing CP2077, I don’t like CUDA. I like wine (VINO).

If you’re not Polish like me you might not grasp this little joke immediately, but it might stick. Polish “cuda” means “wonders”.

So I told him: I’ll try to make a fool of myself first and build my server with Intel OpenVINO — and then, if I fail, we can buy whatever BDX thing they sell cheaply for 5k Euro in Poland. Back at home I checked how much money I spent on the Intel Arc B60 — it was less than 5k Euro. How much did I pay in licence fees? Do I need to pay any if I use OpenVINO in a company? Luckily, no.

I mentioned in Part 1 that basic VLM support was there after the second day session — really basic, to the stage where the same model needed to both recognise a picture and chat with the user. If you ask me where I found an OV image of Qwen2.5-VL-7B — I converted it myself. Because I can. Then I found out that on HuggingFace/OpenVINO I can find a faster one.

I didn’t mention earlier that at the model-picking phase I had a fever for converting models. My broadband router needed three cans of cold beer to survive the downloading sessions. Since routers don’t like beer (at least mine doesn’t), I took advantage of the download time. Time for CP2077. Damn — I got rid of that loud RTX monster and now the neons look sh*tty.

Back to OpenVINO — it’s a more interesting and colourful framework for me now. That experiment with model conversion and a little benchmarking taught me that you are generally better off taking a quality pre-converted model from the OpenVINO Team. My models were a bit slower at loading and inference. Perhaps it’s just the fault of my naive approach and incompetence — but here I saw that tinkering doesn’t always give the optimal result.

I started to think I could make something more than just using one model to recognise pictures and another to chat with. What if I could somehow judge which model should be selected dynamically to answer a question?

I asked Claude to spin his shiny silicon bit-brain — and he agreed. We invented something simple together:

Rule signals — regex/heuristic:

image attached? → VLM
#code hashtag? → code tier
system prompt > 4,000 tokens (excluding AnythingLLM tool schemas — more on that below)? → long-context path

Embedding similarity — multilingual-e5-large (already in VRAM for the embeddings endpoint) embeds the query and cosines it against pre-computed task-class centroids. Handles ~75% of unambiguous queries in ~10ms. Threshold: 0.72.

Assessor LLM — qwen3–8b in a dedicated pipeline, asked to pick a task class. Only fires when embedding confidence falls below threshold. ~1s overhead.

I like simple things — until I don’t.

I started testing thoroughly with AnythingLLM. I learned that it injects thousands of tokens of tool schemas into the system prompt, causing every agentic request to trip the long-context gate and route to a document model — evicting whatever was loaded. So we added a fix to count only user and assistant messages toward the token threshold. The system prompt is application boilerplate, not user content.

I stumbled on multiple things during this voyage. A stubborn Python pipeline doesn’t release GPU memory — the C++ destructor only runs at GC collection. Luckily I had Claude, because I’m a destructor myself.

I learned what optimal KV cache size means — the hard way, of course. Two models at 8GB KV each = 29.6GB against 22.71GB total available — the driver was spilling to system RAM silently. Dropped to 3GB KV per model. Lesson learned: the KV cache budget is the single most consequential config number.

I was greedy, stuffing the B60 VRAM like a Thanksgiving turkey. I found out it’s not a turkey. A 20% VRAM reserve — not 5% — is the practical minimum. At 5% free, the continuous batching scheduler runs out of attention computation buffers and generation hangs at 100W, producing nothing.

Step by step, sticking to my mental framework (KYE-SBS-OMK), Claude and I achieved some success. It wasn’t the “holy smart assessor” concept I had imagined when we started — the 8B model wasn’t smart enough and the bigger model was too slow — but it works based on embedding and weight comparison purely. (Sometimes not, though.)

All this experimenting led me to a point where my earlier crafted monitor started to cripple my diagnostic ability. I could see the current state of the working GPU, but I’ll admit — my weak memory didn’t let me hold more than the last 5 seconds of results.

I thought to myself: what can help? Cold beer, CP2077? Perhaps PostgreSQL?

I heard once, at a firepit, when old people were praising some great PostgreSQL ancestor who could do everything better — and they even included the word “vector.” I remember that because “vector” doesn’t fit into a camping landscape very well.

So I discussed with Claude the viability of using PostgreSQL to store live server statistics and provide long-term observability. We also debated storing embedding vectors using the pgvector extension — mainly for providing future data to optimise threshold adjustment for router decisions. That plan went into execution too.

After a short fight with PostgreSQL installation and database structure establishment, we got our first confirmed run with local database observability. Then I noticed the truth in the old saying: the most beautiful painting is useless when you’re blind.

My current monitor was a little Python script and I didn’t want to fiddle more with it — it’s not worth equipping your bicycle with four seats and windshield wipers. Just get a car, I thought.

I discussed options with Claude and we decided to build the lightest possible web interface embedded in the server. Svelte was the front-end framework of my choice because I had some positive experience with it after building a little “Ecosystem Simulator” in another project.

The silicon bit-brain spun multiple times. I criticized, sent it back to the digital workshop bench, and after a couple of feedback rounds we had a good-looking (opinionated) web panel that allowed you to observe server state, loaded models, and historical statistics. The server started to look professional. Some duct tape and loose wire still dangling, though.

SVP dashboard — EnvyStorm ov_server, localhost:11435. The VRAM bar up top tells the most important story: who’s loaded, how hungry they are, and how much headroom is left. Profiles on the right (Fast / Precise / Laborious) map to the router’s model tiers. The Scope switch lets you choose between local-only or local+OVH routing. Manual model selection is available via a dropdown populated with scoped models. The Model Catalogue below lists the whole arsenal — only two soldiers actually on duty at a time. Power draw: 43W idle out of 200W TBP. The GPU is basically napping.

A couple of direct queries from Open WebUI — different models loaded, stats visible. I love watching the CPU core bars dance under pressure.

SVP dashboard ALIVE. Couple direct queries from Open WebUI — different models loaded, stats visible -I love CPU core bar dancing under pressure.

I thought to myself: don’t you feel something is still lacking?

So I built a VRAM profiler a small tool that calculates the exact size of models loaded into VRAM on first load, or manually on demand. Of course PostgreSQL stores this between session, no recalculation needed. That little thing simplified the server’s model eviction decisions considerably. The server now knows up front whether two models with their corresponding KV cache sizes will actually fit on the B60. Goodbye, turkey.

I still had a lot to do. My Google Home speaker — which had seemed so attractive in this new AI era — now looked completely outdated.

How do you make a talking assistant? Something that actually speaks back to you and to Claude? (He revealed his orientation to me.)

And I went to sleep with a head full of questions.

Part 3.

Disclaimer: All opinions, ideas, choices and questionable purchasing decisions described here are exclusively my own. Intel makes good chips. I make trouble and solve some of it for myself. These are separate and independent activities.

Custom OpenVINO Server — A Birthday Gift to Myself: How to Celebrate Your 50th Anniversary with the Best Wine — part 1.

2026-05-15T00:00:00Z

I had never dreamed of writing a local LLM server — not in Python, not in anything. I know some good, simple, proven existing solutions like Ollama and I use them. I like simplicity — until I don’t.
After getting involved with running LLMs locally, I was struggling to understand how to use them effectively and efficiently.
Cloud-hosted models we all mostly have access to (Gemini, Claude, Copilot) are like “Gods of Digital War” compared to the tiny 3B or 7B models running on local devices.

To describe my inborn curiosity and stubbornness I usually bring back a childhood memory about toys I tore apart, because I was eager to find out how they work internally. I’m 50 years old today and still like to tear things apart to find out how they work.
So I bought an Intel Arc Pro B60 24GB VRAM and threw my RTX 3080 10GB in the bin — don’t look for it — my son picked it up immediately for his gaming PC.

For a casual home user the B60 is not an interesting card. Don’t buy it for CP2077 — it works, but there’s no comparison to Nvidia RTX, which makes Night City shine when you drive your bike through neon-filled streets.
What can you do with this card? Obviously, run LLMs on it. Ollama works under Windows and gives some possibilities. I tried. It’s boring — it just works, and the Vulkan intermediate layer eats its chunk of performance.
So… why not run it with Intel’s native stack, I thought to myself. How hard can that be? I can do it. Can I?

Let’s do a quick check:

I have no clue about LLM servers or OpenVINO
I run Ollama for daily work because it is easy
I work as a serious manager for a programming team and I constantly have no time for coding

But — I have one advantage. I’m a programmer myself (C#, no Python though) and I have 25 years of experience managing technical staff across multiple fields, 10 of those in software development.

So the plan starts to take shape:

Management skills — check.
Experience — check.
I just need to hire a Python developer. Not a cheap deal, though.

What is that Claude Pro subscription fee doing on my credit card bill?
Why have I never used it for more than chat and data analysis?
Let’s put that lazy, overpaid Claude to work for me.

So I hired Claude Code — and he (what are your pronouns, Claude?) decided to be my teammate and follow my suggestions. (Not.) Blindly.
Honestly — I trusted him on many points after he explained his whys, because I had already learned this from working with people: no one is perfect, everyone makes mistakes, you need to trust the people you hire.

But I learned one thing — your employee must understand what you expect from him, what he can and cannot do. He needs a contract, effectively.
I’m lazy, I didn’t want to dig through all the possible settings of the CC environment. I’m impatient (sorry, toys). I have ADHD symptoms.
So I decided to write my customised CLAUDE.md — which explains to Claude how to work for me and with me.
Check it out in the repo. It proved itself very effective — use it and give me your feedback.

Just be a good manager, I thought to myself — no need to tear anything apart here, Jerzy. (What a shame!)

My workstation HP ENVY T02 with i7–12700K CPU and sh*tty Blizzard motherboard (HP — forgive the honest truth) was hosting Nvidia RTX3080 10GB as I mentioned earlier.
Of course, first steps after fitting the B60 into it were painful. BIOS options do not showing Resizable BAR and it was something Claude was nagging me about constantly.
What is that? Couldn’t they make normal bar, why resizable? Simple definition of it — CPU extended access to VRAM on GPU card. Here important fact is that if you don’t switch it on in BIOS, performance between CPU and GPU degrades significantly.
Of course my BIOS has no such an option. Of course I was trying to figure out where can I find it. Effectively nowhere.
I switched my dusty Windows 11 on and started to look for Intel drivers and BIOS upadate for my Blizzard motherboard. Found it, installed it. Took me around two hours to make it right.
Long story short. After updating my motherboard BIOS, installing newest available drivers for Arc Battleimage family I saw on my screen nice green dot which said: Resizeble BAR -ON.
So it exists, it is on and I don’t have to dig in BIOS anymore. Switch back to Linux now, it is easier to make something work when you know you have that thing in your PC in the firstplace.
Linux Mint is great — yeah, I know you were expecting me to be running Arch (actually) or maybe not — but Mint relies on a well-seasoned kernel (6.12). That well-seasoned kernel had no clue that Intel introduced the B60 in end of 2025. Shame on you, Intel — not calling your friend Kernel with such good news.

So me and Claude started looking for solutions. About an hour later we found that I could install experimental kernel version 6.17.0–1020-oem #20-Ubuntu SMP PREEMPT_DYNAMIC and it’s my Kernel now. Selected mainly because of impressive name of course. Check your version — ‘uname -a’.
It was genuinely a bit less painful than removing a front tooth with old, red-hot pliers — luckily only one kernel though, and not even removed, because you can plant and grow many. (Not teeth — kernels.)

Then came some adventures with library compatibility. To make the story shorter: OpenVINO stack is on 2026.1.0 (cutting-edge), transformers is 4.57.6 (very recent), torch is 2.11.0. Everything is current — no stale pinned versions. I saved details to github if you need those.

Damn, it’s quite a pack when I see it now. I remember those two long nights we spent with CC to make it all work together — vibe coding my ar*e!

If you look carefully you might ask what is infergate? It’s re-implantation of my own ideas which were born during custom server development. I decided to put them into separate library so you can try it out, just: pip install infergate. It’s version says Alpha still but it works well. Pace of pushes to PyPI comes from the fact that my two CC employees were building it and re-implementing it at once. It was working three weeks in my server already earlier moulded with it. Whole process of extracting and re-implementing it brought some improvements and ideas in my and Claude’s head. Perhaps this little thing and whole process should receive separate article here later.

Let’s get back to main story. After installing all required libs it was easy and all downhill from there. No, it wasn’t.
Ambitious idiots have a trait that makes them either dead or half-heroes. I’m still alive — so take your pick.

I went for OpenAI API compatibility because the main tool I had under Linux to experiment with was AnythingLLM. I knew I could chat in it, do RAG, put in a picture for recognition. Those were the first targets.
That went into the server over two nights — one for the skeleton, one for the basics:

Day 0 — April 21

Birth. Single commit: fcc5f41 — ”Initial commit — OpenVINO LLM server (FastAPI + openvino_genai)”

Day 1 — April 22 (18 commits in one day)

The server went from skeleton to working in a single session. All the foundations landed in rapid succession:

Tool call support, streaming, model aliases
LRU VRAM eviction with headroom checks
AnythingLLM agent detection via system prompt
Dynamic model discovery + config.json
MODELS.md and path migration to /opt/ov_server
VLM support — Qwen2.5-VL-7B via VLMPipeline

In the meantime I spent some time looking for models that were able to run on it. Do IR or OV sound familiar to you? They didn’t to me. This is Intel’s way of building model images for OpenVINO.
After those two nights of “vibe coding” I had a server that worked — a bit.
It was exciting to see it come to life so fast and to see just how mighty a tool CC really is.
I took a break and the long holiday weekend of May 1–3 arrived — barbecue in the sun. Finally, after this super long winter in Poland.

I hate weekends though if I can’t work and fuel my ADHD brain with creative thoughts. The only thing that can keep me away from the computer is my KTM 790 Adventure motorbike. Go, Horsey, go!
But the weather wasn’t great again and I don’t ride at night. So let’s look at that server and make it better.

First I thought that before it grows it needs some observability and proper configuration — it was all hardcoded at that stage, of course. Vibe coding effect.
I also decided to generate a separate Python script to read GPU stats. That’s when I found out that Intel’s delivered tools don’t read B60 stats well — only partially. Luckily my brilliant co-worker found a way to read those stats directly from system files, and my monitor was born. You can see it in the Shangri-Lab repo. Picture here:

Then I decided — prematurely, idiot trait — that my B60 is so great that surely it could fuel Claude Code, and I started implementing Anthropic API support. After going through all of that (2 nights), I had a server with GPU visibility and barely functional CC support — practically unusable.

You start CC, write “hello” and… CC sends 4,000 tokens to the server. First attempts: 3 minutes to get a response to “hello.” Usually the wall in my room talks back much faster.
I managed to optimize — cripple it — on my server side by automatically cutting out most of that payload. Response time dropped to 40 seconds.
Great, I thought. I’ll die before we get halfway through a 100-line Python script.

So I went to sleep. They say good sleep makes you live longer. They might be right — but I like to try things out on my own first.
Is it over?

”Not yet, my friend. Not yet.” — Gladiator the movie

This story continues. [Part 2: Smart routing, VRAM lessons, and a button hiding in plain sight →]