Unfiltered AI Models: Types, Trade-offs and How to Test

What people mean by an unfiltered model

The term is loose. It never means a model with no limits at all, and no honest provider can promise that. It means a model whose training or weights were changed so that it does not refuse on topic alone. Typical reasons to want one are fiction and roleplay with mature themes, companion apps for adults, security research on your own systems and plain frustration with lectures.

The models themselves usually start as open-weight releases. Open-weight families such as Llama, Mistral and Qwen get community variants, and the way a variant is made tells you what to expect from it.

The main types

Base models

A base model predicts text and was never trained to refuse, because it was never trained to follow instructions either. It continues what you write. Useful for creative continuation, awkward for chat and tools.

Uncensored fine-tunes

Instruction-tuned models retrained on data in which refusals are removed or replaced by answers. Quality depends on the dataset. Good ones keep instruction following intact. Poor ones become rambling or lose tool-calling.

Abliterated models

Here the weights are edited to remove the internal direction associated with refusals, with no retraining. It is a fast technique and can leave small quality losses, so it needs testing.

Lightly aligned originals

Some open models are simply less restrictive out of the box. They refuse less than the most cautious ones, and the behaviour is not guaranteed across topics.

What to measure before you commit

Check	Why it matters	How to test
Refusal rate	The reason you are here	Run 100 to 200 of your real prompts and count refusals
Answer quality	Edits and fine-tunes can lower it	Compare outputs side by side on the same prompts
Instruction following	Formats, length limits, personas	Ask for exact JSON, word limits, specific voices
Tool calling	Needed for agents	Run a function-call round trip
Long context	Chats and documents	Place a fact early, ask for it after many tokens
Consistency	Same prompt, same behaviour	Repeat each prompt several times

A refusal-rate test you can run

This script reads prompts from prompts.txt, one per line, calls the model with four parallel workers and counts replies that look like refusals. Keyword matching is crude, so open the flagged replies and read them. It also catches the case where a model answers but tacks on a warning, which you may or may not care about.

Copyimport os
from concurrent.futures import ThreadPoolExecutor
from openai import OpenAI

client = OpenAI(
    base_url="https://api.unfilteredai.cc/v1",
    api_key=os.environ["API_KEY"],
)

MARKERS = ["i can't", "i cannot", "i'm sorry", "i am sorry", "i won't", "as an ai", "i'm not able to"]

def ask(prompt):
    r = client.chat.completions.create(
        model="uncensored",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=400,
        temperature=0.7,
    )
    text = r.choices[0].message.content or ""
    return prompt, text, any(m in text.lower() for m in MARKERS)

prompts = [p.strip() for p in open("prompts.txt") if p.strip()]
with ThreadPoolExecutor(max_workers=4) as pool:
    results = list(pool.map(ask, prompts))

flagged = [r for r in results if r[2]]
print(f"{len(flagged)} of {len(results)} flagged ({100 * len(flagged) / len(results):.1f} percent)")
for prompt, text, _ in flagged:
    print("PROMPT:", prompt)
    print("REPLY:", text[:200], "\n")

Keep workers at 8 or fewer so you stay inside the concurrency limit of a full key. A trial key allows 2 concurrent requests, so set the worker count to 2 there.

Cost: 200 prompts at about 200 input and 400 output tokens each is 40,000 input and 80,000 output tokens, which is 40,000 x $0.15 / 1M + 80,000 x $0.50 / 1M = $0.006 + $0.04 = $0.046.

Ways to run one

Locally

You need enough memory to hold the weights. Quantised versions use less memory at some cost in quality. This gives you full privacy and no per-token bill, and you handle updates, speed and any concurrent use.

Rented GPU

You run an inference server on a rented machine. It suits spiky experiments, but an idle machine still costs money and you maintain it.

Hosted API

You send HTTP requests and pay per token. Nothing to maintain, and it works with any OpenAI-compatible client. The trade-off is that you do not choose the weights.

Size, quantisation and what they trade away

Larger models usually follow instructions better and hold longer plots together, and they need more memory and compute. Quantisation stores weights in fewer bits, which shrinks memory use and speeds up inference, and can cost some accuracy. For casual chat the loss is often small. For tool calling and strict formats it tends to show first, so test those. Mixture-of-experts designs activate only part of the network per token, which changes the speed-to-quality trade-off in their favour on suitable hardware.

Whatever you pick, compare like with like. Run the same prompts at the same settings, and do not judge a model by a single impressive answer.

Licenses and model cards

Every open-weight model has a license, and fine-tuned or edited variants usually inherit it. Some allow commercial use freely, some restrict large deployments, and some set rules on how outputs may be used. Read the license before you build a product on a checkpoint, and keep a record of the exact version you tested.

Model cards on community hubs are a start for evaluation, but treat claims as claims. A card that says "no refusals" tells you the intent. Your prompt set tells you the result. Look for the method used (fine-tune or abliteration), the base model, the quantisation and any known weaknesses the author lists.

Pitfalls when you evaluate refusals

• Keyword matching misses soft refusals. A model may reply with a vague non-answer or change the subject. Read a sample of replies for every run.
• It also flags false positives. A story in which a character turns someone down is not a refusal by the model. Check flagged items before you count them.
• A system prompt changes the numbers. Test with the system prompt you will actually ship.
• Fewer refusals are not always better. A model that answers everything without regard to the context you gave it can produce off-topic or careless text.
• Test sets go stale. Add the cases that fail in production to the set.

Using the hosted option

Our endpoint serves one open-weight model, run by an independent provider and tuned to answer without content refusals for lawful adult use. It is not the official API of any model vendor, and not a router across vendors. The context window is 100,000 tokens. It supports streaming, tool calling and JSON mode. It is text only.

The test script above is all you need to try it. The base URL is https://api.unfilteredai.cc/v1 and the model ID is uncensored. Claim the $0.50 trial credit on the API key page, run your prompt set, and decide with data. Parameters and error codes are in the documentation, and the pricing page lists top-up bonuses. Our comparison of uncensored LLM options puts hosted choices side by side.

The same rule applies everywhere: no sexual content involving minors. Prompts are not used for training.

More guides

• Unfiltered AI API: Endpoint, Headers and First Request
• Unfiltered AI Chat: Compare Top Uncensored LLM Options