How to Run Hermes 4 and Uncensored Fine-Tunes via API in 2026

You can run Nous Hermes 4 and uncensored fine-tunes like Dolphin through any OpenAI-compatible API by changing two lines of client code: the base URL and the API key. Pick a hosted provider that lists the model, or self-host the open weights with vLLM. This guide walks both paths.

Key takeaways

• Hermes 4 ships in 2 open-weight sizes (70B and 405B), so the same checkpoints run on third-party hosted APIs or on your own GPUs.
• Switching providers is typically a 2-line change (base_url + api_key), because nearly every open-weight host speaks the OpenAI chat-completions schema.
• A 70B model needs roughly 2 bytes of VRAM per parameter at 16-bit precision (~140 GB before the KV cache); 4-bit quantization cuts that to about a quarter.
• "Uncensored" is a spectrum, not a binary: low-refusal claims on model cards are self-reported, and DeAI's refusal-index methodology scores actual compliance versus refusal across prompt categories rather than trusting labels.
• Hosted uncensored endpoints typically cost a fraction of frontier-API pricing, but retention and moderation terms differ per provider. Read the policy page, not the landing page.

What exactly are Hermes 4 and "uncensored" fine-tunes?

Three families of models dominate the low-refusal niche, and they get there in different ways. Knowing which mechanism you're dealing with matters, because it determines how the model behaves under a system prompt and how much you should trust the label.

Nous Hermes 4 70B and 405B

Hermes 4 is the fourth-generation open-weight instruct series from Nous Research. According to the model cards, Hermes 4 70B is post-trained from Meta's Llama 3.3 70B, while Hermes 4 405B builds on Llama 3.1 405B. The series' headline feature is a hybrid reasoning mode: the model can produce extended chain-of-thought traces when steered, or answer directly when you want lower latency. Nous positions Hermes as a steerable, maximally helpful series. Treat that as the developer's positioning and verify it against your own prompt set, as you should with any vendor claim.

Because the weights are public, Hermes 4 shows up on many hosted inference catalogs, and you can also serve it yourself. That dual availability is the whole point of this guide.

Dolphin fine-tunes

Dolphin is a long-running family of fine-tunes from Eric Hartford's cognitivecomputations project, built on various bases (Llama and Qwen variants, among others). The creator explicitly describes Dolphin as uncensored, with alignment moved into the system prompt so the deployer, not the lab, decides acceptable behavior. That description is documented on the model cards; it is still a self-reported claim, but it is at least a specific, checkable one: you can probe the system-prompt steerability yourself in an afternoon.

Abliterated checkpoints

A third path is abliteration: a weight-level edit that removes the "refusal direction" identified by Arditi et al. in Refusal in Language Models Is Mediated by a Single Direction, without retraining. Community publishers apply it to many popular bases. Abliterated models behave differently from fine-tuned ones; the edit can occasionally blunt instruction-following edge cases, so it is worth understanding the technique before committing to it in production. Our explainer on abliterated and uncensored models covers the mechanics and the trade-offs.

Where can you get uncensored model API hosting?

Catalogs change weekly, so treat every provider's model page as the source of truth. Historically, Hermes and Dolphin family models have been listed by aggregators and serverless hosts such as OpenRouter, Featherless (which specializes in long-tail open weights), DeepInfra, Hyperbolic, Novita, and Together. Check each catalog for the exact variant and quantization currently served.

Evaluate candidates on identical criteria:

• Exact model ID and variant. "Hermes 4 70B" might mean full-precision, AWQ, or FP8 depending on the host. The served quantization affects output quality.
• Context length actually exposed. Hosts frequently cap context below the model's trained window to control costs.
• Host-level moderation. Some providers layer their own content filters on top of the weights. An uncensored model behind a filtered endpoint still refuses at the API layer. This is a property of the host, not the checkpoint.
• Retention and privacy policy. Read the data-policy page. Statements like "we don't store prompts" are policy commitments, not independently verified facts, whoever makes them.
• Pricing page. Hosted open-weight endpoints typically run a fraction of frontier-API pricing, but the spread between providers is wide enough to be worth an hour of comparison.

For a tracked, criteria-based comparison, see our roundup of the best uncensored AI APIs.

Decentralized and privacy-focused options

If you prefer not to depend on a single company's infrastructure, decentralized networks route requests to independent operators. Chutes is one such network; Morpheus is a decentralized inference marketplace in the same category. Apply the same checklist as above (model ID, context, moderation, retention), since operator behavior can vary inside a network. Venice, a centralized provider, markets a no-retention privacy posture; as with any provider, that is a policy statement rather than a verified property. None of these structural differences exempts you from testing the endpoint yourself.

How do you call Hermes 4 from an OpenAI-compatible API?

The integration pattern is identical across nearly every open-weight host: create an account, generate an API key, copy the exact model ID from the provider's catalog, and point your client at the provider's base URL. Model ID strings differ per host (one might use NousResearch/Hermes-4-70B, another nous/hermes-4-70b), so always copy rather than guess.

Python, using the standard openai client:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.your-provider.example/v1",  # provider's OpenAI-compatible endpoint
    api_key="YOUR_PROVIDER_KEY",
)

resp = client.chat.completions.create(
    model="nous-hermes-4-70b",  # exact model ID varies by provider — copy from the catalog
    messages=[
        {"role": "system", "content": "You are a precise technical assistant."},
        {"role": "user", "content": "Explain mixture-of-experts routing in one paragraph."},
    ],
    temperature=0.7,
)
print(resp.choices[0].message.content)

The same call with curl:

curl https://api.your-provider.example/v1/chat/completions \
  -H "Authorization: Bearer YOUR_PROVIDER_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nous-hermes-4-70b",
    "messages": [{"role": "user", "content": "Hello"}],
    "stream": false
  }'

Streaming, tool calling, and reasoning-mode toggles work through the same schema where the host supports them. Check the Hermes 4 model card for the creators' recommended sampling settings before you tune temperature by feel.

How do you self-host Hermes 4 70B with vLLM?

Self-hosting trades a per-token bill for full custody: prompts never leave your hardware, and no host-side moderation layer exists. The arithmetic is straightforward. At 16-bit precision, plan on roughly 2 bytes of VRAM per parameter, about 140 GB for the 70B before the KV cache, which fits a pair of 80 GB data-center GPUs. A 4-bit quantized build (AWQ or GPTQ) drops weights to roughly 35–40 GB, within reach of a single 48 GB card or a pair of consumer 24 GB cards. The 405B is a different league: think a full 8-GPU node at 16-bit, or several GPUs at 4-bit. Hourly GPU marketplaces such as RunPod, Vast.ai, and Lambda rent all of these configurations; compare their current rate cards.

vLLM is the default serving stack because its continuous batching keeps throughput high under concurrent load, and it exposes an OpenAI-compatible server out of the box:

pip install vllm

vllm serve NousResearch/Hermes-4-70B \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.92

For a quantized deployment, point --model at an AWQ checkpoint instead. Once the server is up, the client code from the previous section works unchanged. Just swap the base URL and use any placeholder key:

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

That is the entire migration story: hosted and self-hosted endpoints are interchangeable behind the same interface, which is also your vendor lock-in insurance. For production, put the server behind authentication and a load balancer, and pin your vLLM version so upgrades are deliberate.

How "uncensored" are these models in practice?

Less than the label implies, and the variance comes from three places. First, the mechanism: fine-tuned compliance (Dolphin), steerability-focused post-training (Hermes), and weight edits (abliteration) produce different refusal profiles, and none reduces refusals to literally zero. Second, the host: a provider's own moderation layer can reintroduce refusals regardless of the checkpoint. Third, the prompt itself: refusal rates are a distribution across categories, not a single number.

This is why DeAI's refusal-index methodology scores model responses across prompt categories instead of accepting "uncensored" as a label, and why creator claims, however well-documented on a model card, remain self-reported until probed. The practical move is a small eval of your own: 20–30 prompts spanning the categories you actually care about, run against each candidate endpoint, scored for compliance versus refusal. An afternoon of that beats any landing page.

FAQ

What is Nous Hermes 4 70B?

The mid-size model in Nous Research's Hermes 4 open-weight series, post-trained from Meta's Llama 3.3 70B per its model card. It exposes a hybrid reasoning mode and can be called from hosted OpenAI-compatible APIs or self-hosted with vLLM.

Where can I find uncensored model API hosting?

Aggregators and serverless hosts such as OpenRouter, Featherless, DeepInfra, Hyperbolic, and Novita have listed Hermes and Dolphin family models; decentralized options include Chutes and Morpheus, a decentralized inference marketplace. Catalogs change often, so check each provider's model page.

Can I run a Dolphin fine-tune via API?

Yes. Dolphin checkpoints are open weights, so any host that lists them can serve them behind an OpenAI-compatible endpoint, and you can deploy any Dolphin variant yourself with vLLM. The exact model ID differs per provider, so copy it from the provider's catalog.

Are uncensored models truly refusal-free?

No. "Uncensored" describes a spectrum of lower-refusal tuning, and creators' claims are self-reported. Hosts may also layer on their own moderation. DeAI's refusal-index methodology scores responses across prompt categories; the practical test is your own prompt set.