Use GLM 5.3 Abliterated and Uncensored Models with RouterHub

What this project provides

This RouterHub repository combines a GLM 5.3 model guide, API examples, evaluation advice, and 35 prompt files for model-behavior research. It focuses on the standard, Flash, abliterated, and uncensored GLM 5.3 catalogue entries while also explaining how one RouterHub account can access supported GPT, Claude, DeepSeek, Qwen, and Grok models.

The repository is primarily documentation and reusable configuration material rather than a software package. You can review its files offline, place selected instructions into compatible clients, or connect an application to RouterHub’s hosted API.

Reduced refusal is a behavior to measure, not a guarantee that a model will answer every request or produce correct results.

Understand the GLM 5.3 variants

The labels abliterated and uncensored describe related but different ideas.

• GLM 5.3 Abliterated: a research variant associated with interventions in model weights intended to reduce refusal-related behavior.
• GLM 5.3 Uncensored: a broader product category that may involve training changes, weight changes, or a prompt-level persona.
• GLM 5.3: the standard catalogue entry.
• GLM 5.3 Flash: a separate entry whose quality, latency, capabilities, and rates should be evaluated independently.

The repository does not independently inspect hosted weights or publish refusal-rate benchmark results. Always verify the live catalogue entry and test its behavior with your own legitimate tasks.

Available GLM model IDs

• glm-5.3-abliterated
• glm-5.3
• glm-5.3-flash
• glm-5.3-uncensored
• glm-5.3-flash-uncensored

These GLM entries use the Chat Completions protocol. Availability, capabilities, and rates may change, so check the live RouterHub model catalogue before deployment.

Key features

• OpenAI-compatible access: call listed GLM models through Chat Completions using familiar SDKs.
• One account for multiple families: use a prepaid RouterHub account to access supported GLM, GPT, Claude, DeepSeek, Qwen, and Grok entries.
• Thirty-five prompt files: review system prompts, assistant specifications, workspace profiles, agent instructions, Ollama Modelfiles, and a Grok configuration.
• Coding-tool guidance: match OpenCode, Cursor, Continue, Cline, Claude Code, Codex CLI, LangChain, or LlamaIndex with an appropriate protocol.
• Evaluation resources: compare model variants using task quality, refusal behavior, instruction following, repeatability, latency, and total cost.
• Prepaid usage billing: fund an account and pay according to the selected model’s published token rates.

Set up RouterHub API access

1. Create and fund an account

Register with RouterHub, add prepaid credits, and create a private API key. An inference request consumes credits, so begin with a small test and review the resulting usage charge.

2. Store the credentials safely

RouterHub publishes https://routerhub.si/v1 as its API base URL. Store the URL and key in environment variables:

export ROUTERHUB_API_KEY="<your-private-key>"
export ROUTERHUB_API_BASE_URL="https://routerhub.si/v1"

Do not commit a real key to the repository. For production systems, use the secret manager supplied by your hosting platform.

3. Install the OpenAI SDK

The listed GLM 5.3 models use Chat Completions, so install the OpenAI Python client:

python -m pip install openai

Make your first GLM 5.3 request

Create an OpenAI client with RouterHub’s base URL and your private key. Then submit a Chat Completions request using the exact catalogue ID:

import os
from openai import OpenAI

api = OpenAI(
    base_url=os.environ["ROUTERHUB_API_BASE_URL"],
    api_key=os.environ["ROUTERHUB_API_KEY"],
)

result = api.chat.completions.create(
    model="glm-5.3-abliterated",
    messages=[
        {
            "role": "user",
            "content": "Explain what an API gateway does in two sentences."
        }
    ],
)

print(result.choices[0].message.content)

To compare another variant, keep the request unchanged and replace only the model ID. For example, use glm-5.3 as a standard-model baseline or glm-5.3-uncensored to evaluate the separately listed uncensored entry.

Add a system instruction

A system message can define output requirements for a supported Chat Completions request:

result = api.chat.completions.create(
    model="glm-5.3-flash",
    messages=[
        {
            "role": "system",
            "content": "Answer concisely and identify uncertain claims."
        },
        {
            "role": "user",
            "content": "Suggest tests for a function that parses CSV rows."
        }
    ],
)

print(result.choices[0].message.content)

Check whether each variant follows your system instructions as intended. The uncensored label alone does not explain whether an implementation uses weight changes, training changes, or a fixed persona that could affect instruction handling.

Use the bundled prompt collection

All 35 research prompt files are stored in the repository’s jailbreaks/ directory. They cover GLM and ZCode, Claude, DeepSeek, Kimi, Grok, Gemini, Mistral, Qwen, Gemma, GPT-OSS, and several OpenCode-oriented models.

System prompts

Copy a file’s contents into the system-prompt or custom-instructions field provided by your API, chatbot, agent, or harness. Through Chat Completions, that usually means placing the text in a message whose role is system.

Project-level agent instructions

Files designed as AGENTS.md instructions should be saved under that exact name in the root of the relevant repository or workspace. Compatible coding agents can then treat the file as project-level guidance.

Persistent workspace policies

Assistant operating specifications and workspace profiles belong in a client’s persistent instruction location. The README gives this OpenCode path as an example:

~/.config/opencode/AGENTS.md

Other tools may use different paths, so consult the client’s documentation before installing a policy globally.

Ollama Modelfiles

The Gemma 4 and GPT-OSS 20B prompt files contain Ollama-style FROM and SYSTEM blocks. Create a local model from one of these files with:

ollama create gemma4-jb -f jailbreaks/gemma4.md

Change the output model name and source path when using another Modelfile.

Grok configuration

The jailbreaks/grok-config.txt file is intended for the target harness’s configuration field, not for an ordinary conversation message.

Prompt behavior is version-dependent. Model updates and instruction-hierarchy changes can make a previously effective file behave differently.

Choose a compatible client and protocol

A shared RouterHub key does not make every model compatible with every API protocol. Select the model and client together.

• OpenAI SDK: provide the RouterHub base URL, key, and an exact GLM model ID.
• OpenCode: use a Chat Completions provider configuration for the selected GLM entry.
• Continue or Cline: follow their compatible Chat Completions setup.
• Cursor: verify that your installed version supports a custom Chat Completions endpoint and the model features you require.
• LangChain or LlamaIndex: select a compatible Chat Completions integration and validate application-specific features.
• Claude Code or Anthropic SDK: select a catalogue entry supporting Anthropic Messages, such as a supported Claude model. The listed GLM variants do not use Messages.
• Codex CLI: choose a model supporting Responses instead of a Chat-only GLM entry.

Optional Claude Messages example

The same RouterHub account can serve supported Claude models through the Anthropic-compatible Messages API. This is not an alternative endpoint for GLM. Install the Anthropic SDK first:

python -m pip install anthropic

Then use a supported Claude catalogue entry:

import os
from anthropic import Anthropic

api = Anthropic(
    base_url=os.environ["ROUTERHUB_API_BASE_URL"],
    api_key=os.environ["ROUTERHUB_API_KEY"],
)

result = api.messages.create(
    model="claude-opus-5-5",
    max_tokens=64,
    messages=[
        {
            "role": "user",
            "content": "Explain what an API gateway does in two sentences."
        }
    ],
)

for part in result.content:
    if part.type == "text":
        print(part.text)

Evaluate variants systematically

A useful comparison requires more than finding one permissive response. Run the same legitimate tasks against the standard, Flash, abliterated, and uncensored entries, then record consistent measurements.

1. Define representative tasks. Include coding, agent, analysis, writing, or bilingual scenarios that reflect your application.
2. Keep inputs consistent. Reuse the same prompts, system instructions, and relevant settings across models.
3. Measure unnecessary refusals. Record requests declined despite being answerable under your defined test policy.
4. Score task quality. Check correctness, useful detail, tested code, and appropriate expression of uncertainty.
5. Test instruction behavior. Verify formatting, system-message handling, project instructions, and required tool integration.
6. Check repeatability. Record the API ID, prompt revision, settings, repetition count, and test date.
7. Calculate total task cost. Include input and output tokens, failed attempts, retries, output length, and end-to-end latency.

The repository includes benign sample tasks in examples/benign-eval-prompts.json. It does not claim live benchmark scores, so treat these resources as a foundation for your own evaluation.

Advanced tips

Recheck the catalogue before deployment

Hosted availability, pricing, capabilities, and behavior can change. Confirm the exact model ID and supported protocol before releasing an integration, and rerun important tests after model updates.

Test Flash separately

Do not assume that GLM 5.3 Flash has the same quality or behavior as the standard model. Benchmark both using your latency, cost, and acceptance criteria.

Account for retries

A model with a lower token rate may still cost more per successful task if it needs longer prompts, generates excessive output, or requires repeated attempts. Compare completed-task cost rather than token prices alone.

Treat prompts as versioned assets

Record the model version or test date alongside every prompt revision. If an instruction file stops working, update it and document the failure rather than assuming the client is misconfigured.

Run offline repository checks

Documentation contributors can run the repository’s link and syntax checker without spending inference credits:

python tools/check.py

Protect private data

Hosted inference is not local inference. Review applicable provider terms and retention policies before sending confidential information. Keep humans in the loop for consequential actions, restrict agent permissions, and inspect generated code before execution.

Conclusion

This project offers a practical path from GLM 5.3 terminology to a working API request and repeatable model evaluation. Start with a funded RouterHub account, use the exact Chat Completions model ID, test variants on identical tasks, and treat abliterated or uncensored labels as hypotheses to verify rather than guarantees. The bundled prompt files can support research and agent configuration, but they should be versioned, reviewed, and used with appropriate privacy and deployment controls.