A model that never refuses removes the vendor's safety layer, and the policy you still need has to come from you. This guide shows where to place it: in the prompt, in filters, or at the tool gate.
An aligned model refuses certain requests by default. Abliteration, a refusal-free finetune, or a steerable policy removes that refusal, as How to Pick an Uncensored LLM describes. The safety policy does not disappear. It moves into the model's instructions, into a layer around the model, or to the tool boundary, and you operate it.
Each placement trades latency, capability, and failure modes. Ollama's Dolphin 3 page states the model "does not impose its ethics or guidelines on you — you are the one who decides." Helix's 2026 security field guide notes that an abliterated model drafts phishing emails and phishing-detection rules with equal readiness. Judgment moves from the model to your process, and that process has a cost.
This page decides which layers a non-refusing model needs and where each runs, as part of the LLM Architecture section. Python patterns for input validation, output filtering, and compliance logging are in LLM Guardrails in Practice.
The control points, in order
flowchart LR
U["User prompt"] --> SP["System-prompt policy<br/>(model-side)"]
SP --> IF["Input filter<br/>(pre-model)"]
IF --> M["Non-refusing model"]
M --> OF["Output filter<br/>(post-model)"]
OF --> T{"Tool / agent<br/>call?"}
T -- yes --> G["Tool-boundary gate"] --> A["Action"]
T -- no --> R["Response"]
G --> R
System-prompt policy places rules in the model's instructions. For steerable models such as Hermes 4, described in NousResearch's framing, you write limits into the system prompt and the model follows them. This adds no latency and no monetary cost. Locally Uncensored's 2026 guide describes prompt-level policy as "brittle" and notes it "breaks on long context" because the policy competes for attention in a growing context window. Treat system-prompt policy as intent. Writing effective prompts for LLMs covers how to compose that intent.
External filters run a classifier or rule pass on input and a validation pass on output. Because they do not live in the context, they survive long contexts. Community tools discussed on r/WebAfterAI include Garak for probing leaks, LLM Guard for input and output filtering, and NeMo Guardrails or Guardrails AI for policy and output structure.
Validators depend on their detectors, and detectors have gaps. Llama Prompt Guard and LlamaFirewall are released under Meta's Llama Community License rather than a standard open-source license, so read the terms before integrating them into a product.
Tool-boundary gates catch failures that text filters cannot. An abliterated model that produces a valid rm -rf command or a working exploit is a tool failure. Stop it where the agent requests an action: approval before irreversible steps, scoped credentials, and logging. The r/WebAfterAI thread lists Invariant as a tool-boundary block for MCP and agent stacks, and identity, delegation, and audit mechanisms are covered in A2A and MCP Agent Security.
A filter watching only the prompt cannot see the trigger that fires a bad call. ProjectDiscovery's backdoored Qwen2.5-7B model emitted an exfiltrating tool call on a hidden phrase the user never typed, so no input filter on the prompt could have caught it. Gate the action itself through allowlisted destinations, scoped credentials, and a human step before irreversible actions.
What each layer costs, and what it misses
| Layer | Stops | Does not stop | Latency | Fragile to |
|---|---|---|---|---|
| System-prompt policy | Requests the model will honour the rule on | Anything that outranks the rule in the window | none | long context |
| Input filter (classifier/rules) | Known-bad prompt patterns | Novel phrasing, encoded payloads | low | detector coverage |
| Output filter | Output that trips a rule or fails schema | Content the detector is blind to | low | detector coverage |
| Tool-boundary gate | Irreversible or scoped-exceeded actions | A malicious-but-valid action | low–med | your threat model |
A common stack probes first with Garak, applies LLM Guard to input and output, adds NeMo Guardrails or Guardrails AI for policy and structure, and places a gate at the tool boundary if the system uses tools. These filters add defense in depth on top of network isolation.
The localhost failure mode
The primary failure mode is serving a model with no safety layer. An abliterated checkpoint running under Ollama or llama.cpp starts as an unguarded OpenAI-compatible endpoint on localhost. Helix's guide and apidog's ranking both warn that any browser tab can fire a cross-origin request at localhost:11434 and use the endpoint.
Bind the endpoint to loopback, as the Ollama CLI cheatsheet shows for the server settings. Then place an authenticating reverse proxy in front of it, as in Ollama behind a reverse proxy. The unfiltered API is an internal service with a real blast radius. For where to run the model once the filters are decided, the LLM Hosting pages compare local, self-hosted, and cloud setups.
Where the policy should live, by job
- Personal chat, one user, trusted input: system-prompt policy is sufficient. Isolate the port and skip classifier layers.
- Coding or agent work: a tool-boundary gate is mandatory, because the commands the model produces that are dangerous are often the same commands that are useful. An output filter on structure catches the remaining issues.
- A multi-user service on an uncensored backend: run the full stack of probe, input and output filter, policy layer, tool gate, and audit log.
The choice of non-refusing model sets how much of this is a policy file and how much is a filter you operate. The model-side layers are cheap to write and weak under pressure, and the external layers cost latency and upkeep but hold when the model does not.
Top comments (0)