How to Run Hemmingway-1 Locally with vLLM or Transformers
Steps and context-length requirements for self-hosting the 27B Hemmingway-1 writing model with vLLM or Hugging Face Transformers.
What is Hemmingway-1?
Hemmingway-1 is a 27B parameter open-weight language model built on Qwen3.8-27B, released under Apache-2.0 by Altworld. It’s tuned specifically for everyday writing tasks (texts, emails, awkward messages you’ve been avoiding) rather than general chat or coding. The model is available through a hosted app at hemmingway.io, but the weights are also public on Hugging Face, which means anyone with the right hardware can run it locally with vLLM or Transformers instead of going through the hosted version.
TL;DR
- Hemmingway-1 is a 27B model fine-tuned from Qwen3.8-27B, released with open weights under Apache-2.0, so commercial use is permitted.
- The model supports a 262,144-token context window, which matters more for hardware planning than most people expect when self-hosting.
- You can serve it with a single command via vLLM (
vllm serve Altworld/Hemmingway-1 --max-model-len 262144), or load it directly with the Transformers library for more granular control. - It’s positioned as a writing-focused model rather than a general assistant: it’s built to output the actual message you need instead of a menu of options and caveats.
- On the model’s own CommunicationBench and Human-Likeness evaluations it scored ahead of several larger closed models, though those benchmarks were built and run by Altworld itself.
- It also posted a third-place result on EQ-Bench 4, an independent public benchmark, putting it within 12 points of the top model on that leaderboard.
- The model card is explicit that it’s English-first and can sound confident while being wrong, so it’s not suited for medical, legal, or financial decisions.
Remy doesn't build the plumbing. It inherits it.
Other agents wire up auth, databases, models, and integrations from scratch every time you ask them to build something.
Remy ships with all of it from MindStudio — so every cycle goes into the app you actually want.
How do you run Hemmingway-1 with vLLM?
The fastest path to a local (or self-hosted server) deployment is vLLM, which handles batching, memory management, and an OpenAI-compatible API out of the box. The model card gives a single command:
vllm serve Altworld/Hemmingway-1 --max-model-len 262144That flag matters. Hemmingway-1 supports a context length of 262,144 tokens (256K), and vLLM needs to know the maximum sequence length up front to allocate its KV cache correctly. If you don’t need the full context window, for instance if you’re only generating short messages and emails, you can pass a smaller value to --max-model-len and reduce memory pressure significantly. Running at the full 256K context on a 27B model requires substantial VRAM headroom for the KV cache on top of the weights themselves, so most people experimenting locally will want to cap this lower unless they specifically need long-document handling.
Once the server is running, it exposes an OpenAI-compatible endpoint, so any tooling built against the OpenAI chat completions API can point at it with minimal changes.
How do you run Hemmingway-1 with Transformers?
For anyone who wants direct control over generation, or who wants to integrate the model into a Python pipeline without standing up a server, Hugging Face Transformers is the alternative path. The model card provides a minimal working example:
from transformers import AutoModelForCausalLM, AutoTokenizer
model_id = "Altworld/Hemmingway-1"
tok = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto", dtype="auto")
messages = [{"role": "user", "content": "Write the text I send my landlord about the broken boiler."}]
ids = tok.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt").to(model.device)
out = model.generate(ids, max_new_tokens=512)
print(tok.decode(out[0][ids.shape[-1]:], skip_special_tokens=True))device_map="auto" lets Transformers distribute the model across available GPUs (or fall back to CPU if that’s all you have, though generation will be slow at 27B parameters on CPU). dtype="auto" picks an appropriate precision based on what the checkpoint ships with. Note that apply_chat_template is doing real work here: Hemmingway-1 is tuned to respond in a specific format (direct output, not a menu of options), and skipping the chat template will likely degrade that behavior.
What hardware do you actually need?
The model card doesn’t publish exact VRAM figures, so the honest answer is: it depends heavily on precision and context length. As a general rule of thumb for a 27B dense model, running at full (bf16/fp16) precision requires on the order of 54GB+ just for weights, before accounting for KV cache at longer contexts. Quantized versions (4-bit or 8-bit, via bitsandbytes or similar) will reduce that substantially and are the more realistic option for single-GPU consumer setups. If you plan to actually use the 256K context window, budget considerably more memory for the KV cache, since that scales with sequence length and batch size, not just parameter count. If your use case is short-form writing (texts, emails, quick notes) rather than long-document work, running with a much smaller --max-model-len is the practical choice and will make local deployment feasible on more modest hardware.
Is Hemmingway-1 worth self-hosting?
Other agents ship a demo. Remy ships an app.
Real backend. Real database. Real auth. Real plumbing. Remy has it all.
Whether it’s worth running locally versus using the hosted app at hemmingway.io depends on what you need. The case for self-hosting: full data privacy (nothing leaves your machine), no usage limits or costs beyond your own compute, and the ability to integrate it directly into your own tools via the vLLM API or Transformers pipeline. The Apache-2.0 license explicitly permits commercial use, so there’s no licensing barrier to building a product on top of it.
The case against: you need real GPU hardware to run a 27B model well, and the hosted app and Mac/Android apps already exist if you just want to use the model without managing infrastructure. For most casual users, the hosted version is simpler. For developers who want to fine-tune further, integrate the model into an existing pipeline, or guarantee data never leaves their own infrastructure, self-hosting via vLLM or Transformers is the more sensible route.
On capability, the model card reports that Hemmingway-1 outperformed several larger closed models, including a 50-point margin over GPT-6 Astra, on Altworld’s own CommunicationBench, and beat Fable 5.1 as well. It’s worth being clear-eyed about this: CommunicationBench, the Human-Likeness comparison, and StoryBench are benchmarks Altworld built and ran itself, and the model card discloses this openly. The one third-party result cited is EQ-Bench 4, a public emotional-intelligence benchmark run by an independent harness, where Hemmingway-1 placed third, ahead of GPT-5.5 and both Opus 4.7 and Opus 4.8, and within 12 points of the top-ranked model.
The model reportedly performs less well on hostile storytelling and long multi-turn story writing, where dedicated story-generation models have an edge. That tracks with its stated purpose: Hemmingway-1 is built for practical, everyday communication rather than long-form fiction.
Frequently Asked Questions
What base model is Hemmingway-1 built on?
It’s a fine-tune of Qwen3.8-27B, a 27-billion-parameter base model, adapted specifically for everyday writing tasks like messages, emails, and short-form communication.
What context length does Hemmingway-1 support?
The model supports up to 262,144 tokens (256K) of context. When serving with vLLM, this needs to be set explicitly via --max-model-len, and you can lower it to reduce memory requirements if you don’t need the full window.
Can I use Hemmingway-1 commercially?
Yes. It’s released under the Apache-2.0 license, which permits commercial use of the weights without licensing fees or restrictions.
Do I need vLLM, or can I just use Transformers?
Either works. vLLM is generally better if you want a persistent server with an OpenAI-compatible API and efficient batching. Transformers is a better fit if you want to embed the model directly in a Python script or pipeline without running a separate server process.
What are Hemmingway-1’s known limitations?
The model card states it’s English-first, can sound confident while being factually wrong, and underperforms specialized story-generation models on hostile storytelling and long narrative turns. Altworld explicitly advises against using it for medical, legal, or financial decisions.