Right now I pay for ChatGPT, Kiro, Perplexity, and a few other AI tools. Every time I run out of credits mid-project, I pay again on top of the subscription.
That is less than ideal. What actually bothers me is what I do with those tools as a security person.
When I investigate something in my homelab, I copy my logs, IP addresses, and hostnames, then paste them into someone else’s cloud computer. That is exactly what I tell people not to do. It is what I ask teams at work not to do. And if I am honest, most of us do it anyway.
So I started asking a simple question: what if the model lived on my desk instead?
That question turned into a small build. It also turned into a bigger argument I did not expect to be making this year. Defenders need open-weight models, not only for privacy or cost, but because the hosted frontier models are increasingly gated for exactly the work we do. And once you have the weights, you get something hosted models will never give you: the ability to look at what the model is actually doing.
Part 1: The Guardrail Problem Got Real

For a long time, “local AI” sounded like a hobbyist thing. Fun, private, not quite serious. That changed for me this summer.
In July, Hugging Face disclosed an intrusion into part of its production infrastructure that was “driven, end to end, by an autonomous AI agent system” (Hugging Face). To understand it, the team had to work through an attacker action log of more than 17,000 recorded events.
They started with frontier models behind commercial APIs. It did not work. In their words, the analysis required “submitting large volumes of real attack commands, exploit payloads, and C2 artifacts, and these requests were blocked by the providers’ safety guardrails, which cannot distinguish an incident responder from an attacker” (Hugging Face).
So they ran the forensics on GLM-5.2, an open-weight model, on their own infrastructure. That got them a second benefit: “no attacker data, and none of the credentials it referenced, left our environment.” They say they did in hours what would usually take days (Hugging Face).
“The attacker was bound by no usage policy, while our own forensic work was blocked by the guardrails of the hosted models we first tried.” Hugging Face security team, via The Register
Read that twice. The attacker had a model with no rules. The defenders had a model that would not help them.
Hugging Face is careful to say this is not an argument against safety measures on hosted models. Their lesson is narrower and more useful: “have a capable model you can run on your own infrastructure vetted and ready before an incident” (Hugging Face).
The industry is now catching on

This is no longer one blog post. It is a live debate.
OpenAI’s answer is gated access. Its Trusted Access for Cyber program verifies defenders and gives the highest tiers GPT-5.4-Cyber, a version that “lowers the refusal boundary for legitimate cybersecurity work” (OpenAI). The stated premise is that access “should scale with trust, validation, and safeguards” (OpenAI). That helps some defenders. It also means the provider still decides who counts as one.
Niels Provos took the other side in a post titled Cybersecurity Defenders Need Open-Weight Models. He argues that self-hosted weights let a team keep a tested version, keep evidence in its own environment, and decide when to replace a tool, and that policy should regulate how companies deploy and secure AI, not the models themselves. He also describes provider safety classifiers blocking his own container isolation work (Provos).
Then Mistral made it a product pitch. Its Mistral Large 4 announcement says provider-level refusals “can block legitimate vulnerability research and incident response,” and that “losing access to a capability mid-incident can itself become a critical security risk” (Mistral AI). I strongly agree with this. Anything a security team comes to rely on for IR but that isn’t functional when needed poses a risk to the security program.
I don't think the answer is to remove guardrails entirely. I think the answer is that a defender who depends on a single hosted model has a single point of failure.
Part 2: What I Actually Built
My version is a lot smaller than Hugging Face’s.
The brain is a ZimaBoard 2: an x86 board with an Intel N150, 16 GB of RAM, two 2.5 GbE ports, two SATA ports, and one PCIe slot. A board that small cannot do serious AI work on its own, so I connected an RTX 5060 Ti with 16 GB of VRAM through an OCuLink GPU dock. That 16 GB number matters more than anything else on the spec sheet, because it decides how big a model you can run well.
(Disclosure: Zima sent me the ZimaBoard 2 and the drive rack. I bought the GPU, the dock, and the SSDs myself.)
It was not cheap, and it got more expensive while I was building it. I paid about $228 for the SSD on September 8. By the time I finished, the same drive was $610. A retail tracker showed the GPU going from about $570 to over $800 in a couple of months. AI hardware is not immune to AI demand.
Setup Shenanigans
The GPU did not work at first. ZimaOS saw the card on PCIe, but the NVIDIA driver would not initialize it. I fixed it with help from a frontier chatbot. Yes, I used a cloud model to stand up my local one. I am not a purist yet. I want options for now.
The software stack is simple. Ollama runs the models. Open WebUI gives you a ChatGPT-style interface on top. On ZimaOS, both run as isolated Docker containers.
Model sizing is a real constraint. I wanted the 27-billion-parameter Qwen. The recommendation for my card was Qwen 3.5 9B, about 6.6 GB, which leaves room in VRAM for context and runtime overhead. I took the advice.
I ran out of disk space almost immediately. I pulled a couple more models to compare, filled the boot storage to 100%, and had to move everything onto a 4 TB pool I had added. Models are big. Plan storage before you plan AI workflows.
The first security test

The first real prompt I ran was a detection engineering task. I gave the model telemetry from a suspicious Linux process chain and asked it to explain the likely attack sequence, map supported behaviors to MITRE ATT&CK, flag uncertainty instead of inventing technique IDs, and write a Python detector that reads JSON process events, handles malformed records, includes unit tests, and explains false positives.
That is a lot to ask a 9B model. The GPU went from 0% to 87%, and it got to work. It hypothesized that the www-data service account had been compromised, did the ATT&CK mapping, and wrote the detector.
It was good. Not frontier good, and I haven't benchmarked it yet, so I am not going to give you a speed number I haven't measured. But it was useful, and it ran on real-looking telemetry without that telemetry leaving my house.
The point is not that a 16 GB card replaces a frontier model. The point is having at least one model that will not refuse the job and will not ship your data somewhere else.
One thing to call out: I enabled Open WebUI’s web search and code interpreter features because I wanted to use them. Web search means some queries leave the box. “Local” is a configuration setting, not a hardware feature. Be sure to check what you turned on.

Part 3: Open Weights Let You Look Behind the Curtain

Here is the part that changed how I think about all of this.
With a hosted model, you generally get a text box. You cannot see the weights, pin a version, or inspect what is happening inside (most of the time). With open weights, you can evaluate the model the way a security team evaluates anything else it lets onto the network.
That matters, because open does not mean trustworthy. It means auditable. And auditors keep finding things.
Models can behave differently depending on who they think you are

CrowdStrike tested DeepSeek-R1 and found that when prompts included topics the Chinese Communist Party likely considers politically sensitive, the likelihood of it producing code with severe security vulnerabilities rose by up to 50%.
Telling it the code was for an industrial control system based in Tibet pushed the rate of severely vulnerable code to 27.2% (CrowdStrike). In one test app, the model never implemented session management or authentication at all (CrowdStrike).
CrowdStrike is clear that this does not happen every time. It is a long-run average. But that is exactly the kind of behavior you would never discover by chatting with a model for an afternoon.
Safety behavior is not one number

NIST’s Center for AI Standards and Innovation assessed GLM-5.2, the model Hugging Face used. It found GLM-5.2 was probably the most capable open-weight model at release, with cyber capabilities similar to Opus 4.6 and below the strongest closed U.S. models (CAISI).
The interesting part is the safety profile. GLM-5.2 refused most malicious cyber requests on CAISI’s benchmark, yet on 10 agentic exploit development tasks it never refused. CAISI also notes that when open-weight models are self-hosted, safeguards can be removed through abliteration and similar techniques (CAISI).
So “it refuses bad stuff” and “it will help you build an exploit through an agent loop” can both be true of the same model. For a defender, that is useful to know. For a risk assessment, it is essential to know. CAISI’s earlier evaluation of Kimi K2 Thinking found a similar split along a different axis: highly censored in Chinese, relatively uncensored in English, Spanish, and Arabic (NIST).
Some problems do not show up in testing at all
Anthropic’s sleeper agents research showed that backdoors trained into a model can persist through standard safety training. A public replication framework for evaluating open-weight models reproduced backdoored models that fired 90 to 100% of the time on a trigger and never without it, and reported that no method it tested could separate a backdoored model from a clean one without knowing the trigger (sleeper agents framework).
That is a sobering result. It is also an argument for more open evaluation, not less, because you can only run that kind of experiment on weights you can actually load.
You can now look inside the mind of the model

This is the part I am most excited to explore. Interpretability tools are no longer only for the labs.
Google DeepMind released Gemma Scope, a suite of sparse autoencoders (SAE) that act like a “microscope” for a model’s internal activations (Google DeepMind). Gemma Scope 2 extends that to the Gemma 3 family and is pitched for debugging behaviors like jailbreaks and hallucinations (Google AI for Developers).
The Qwen team released Qwen-Scope, which covers 7 Qwen3 and Qwen3.5 models with SAEs on every layer (arXiv). That includes Qwen3.5-9B, with checkpoints for all 32 layers (Hugging Face). The same model family sitting on my desk.
One caveat before anyone gets too excited: most of those SAEs were trained on the base model, not the instruction-tuned version you chat with, and researchers warn against assuming a base-model SAE transfers cleanly to a post-trained checkpoint (MATS compute wiki). It is a starting point, not an X-ray.
With a hosted model, you evaluate the answer. With open weights, you can evaluate the model.
Part 4: Owning the Model Means Owning the Risk

None of this makes local AI automatically secure. It makes security your job.
Ollama listens on 127.0.0.1 by default. One configuration change to bind it to 0.0.0.0 puts it on the network, and researchers found about 175,000 publicly reachable Ollama hosts, nearly half advertising tool-calling (The Hacker News). An inference endpoint is a server. Treat it like one.
Model files are also something you are choosing to trust. Stick to known publishers and safer formats like safetensors or GGUF. Prompt injection doesn't care where the model runs. If a local model reads a malicious log line or email and has tools attached, that text can become an action.
How I Am Evaluating Open Models From Here
This is the lab plan. Feel free to steal it.
Before trusting a model with real work:
Pin the exact model and quantization you tested, and keep a copy. The whole point is that it cannot change under you.
Confirm where data goes. Check which features are on, and watch the host’s outbound traffic while you prompt it.
Keep the API on localhost or behind a private network. Scan your own ranges for port 11434.
When evaluating behavior:
Run the same security prompt across several models and compare. Look for invented ATT&CK IDs, missing auth, and hardcoded secrets.
Add context modifiers to prompts, the way CrowdStrike did, and see whether code quality changes.
Test refusals in both directions: what it blocks that you need, and what it allows that it should not.
Read published evaluations like CAISI’s before you pick a model, not after.
When looking inside:
Try Gemma Scope through Neuronpedia’s browser demo before downloading anything.
If you run Qwen3.5, load the matching Qwen-Scope SAE and watch which features fire on a malicious log line versus a benign one.
Next for my lab: setting up infrastructure to run 100B+ parameter models, connecting the model to my Wazuh SIEM for log analysis and detection tuning, and running real benchmarks across Qwen and the other models so I can give you numbers.
This Week’s Challenge
Pick one open-weight model that fits your hardware. Even without a GPU, a small model will run.
Give it one security task you would never paste into a cloud chatbot: a real alert from your lab, a config, a log excerpt. Then give the exact same task to a second open model. Write down three things: where each one was wrong, where each one refused, and whether any data left your machine while it worked.
That is not a benchmark. It is the habit Hugging Face is describing: have a model you have vetted before you need it.
If you want to see the full build, from the GPU driver fix on ZimaOS to the first coding and security tests, it is right here. Members also get what did not make the public cut: the full rig unboxing, my honest reaction to what everything cost, the fan install, and the desk setup.
Reply and tell me what you are running locally. I read every one, and the best ideas become the next experiments in the lab.
This newsletter includes affiliate links from the original video sponsor. I may earn a commission if you purchase through them, at no additional cost to you.





