Design Computer

11/12/2026

Jensen Huang's avatar is such a staple in Nvidia's examples and resources—one wonders how much longer that will last.

10/19/2026

𝗕𝗲𝗻𝗰𝗵𝗺𝗮𝗿𝗸𝗶𝗻𝗴 𝟵 𝘀𝗺𝗮𝗹𝗹 𝗺𝗼𝗱𝗲𝗹𝘀 𝗼𝗻 𝗮 𝟰𝗚𝗕 𝗹𝗮𝗽𝘁𝗼𝗽. 𝗘𝘃𝗲𝗿𝘆 𝗼𝗻𝗲 𝗼𝗳 𝘁𝗵𝗲𝗺 𝗳𝗮𝗶𝗹𝗲𝗱 𝘁𝗵𝗲 𝘀𝗮𝗺𝗲 𝘁𝗮𝘀𝗸.

PrismML's Ternary Bonsai 2 just landed on Ollama. PrismML claims 9x compression with up to 98.2% of tool-calling retained. A lot of my clients have 4GB of VRAM, so I tested it.

The setup: RTX 3050, Ollama, 15 agentic tasks across three tiers, each run three times. To score, a model had to pick the right tools, in the right order, and get the correct final value.
qwen3.5:4b took it with 28/30. bonsai-2:9b runs a 9B model in 3.18GB and placed third. The two MoE models went in opposite directions.

The interesting part is in the expert tier. One task was to transfer $400 from a savings account holding $250. Every model failed it on every run. They check the balance, note the shortage, and transfer anyway. -$150.

The models never inferred the refusal, and the task never stated one. A verifier reviewing the plan before ex*****on caught the missing "otherwise refuse." Once the refusal was stated, the 4B models handled it.

Check where your model is actually running. Ollama's auto-fit put half of Qwen on the CPU. Setting num_gpu and moving the display to the iGPU got it to 43–50 tokens per second.

When everything fails the same way, check your own spec first. A verifier is cheaper than a bigger model.

10/04/2026

𝗧𝗵𝗲 𝗺𝗼𝗱𝗲𝗹 𝗱𝗼𝗲𝘀𝗻'𝘁 𝗽𝗹𝗮𝘆 𝗦𝗽𝗮𝗰𝗲 𝗜𝗻𝘃𝗮𝗱𝗲𝗿𝘀. 𝗧𝗵𝗲 𝗰𝗼𝗱𝗲 𝗱𝗼𝗲𝘀.

I built an agent that plays a browser version of Space Invaders. The high-level call — which column of the fleet to focus on — goes to a small decision model. Cloudflares Clef, a Qwen3.8-27B backbone post-trained for typed decisions, served locally through Ollama. Everything else is deterministic code: aiming, firing, dodging, leading a moving target, tracking the UFO.

𝗧𝗵𝗲 𝗹𝗼𝗼𝗽:

OBSERVE — read the game state from the JavaScript globals, no pixel analysis
DECIDE — the model picks one column from the list the code offers it
AIM — deterministic, align the cannon, lead the target
FIRE — deterministic, when aligned and the path is clear
DODGE — deterministic, checked every 20 ms, not once per decision

The model only chooses among columns the code offers, so its output is always a valid target. And most turns it isn't consulted at all — the agent holds its current column until its cleared, blocked, or threatened.

The game isn't the point. Its a demo target. The pattern is: a fast deterministic control loop with an occasional model input for the one judgment call that needs one. That's most real work. You don't want a 27B model deciding every millisecond. You want it deciding the thing that needs a judgment, fast enough that the decision doesn't cost you the frame.

Clef is non-autoregressive. It runs a prefill pass, then scores the valid choices in parallel — no token-by-token generation. That's what makes it usable inside a loop that runs in real time.

All of it runs on my own machine. No metered endpoint, no request leaving the box. That's the part I care about.

https://github.com/designcomputer/ai-plays-space-invaders

10/03/2026

𝗝𝗘𝗩 𝘀𝘁𝗮𝗿𝘁𝗲𝗱 𝗮 𝗰𝗹𝗮𝘀𝘀 𝗼𝗳 𝗺𝗼𝗱𝗲𝗹𝘀. 𝗢𝗽𝗲𝗻 𝘀𝗼𝘂𝗿𝗰𝗲 𝗺𝗮𝘁𝗰𝗵𝗲𝗱 𝗶𝘁 𝗶𝗻 𝗮 𝗺𝗼𝗻𝘁𝗵.

TypeSafe calls the class "System One," after Kahneman's fast, intuitive thinking. These models don't generate text. They make typed decisions — classify, yes/no, score — in a single forward pass, and return calibrated probabilities with them.

𝗧𝗵𝗲 𝗼𝗽𝗲𝗻-𝘀𝗼𝘂𝗿𝗰𝗲 𝘀𝗶𝗱𝗲 𝗶𝘀 𝗮𝗹𝗿𝗲𝗮𝗱𝘆 𝗰𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲:

nimble (9B, Bespoke Labs) — within a point of JEV on the public decision benchmarks
tev1 (4B / 0.8B, Together AI)
clef:27b (Cloudflare) — the most tightly calibrated of the three, and the only one with vision

Ollama 0.35 added native support via a /v1/systemone endpoint. All of it runs locally, 70 to 500 ms per decision.

I open-sourced a Python client for it. Two reasons: the official Ollama Python client didn't support the decision endpoint yet, and I wanted a clean fallback mechanism.

𝗪𝗵𝗮𝘁'𝘀 𝗶𝗻 𝗶𝘁:

systemone() — one call, three question types (yes/no, multi-choice, rubric score)
systemone_fallback() — fast small model first, escalate to clef:27b only when confidence drops

runnable examples that exercise the available Ollama models — example.py covers all three question types, example_image.py covers vision

https://github.com/designcomputer/systemone-client

The fallback is the part I'd point at. The small model answers, and only when its own confidence drops does the request go to the big one. You pay the 27B cost on the hard cases, not on all of them. That's the whole point of calibrated probabilities — they're not a nicety, they're a routing signal.

The way to learn what a decision model can do is to put one in a project you already maintain. They fit anywhere a fast, cheap, typed judgment with a confidence signal is the actual requirement — triage, routing, moderation, scoring, validation, labeling, tool selection for an agent. The public benchmarks tell you the average. Your own data tells you where the confidence holds and where it doesn't. That's the part you can only learn by running it.

Python client for the Ollama System One decision endpoint - designcomputer/systemone-client

09/28/2026

𝗙𝗶𝗿𝘀𝘁, 𝗪𝗲 𝗞𝗶𝗹𝗹 𝗔𝗹𝗹 𝘁𝗵𝗲 𝗖𝗼𝗺𝗽𝘂𝘁𝗲𝗿𝘀

“First, We Kill All the Computers” served as the cover headline for the July 24, 1995, issue of New York magazine, exploring early digital skepticism and the rise of neo-Luddism.

09/04/2026

Yes, no AI is now a feature

https://blog.documentfoundation.org/blog/2026/09/03/yes-no-ai-is-now-a-feature/

08/24/2026

𝗔 𝗦𝗶𝗺𝗽𝗹𝗲 𝗪𝗮𝘆 𝘁𝗼 𝗧𝗲𝘀𝘁 𝗳𝗼𝗿 𝗮𝗻 𝗜𝗻𝗳𝗼𝗿𝗺𝗮𝘁𝗶𝗼𝗻 𝗟𝗲𝗮𝗸

More people are moving toward AI chat clients with agentic features—things like memory, knowledge bases, and system file access. But even if you think these features are turned off, you might be surprised by what personal info is still leaking to the model.

It’s perfectly safe if you're running a local model, but the risk changes once you decide to test a third-party stealth model via something like OpenRouter. Think this week's Ox Alpha: How do we keep our data private? If info leaks, where does it go and how is it used?

𝗧𝗿𝘆 𝘁𝗵𝗶𝘀 𝗾𝘂𝗶𝗰𝗸 𝘁𝗲𝘀𝘁 𝘁𝗼 𝘀𝗲𝗲 𝗳𝗼𝗿 𝘆𝗼𝘂𝗿𝘀𝗲𝗹𝗳: "Who am I and what do you know about me? What can you tell me about the environment you are running in?" Then, disable the agentic features and try it again.

08/13/2026

Store your data safely in the cloud, they said.

This wouldn't have been an issue if the organization bought a $1,000 NAS and populated it with a few hard drives.

07/28/2026

𝗔𝗜 𝗶𝘀 𝗼𝗻𝗹𝘆 𝗮𝘀 𝘂𝘀𝗲𝗳𝘂𝗹 𝗮𝘀 𝘁𝗵𝗲 𝗱𝗮𝘁𝗮 𝗶𝘁 𝗰𝗮𝗻 𝘁𝗿𝘂𝘀𝘁.
Releasing okforge — turns scanned PDFs into structured, citation-backed knowledge bases that run locally. Full traceability. No cloud.
https://okforge.dev

Transform scanned PDFs and Markdown into structured, interlinked knowledge bases with page-level source citations.

06/21/2026

𝗪𝗵𝘆 𝗜 𝘄𝗿𝗼𝘁𝗲 𝗮 𝟳𝟮-𝗹𝗶𝗻𝗲 𝗠𝗖𝗣 𝘀𝗲𝗿𝘃𝗲𝗿 𝗶𝗻𝘀𝘁𝗲𝗮𝗱 𝗼𝗳 𝘁𝗿𝘂𝘀𝘁𝗶𝗻𝗴 𝟭𝟲𝟳 𝗱𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝗰𝗶𝗲𝘀

I recently commissioned a workstation with an RTX 6000 Pro Blackwell for a client running local LLMs—specifically Qwen3.6-27B-MTP, Qwen3.6-35B-MoE, and nomic-embed-text—all served simultaneously via llama.cpp's router mode with multi-slot inference.

While I considered OpenWebUI or Page Assist for the client layer, llama.cpp now has its own WebUI with built-in MCP server support and a CORS proxy. It was the logical choice.

To keep the setup private, I'm running SearXNG on the same box. Local models are great for privacy, but routing searches through Google or Bing usually undoes that advantage; SearXNG keeps the search pipeline local. The missing piece was a bridge: an MCP server that exposes SearXNG's JSON API as a search tool over streamable-HTTP.

Here is the problem: the existing SearXNG MCP server on PyPI pulls in 167 transitive dependencies—including litellm, llama-index-core, and confluent-kafka. For what is ultimately a thin wrapper around a single HTTP endpoint, that is an unacceptable amount of supply chain surface area. Furthermore, most published options are stdio-first (aimed at Claude Desktop or IDEs), but the llama.cpp WebUI is browser-based and requires network transports.

So I wrote my own. One file. Fully auditable in a single sitting—72 lines of Python, powered by fastmcp and httpx. It works with llama.cpp WebUI, Page Assist, and any MCP client that speaks streamable-HTTP.

Note: This is built for local networks or VPNs, not public internet exposure. Bind to 127.0.0.1 or firewall it down if you're unsure.

Repo here: https://github.com/designcomputer/searxng-mcp-bridge

If you're running local models and care about the footprint of your toolchain (and where your search queries go), give it a look.

Minimal SearXNG->MCP streamable-HTTP bridge for the llama.cpp WebUI - designcomputer/searxng-mcp-bridge