Weekly News Roundup: CW33 - The Local-AI Reality-Check Week

tl;dr

• 🏠 Local AI: Kimi K3 needs ~940 GB of weights, Opus 4.6 is API-only, one DGX Spark runs the whole stack by swapping models
• 🤖 Agents: persistent state turns a loop into a system, 12 browser tools collapse into one, humans and agents share workspaces, one prompt builds a whole course
• 🖥️ Tools and hardware: ZoomIt lands on macOS under MIT, TCL’s OLED+ is dual-mode
• 🛡️ AI security: 71 free labs and a course that starts with them

Local AI had a reality-check week. A viral Kimi K3 post claimed a 2.8-trillion-parameter model could run in 16 GB of RAM. Another promised “Opus 4.6 max locally,” only for the project to turn out to be an API wrapper. The more interesting example was less sensational: one DGX Spark running an entire open-source AI stack, just not all of it at the same time.

Beyond local AI, agents are becoming more system-like. One Claude setup behaves like an engineering manager with persistent state, Hermes is collapsing twelve browser tools into one, and Buzz is experimenting with humans and agents sharing the same workspace. Microsoft also brought ZoomIt to macOS, while the AI-security community added dozens of new hands-on labs.

Local AI meets reality

Kimi K3 does not run in 16 GB: not even close

A 2.8-trillion-parameter model is not a 16 GB proposition. Kimi K3 is open-weight, but the abliterated builds circulating this week remain firmly data-center class: Blackfrost’s Q2_K GGUF is roughly 940 GB and is shown running across eight B200s, with SHS-Lab’s and audnai’s GGUF in the same weight class.

The replies to the original post caught the problem immediately. One summed it up nicely: “You misspelled 861GB there.”

The takeaway: the weights are genuinely interesting for red-team research, continuing the abliteration coverage from earlier roundups alongside Open-Kritt. The 16 GB claim isn’t.

Kimi was the extreme example, but it wasn’t the only time “local” became a flexible term this week.

Opus 4.6 is still API-only: the “local” version is a wrapper

Anthropic’s Claude Opus 4.6 announcement ships no weights and offers no local version. The repository circulating under the claude-opus-4.6 name simply intercepts requests, sets thinking_effort="max", and sends them to Anthropic’s API.

So yes, you can run the wrapper locally. You’re not running Opus locally. The surrounding discussion did surface a real benchmark thread: open-weight Qwen-class 27B models getting measured against Opus 4.6.

The DGX Spark example is more interesting because the workload really is local. The compromise is elsewhere.

One DGX Spark runs the whole AI stack by swapping models

Steven Darlow demonstrated seven workloads on one NVIDIA DGX Spark: language, vision, image generation, video, transcription, voice cloning, and music. The pieces are real and linkable: DeepSeek V4 Flash 0731 for language, Qwen-Image for images, antirez’s ds4 engine for serving.

The important caveat is memory. The models aren’t resident simultaneously. With 128 GB of unified memory, the machine swaps models in and out depending on the task. No existing harness routes to each model by task out of the box, one commenter pointed out.

That’s still impressive. More importantly, it’s a much more realistic picture of “local AI everything” than the usual benchmark screenshot. It also builds on last week’s single-serving setup on the same hardware.

Agents are becoming real systems

The common thread in this week’s agent projects isn’t a smarter model. It’s everything being built around the model: memory, tool execution, coordination, and interfaces.

Lloyd: memory turns a loop into a system

An r/ClaudeAI show-and-tell runs an orchestrator named Lloyd on a heartbeat loop: it checks email and app logs, and creates and staffs tickets like an autonomous engineering manager.

The interesting architectural idea is persistent state. Lloyd stores its ticket history in SQLite, turning what could have been a simple heartbeat loop into a system that remembers previous work.

The demo itself runs on scape.work, with one caveat: several commenters called the post an ad for it. The OP is also its developer, something disclosed only in the replies. For a vendor-neutral version of the same idea, the discussion points to OpenAI’s Symphony, the open-source spec and Elixir reference implementation for orchestrating Codex sessions from an issue tracker.

Persistent state solves one problem. Hermes is attacking another: tool sprawl.

Hermes trades 12 browser tools for one

Hermes’s browser automation docs now describe Browser Use mode: twelve browser tool schemas collapse into a single browser_exec tool that runs model-written Python in a browser, powered by browser-use 0.13.3 and the new CLI 3.0.

Nous reports 48–66% lower token use with no accuracy drop. Those are vendor-reported numbers, not independently benchmarked. The reasoning, per the changelog, is the Bitter Lesson: give the model freedom instead of a fixed menu of actions.

Buzz takes the same idea outward: from agents operating tools to agents working alongside people.

Buzz puts agents in the same workspace as humans

Block’s Buzz is an open-source, self-hostable Nostr workspace where agents share channels with humans, each with its own keypair and audit trail. The integration docs describe three ways to wire Hermes in.

Miles Deutscher called the pairing “Hermes + Buzz is a cheat code”, and the Block Engineering write-up behind the tutorial wave frames agents as having a character sheet, a save file, and skills loaded on demand.

The caveat: a commenter flagged that the native gateway integration “isn’t quite there yet,” linking PR #4964.

The loop ends with output. This week there was a striking example of what one prompt can produce.

Claude Code + HyperFrames: one prompt to a complete interactive course

A German-language tutorial by Julian Ivanov shows one prompt becoming a complete interactive training: Claude Code asks clarifying questions, drafts a curriculum, and assembles a single HTML file with video lessons, quizzes, sliders, XP levels, and voiceover.

The example use case is the EU AI Act’s Article 4 training obligation, a rare practical compliance angle. The video names HyperFrames, an open-source “write HTML, render video” framework.

It also references a Hixfield MCP server for asset generation that I could not independently verify. Cost claims of about €5-6 per 10-15 second HD clip are the creator’s own numbers.

Tools and hardware

ZoomIt lands on macOS: MIT, ported in two days with AI

Microsoft has finally brought ZoomIt for Mac to macOS. The Sysinternals presentation utility is open source under MIT, listed as v12.21, and includes zooming, annotation, recording, and panorama capture.

The more interesting part may be how it was built: Mark Russinovich says the port took about two days with AI-assisted coding. Homebrew: brew install --cask microsoft/sysinternalstap/zoomit.

TCL’s first OLED+ is dual-mode, not “4K at 480Hz”

The monitor everyone shared this week is TCL’s 32X3A OLED+. It’s a dual-mode panel: UHD at 240 Hz or FHD at 480 Hz, per both the product page and the launch press release.

Beyond the mode switch: a €918 European price, 6.4 mm at its thinnest point, Bang & Olufsen-tuned audio, and USB-C with 90 W power delivery. That’s what had people measuring it against an Apple Studio Display.

AI security

71 free AI security labs and a course that starts with them

Jason Haddix’s AI security labs hub grew from 23 to 71 labs (103 resources in total, all free or self-hostable, link-checked as a living list), and the collection sits behind his Attacking AI course, which starts students on the labs. His update post covers the jump.

Coverage runs from direct and indirect prompt injection, jailbreaks, and agent or MCP exploitation to RAG attacks and guardrail bypass. “Reading about prompt injection makes you conversational,” Haddix wrote. “Running 71 labs makes you dangerous.” Another entry in the ongoing security-education streak.

If there was one theme this week, it was that the interesting work is increasingly happening around the model: memory, routing, tools, interfaces, and realistic hardware constraints.

That’s the week. See you in CW34.