Abliterated models.
From idea to first request.

What is an abliterated model?

Abliteration changes how a model represents refusal. One influential research result identified a direction associated with refusal in the internal activations of the chat models studied. Intervening on that direction reduced refusal behavior. The finding describes those experiments; it does not prove that every model or modified checkpoint behaves the same way. Read the original research by Arditi and colleagues.

Community implementations can apply this idea by changing model weights, so the modification remains when the model is loaded. Maxime Labonne’s abliteration walkthrough explains one such approach. You do not need to edit weights to use an abliterated model: choose a published checkpoint or a provider that serves one.

The practical question is whether the particular model helps with your work. Try a task with a clear result: suggesting test cases, editing code that has tests, or summarizing a document whose facts you know. Evaluate the answer, including errors and unnecessary refusals.

Abliterated vs. uncensored: what is the difference?

“Abliterated” refers to a kind of model modification. “Uncensored” is a broader label used for models and services with reduced refusal behavior; the label alone does not specify how a model was trained or changed. Ask for the model identity, modification details and provider’s limits.

Model behavior, API rules and agent permissions are separate. A model’s willingness to produce a response does not grant an agent access to your files, authorize a tool action, or change a service’s terms.

Choose hosted API access or a local model

Use a hosted API when you want to start with a key and a request. Consider local inference when controlling the runtime and working with downloadable weights matters enough to manage the hardware and setup.

The API example below uses Oathbreaker, the service we operate. Oathbreaker supplies the account, gateway and usage accounting; its inference suppliers host modified GLM models. We do not train the underlying model. See who operates Oathbreaker, data handling and the model’s provenance and limits.

How to use an abliterated model through an API

This first request asks for test ideas. It does not execute code or give the model tools. You need a terminal with cURL, an Oathbreaker account with prepaid credit, and an API key.

1. Create your account, review current pricing, and add credit.
2. Create a key in your console. Set it as OATHBREAKER_API_KEY in your terminal environment. Keep the value out of source control and browser code.
3. Send the request below. Running it uses prepaid credit. The selected model is oathbreaker-glm-5.3-flash; it comes from the service’s current public model list.

curl --fail-with-body --silent --show-error --max-time 650 \
  https://oathbreaker.ai/v1/chat/completions \
  -H "Authorization: Bearer $OATHBREAKER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "oathbreaker-glm-5.3-flash",
  "messages": [
    {
      "role": "user",
      "content": "Suggest three tests for a CSV import tool. Return a numbered list with one sentence per test."
    }
  ],
  "max_tokens": 2048,
  "reasoning_effort": "low",
  "stream": false
}'

This uses the Chat Completions endpoint. In an OpenAI-compatible SDK or agent, set the base URL to https://oathbreaker.ai/v1; the client adds the completion path. Compatibility does not imply support for every OpenAI endpoint.

Prefer Python?

Save this as first_request.py and run python3 first_request.py with the same environment variable. It uses Python’s standard library and prints the final answer, finish reason and usage.

import json
import os
import urllib.error
import urllib.request

payload = {
    "model": "oathbreaker-glm-5.3-flash",
    "messages": [
        {
            "role": "user",
            "content": "Suggest three tests for a CSV import tool. Return a numbered list with one sentence per test."
        }
    ],
    "max_tokens": 2048,
    "reasoning_effort": "low",
    "stream": False
}
request = urllib.request.Request(
    "https://oathbreaker.ai/v1/chat/completions",
    data=json.dumps(payload).encode("utf-8"),
    headers={
        "Authorization": "Bearer " + os.environ["OATHBREAKER_API_KEY"],
        "Content-Type": "application/json",
    },
    method="POST",
)

try:
    with urllib.request.urlopen(request, timeout=650) as response:
        result = json.load(response)
except urllib.error.HTTPError as error:
    print("HTTP", error.code)
    print(error.read().decode("utf-8"))
    raise SystemExit(1)

choice = result["choices"][0]
print(choice["message"].get("content") or "No final answer returned.")
print("Finish reason:", choice.get("finish_reason"))
print("Usage:", json.dumps(result.get("usage", {})))

Each example makes one request and has no automatic retry. The 2,048-token output budget includes reasoning as well as the final answer. Check the finish reason before deciding that an empty or truncated answer is a model failure.

Check the result before expanding the task

One recorded request

On November 13, 2026, we sent the prompt above to oathbreaker-glm-5.3-flash with low reasoning and a 2,048-token output budget. It completed in one attempt, with no tools executed, and returned:

1. Test that a well-formed CSV with headers, quoted commas, and Unicode characters imports all rows and columns without data corruption.
2. Test that malformed rows, missing columns, and inconsistent quoting produce clear errors or documented handling rather than silent corruption.
3. Test that a large CSV file imports within acceptable time and memory limits while preserving row count and field values.

The API reported 72 input tokens, 236 output tokens and a stop finish reason. At that day’s published Flash rates, the usage calculates to $0.00039; this is a calculation from returned usage, not a separate billing-ledger audit. This single request demonstrates the connection and response format. It does not establish general model quality or a typical task cost.

Turn a response into checks

A useful answer should give three distinct test ideas that you can turn into checks. For this CSV task, examples of relevant coverage include quoted commas, missing required columns and malformed rows. These are evaluation suggestions, not a quoted model response.

1. Check instruction following. Did it return three numbered items and one sentence per item?
2. Check correctness. Would each proposed test catch a real problem in your importer? Reject invented behavior or duplicated cases.
3. Check completion. Inspect choices[0].finish_reason. A length-limited result needs a different budget or a smaller task, not an automatic assumption that the model cannot answer.
4. Check usage. Compare returned token usage with the request in your console. Record the model, prompt, settings, result and charge when comparing runs.

On the selected model, current rates per million tokens are $0.50 input, $0.05 cached input and $1.50 output. Cache hits are reported by the provider and are not guaranteed. Read how charges and credit reservations work.

For an agent, compare completed tasks and human corrections as well as token rates. A cheaper request that needs several retries may cost more to finish the work. A single successful example is a setup check, not a general quality benchmark.

Connect an agent after the first request works

Use the same key and base URL in Hermes or the OpenCode custom-provider configuration. Choose the exact model identifier from this guide or the model list. Follow the configuration for your installed client version.

Give the agent a small task in a sample repository, such as adding a CSV parser test. Read the changes and run the test suite. Your agent controls file access and tool execution; Oathbreaker returns model messages and tool-call arguments. Validate those arguments and choose permissions in the client.

For your own application, start with the Python and JavaScript examples, then add streaming or function calling when you need them.

How to approach a local abliterated model

Start with a downloadable checkpoint whose model card identifies the base model, modification and license. Check that your runtime supports its architecture and file format. Choose a size and quantization that fit your machine, allowing memory for the context and runtime as well as the weights.

For example, Ollama documents importing compatible Safetensors or GGUF files through a Modelfile, then creating and running the model. Follow its official import guide for your files. llama.cpp is another runtime with local inference and server options; consult its current model and hardware support.

Run the same small evaluation task before adding long conversations or tools. Record the checkpoint, quantization, runtime version and settings so a comparison is repeatable. This is a local evaluation workflow, not a claim that Oathbreaker’s served GLM derivative is downloadable or fits a consumer laptop.

Common first-request problems

The API error reference explains request and retry behavior. If you need help, contact support@oathbreaker.ai with the request ID and error code, without your key or private prompt.

Make your first request.

Use a task you understand, inspect the answer, then give it more work. Keep the model’s behavior, your application’s permissions and the service’s limits in view.