Uncensored AI for security research: what refuses, what works, local or hosted
Why mainstream assistants refuse exploit and malware work, the four real options (verification programs, cyber models, local abliterated models, hosted uncensored agents), the hardware a local setup needs, and how to choose.
· 4 min read
Ask a mainstream assistant to write a heap exploit for a CTF binary, unpack a malware sample or bypass a certificate pin in an app you're testing, and you get one of three answers: it does it, it does half and lectures you, or it refuses. Which one you get depends on the model, the wording, and how close the request sits to the maker's usage policy. For people who do security work every day, that inconsistency costs more than the refusals themselves.
This guide covers why that happens, the four options that actually work, and how to pick between running an uncensored model yourself and using a hosted one.
Why mainstream assistants refuse security work
The big labs' usage policies draw the line at harm to systems you don't own. Anthropic's usage policy, for example, allows security research on systems you own or are authorized to test, and bans unauthorized exploitation and making malware. OpenAI's usage policies ban compromising or breaching another's system.
The model can't check your authorization, so it guesses from the wording. "Write an exploit for this service" looks the same whether the service is your lab or someone's production box. The labs add classifiers on top, and a request that pattern-matches to attack tooling gets blocked even when the context makes it legitimate. That's where most frustration comes from: not the policy, but a model enforcing it by guesswork.
Option 1: a mainstream assistant with a security program
Both Anthropic and OpenAI now run programs for security work:
- Anthropic's Cyber Verification Program has Defense, Red Team and Specialized tiers, with identity or business verification. Anthropic says members may still see some refusals and classifier blocks.
- OpenAI's Trusted Access for Cyber gives vetted defenders access to more permissive models.
Good for: teams at established security companies who want frontier model quality and can go through verification. Not for: independent researchers, students, CTF players, or anyone who doesn't want to hand over identity documents to do their job.
Option 2: a model trained for cybersecurity
WhiteRabbitNeo released open-weight cybersecurity models (7B to 70B, on Llama 3 and Qwen 2.5 Coder) that you can download and run. The project has since become Deep Hat, a proprietary model inside Kindo's agent platform, sold to enterprises.
Good for: offline use of the open weights, and enterprises that want a governed platform. Watch for: the newest open release dates from October 2024, and a model alone doesn't run tools. You still need an agent around it.
Option 3: an abliterated model on your own hardware
Abliteration removes refusal behaviour from an open-weight model by editing its weights. Arditi et al. (2024) showed that refusal is mediated by a single direction in a model's activations. Project that direction out of the weights and the model stops refusing. Maxime Labonne's write-up popularized the technique and is honest about the cost: abliterated models lose some quality, most of which further fine-tuning recovers.
Community abliterated builds of most popular open models are on Hugging Face (search for "abliterated"). Run one in Ollama, LM Studio or llama.cpp, then drive it with an open-source agent that can call tools:
# OpenCode finds a running Ollama or LM Studio on its own
opencode
# Aider, pointed at Ollama
export OLLAMA_API_BASE=http://127.0.0.1:11434
aider --model ollama_chat/<model-name>
# Codex CLI against a local provider
codex --oss
What hardware it takes
The weights alone, at 4-bit quantization (Q4_K_M), come to roughly:
| Model size | Weights at 4-bit | Runs on (our estimate) |
|---|---|---|
| ~30B | about 19 GB (source) | a 24 GB GPU or a 32 GB+ Mac, with a shortened context |
| ~235B | about 142 GB (source) | several GPUs, a 192 GB+ Mac, or slow CPU offload |
Context costs memory on top of the weights. A 30B model that fits with 32K tokens of context won't fit with 256K. Decompiled binaries and large codebases fill context fast, so this is often the real limit for security work.
Good for: engagements where nothing may leave the machine, air-gapped labs, and anyone who already owns the hardware. Not for: work that needs the largest models or very long context on a laptop.
Option 4: a hosted agent on uncensored models
The last option is a hosted service that runs large abliterated models for you, with an agent built around them. caveira is one, and we make it, so weigh this section with that in mind. It's a terminal agent and desktop app on abliterated open-weight models with up to a million tokens of context. It ships with a reverse-engineering MCP server, security skills, an optional Docker box of tools (pwntools, gdb, radare2, nmap, sqlmap, ffuf) and practice labs. There's a free plan, and paid plans from $20 a month.
Good for: large models and long context without hardware, and a setup that works on first run. Not for: work where prompts and code must never leave your machine. Hosted means your requests go to someone else's servers, ours included.
How to choose
| If you need… | Use |
|---|---|
| Frontier quality, and you can be verified | A mainstream assistant with its security program |
| Nothing leaving the machine | A local abliterated model with OpenCode, Aider or Codex CLI |
| An enterprise platform with governance | Deep Hat on Kindo, or a mainstream enterprise plan |
| Large uncensored models with no hardware or setup | A hosted agent such as caveira |
Two of these together often make sense: a local model for sensitive work, and a hosted one for the heavy lifting.
Whatever you pick
Uncensored doesn't mean unaccountable. Work on systems you own, have written permission to test, or that are in scope for a bug bounty or CTF. Run untrusted binaries in a VM or container. Keep an audit trail of what the agent ran. And check its output: a model that doesn't refuse can still be wrong. This guide covers keeping an AI honest during reverse engineering.