How to run Hemmingway-1 locally

To run Hemmingway-1 locally, download the open weights from Hugging Face (Altworld/Hemmingway-1) and serve them with vLLM, or load them with Hugging Face Transformers as an ordinary chat model. It is a 27B model built on Qwen3.8-27B, with a 262,144-token context, released under Apache-2.0, so you may use it commercially.

The catch is memory. At 16-bit precision the weights alone take roughly 54 GB, before any room for context. That usually means a single large data-centre GPU or several smaller ones. If you do not have that, the same model is available through an OpenAI-compatible API as hemmingway-27b.

What you need

You also need Python, a recent version of vLLM or Transformers, and a machine with enough GPU memory. There is no official GGUF or quantised release of Hemmingway-1. The only weights we publish are the full ones on Hugging Face.

How much memory it needs

Here is the arithmetic, stated plainly so you can check it.

• A parameter stored at 16-bit precision takes 2 bytes.
• Hemmingway-1 has about 27 billion parameters.
• 27 billion times 2 bytes is about 54 GB.

That 54 GB is the weights alone. On top of it comes the memory for the context: every token the model is holding in the conversation takes space, and a 262,144-token context is a lot of tokens. The more context you ask for, the more memory you need beyond the 54 GB. There is also some overhead for the framework itself.

In practice this means planning for more than 54 GB of GPU memory, not exactly 54. If one card does not have enough, vLLM and Transformers can both spread the model over several cards. We have not published tested hardware setups, so treat this as a sizing rule rather than a recommendation for a particular card.

Option 1: serve it with vLLM

vLLM is the simplest way to run it as a server. The README gives one command:

vllm serve Altworld/Hemmingway-1 --max-model-len 262144

What that does:

1. vllm serve downloads the weights from Hugging Face the first time and starts a server.
2. Altworld/Hemmingway-1 is the model to load.
3. --max-model-len 262144 sets the longest context the server will accept, which is the model's full context.

If the server will not start because it runs out of memory, the first thing to try is a smaller --max-model-len. Most writing jobs, such as a reply to an email thread or a rewrite of a page of notes, need far less than 262,144 tokens, and a shorter limit means less memory set aside for context. If you have several GPUs, vLLM's --tensor-parallel-size option splits the model across them.

Once it is running, vLLM speaks an OpenAI-compatible API on your own machine, so any code written for OpenAI's Chat Completions can point at it. Use Altworld/Hemmingway-1 as the model name.

Option 2: load it with Transformers

If you want the model inside a Python script rather than behind a server, Transformers works too. The README's example, step by step:

1. Import the two classes: from transformers import AutoModelForCausalLM, AutoTokenizer
2. Name the model: model_id = "Altworld/Hemmingway-1"
3. Load the tokenizer: tok = AutoTokenizer.from_pretrained(model_id)
4. Load the model, letting Transformers place it on your GPUs and pick the precision: model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto", dtype="auto")
5. Write the conversation as a list of messages: messages = [{"role": "user", "content": "Write the text I send my landlord about the broken boiler."}]
6. Turn it into model input with the chat template: ids = tok.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt").to(model.device)
7. Generate: out = model.generate(ids, max_new_tokens=512)
8. Print only the new text, not the prompt: print(tok.decode(out[0][ids.shape[-1]:], skip_special_tokens=True))

device_map="auto" is what lets Transformers spread the model over more than one GPU, or put part of it in ordinary memory if it has to. Putting part of a model in ordinary memory works but is slow, so it is fine for a test and not for a product.

Two practical notes. Hemmingway-1 thinks before it answers, so leave max_new_tokens enough room for the thinking and the reply together. On the hosted API, thinking counts towards the token limit in the same way. And always build the prompt with apply_chat_template rather than writing the special tokens by hand, so the conversation reaches the model in the format it was trained on.

Checking it works

A quick test is the one in the README: ask for the text you would send your landlord about a broken boiler. A working setup gives you the text itself, ready to send, without a preamble, three options or a note about tone. That is how the model was trained to answer, and it is the easiest way to see it is running as it should.

Try HemmingwayDownload the app

Option 3: no hardware at all

If 54 GB of GPU memory is not something you have lying around, you can use the same model over the internet.

• The API. Hemmingway-1 runs behind an OpenAI-compatible API at https://hemmingway.io/v1 as the model hemmingway-27b. If your code already uses OpenAI's SDK, you change the base URL, the key and the model name. The API docs show every field, and keys are made on the API platform, which is also where the API prices are.
• The app. If you want to write with it rather than build on it, the Hemmingway app on Mac, Windows, Android and the web uses the same model.

Running it yourself makes sense when you need your data to stay on your own machines, want to fine-tune it, or already have the GPUs. The API makes sense when you do not want to manage hardware. Both use the same weights.

What to expect from it

Hemmingway-1 was built for writing that sounds like a person: messages, emails, notes, and stories. In our own blind tests, CommunicationBench and Human-Likeness, it came first of the models we tested, including much larger ones. On the public EQ-Bench 4 it placed third, behind Fable 5 and Kimi K3. On long fiction, larger story models such as Fable 5 Max and GLM-5.3 score higher on our StoryBench. The full numbers are on the model card.

It is English-first. It can be wrong and still sound certain, so do not use it to decide anything medical, legal or financial.

Common questions

Is there a GGUF or quantised version of Hemmingway-1?

No. There is no official GGUF or quantised release. The only weights we publish are the full ones on Hugging Face at Altworld/Hemmingway-1, and we have not tested any other versions.

How much VRAM does Hemmingway-1 need?

At 16-bit precision, 27 billion parameters at 2 bytes each is roughly 54 GB for the weights alone. The context needs memory on top of that, and more the longer the context you allow. Plan for more than 54 GB of GPU memory, spread over several cards if needed.

Can I use Hemmingway-1 commercially?

Yes. It is released under Apache-2.0, which allows commercial use, changes and redistribution under the licence's terms. The README puts it simply: yours to use, including commercially.

Can I run Hemmingway-1 on a laptop?

Only if the laptop has well over 54 GB of GPU memory to spare, which most do not. The practical options on ordinary hardware are the Hemmingway app or the hosted API, which run the same model.

What is the model name to use with the API?

On the hosted API the model is called hemmingway-27b, at the base URL https://hemmingway.io/v1. On your own vLLM server, use the Hugging Face name, Altworld/Hemmingway-1.