Hemmingway Try Hemmingway

Blog · Guide

Choosing the best LLM API for writing

What to look for in an LLM API for writing features: human-sounding output, no commentary around the message, context, OpenAI compatibility and open weights.

By the Hemmingway team ·

The best LLM API for a writing feature is the one whose output your users can send without editing. That comes down to five things: it sounds like a person wrote it, it returns the message itself rather than a message wrapped in commentary, it has enough context for your inputs, it speaks the OpenAI format so you can switch without rewriting code, and ideally it has open weights so you can run it yourself later.

General-purpose models are built to be good at everything, from code to maths to analysis. For a feature that drafts emails, replies, messages or stories, it is worth testing a model built for writing against them on your own prompts. We make one, Hemmingway-1, so this guide says where it fits and where it does not. The criteria apply to any API.

1. It sounds like a person

Users notice AI text quickly: the even rhythm, the stock phrases, the reply that is too polite for the person it is going to. If your feature drafts messages that users send under their own name, this is the thing that decides whether they keep using it.

You cannot read this off a spec sheet. The honest way to judge it is a blind test on your own prompts: take twenty or fifty real requests from your product, get answers from each candidate model, shuffle them, and have people (or a judge model, run in both orders) pick the one that sounds more like a person.

We ran that kind of test on eighty real requests. In Human-Likeness, our own blind benchmark where a judge is asked which of two replies a person wrote, Hemmingway-1 scored 1032, ahead of Fable 5.1 (1006), GLM-5.3 (996), Fable 5 (992), Kimi K3 (985) and GPT-6 Astra (964). On CommunicationBench, our own test of everyday writing, it scored 1026, level with Fable 5.1 at 1024. Both benchmarks are ours, and we say so on the model card. Run your own test before you trust ours.

2. You get the message, not a memo

This is the one most people only notice after they have built the feature. Ask a general model for a text to a landlord and you often get a preamble, three options, and a paragraph explaining the options. In a chat window that is fine. In an app, it means you need extra code to dig the actual message out, and that code breaks whenever the model changes its wrapping.

We measured how often models bury the text in commentary, options and notes. Fable 5, GLM-5.3 and Kimi K3 did it in more than nine replies out of ten. Hemmingway-1 was trained to give you just the message, so what comes back in content is what your user sends.

When you test candidates, count this. For each reply, ask: could this go straight into the text box? If you find yourself writing a prompt that begins "Return only the email, no explanation", you are paying for the wrapper in tokens, latency and fragile parsing.

3. Enough context, and a sensible reply length

Writing features often carry a lot of input: an email thread, a chat history, notes about the person, the user's earlier messages as style examples. Check two numbers.

  • Context window. How much the model can read at once. Hemmingway-1 has 262,144 tokens.
  • Longest reply. How much it can write in one go. On the Hemmingway API it is up to 32,768 tokens, thinking included.

Also check how the API handles repeated input. If your system prompt and the start of the conversation stay the same across requests, an API that reuses the start of a prompt it has seen recently saves time. The Hemmingway API does this by itself, and the reply's usage tells you how many prompt tokens were cached. Put what stays the same first and what changes last.

4. OpenAI compatibility

Most apps already talk to a model through OpenAI's SDK or something that copies its format. An OpenAI-compatible API means switching is a change of base URL, key and model name, not a rewrite. It also means you can run two models side by side while you test.

Check what "compatible" covers: chat completions, streaming, function calling, and images if you need them. Hemmingway's API takes OpenAI's Chat Completions body, streams server-sent events, does function calling in OpenAI's format, and reads pictures sent as data URLs.

Here is a minimal call with OpenAI's Python SDK (pip install openai), one line at a time:

import os

from openai import OpenAI

client = OpenAI(base_url="https://hemmingway.io/v1", api_key=os.environ["HEMMINGWAY_API_KEY"])

reply = client.chat.completions.create(model="hemmingway-27b", messages=[{"role": "user", "content": "Hello"}])

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

The model thinks before it answers, at its highest level by default. For quick features such as short replies, you can ask for less with reasoning_effort="low", or turn thinking off with extra_body={"enable_thinking": False}. Thinking comes back separately in reasoning_content, so it never mixes with the message. The API docs cover streaming, images, errors and limits.

Try HemmingwayDownload the app

5. Open weights, for when you need them

A closed API is simple until you need something it cannot give you: data that must stay on your servers, a fine-tune on your own writing, a guarantee the model will not change under you. Open weights keep those doors open.

Hemmingway-1's weights are on Hugging Face under Apache-2.0, which allows commercial use. It is 27B parameters, built on Qwen3.8-27B, and runs with vLLM or Transformers. The hosted API serves the same model, so you can start on the API and move to your own hardware later. How to run it yourself.

Other things worth checking

  • Privacy. What happens to the text you send. On the Hemmingway API platform, nothing you send and nothing the model writes is logged.
  • Limits. How many requests can run at once, and what happens when you hit the limit. Hemmingway's docs list every limit and error code.
  • Cost. Writing features send a lot of input and get short replies back, so compare prices on your real ratio of input to output. Hemmingway's API prices are on the API platform.
  • Languages. Hemmingway-1 is English-first. If most of your users write in another language, test in that language.

Where Hemmingway-1 is not the best choice

  • Long fiction. On StoryBench, our own creative writing test, Hemmingway-1 scored 1197, level with Kimi K3 but behind Fable 5 Max (1277) and GLM-5.3 (1254). For long story generation, the large story models are stronger.
  • Emotional intelligence at the very top. On the public EQ-Bench 4, Hemmingway-1 placed third with 1330, behind Fable 5 (1341) and Kimi K3 (1332).
  • Anything where a wrong answer costs something. It can be wrong and still sound certain. Do not build medical, legal or financial decisions on it.
  • General tasks. It was built for writing. We have not tested it as a coding or maths model, and we did not compare it with every API on the market, so test anything outside writing yourself.

A simple way to decide

  1. Collect 30 to 50 real requests from your product.
  2. Run them through two or three candidate APIs with the same prompt.
  3. Count how many replies could be sent without editing.
  4. Do a blind comparison of which sound more like a person.
  5. Check context, limits, privacy and price for the winner.

That test takes an afternoon and tells you more than any leaderboard, including ours.

Common questions

What is the best LLM for writing emails and messages?

In our own blind tests of everyday writing, CommunicationBench and Human-Likeness, Hemmingway-1 came first of the models we tested, with Fable 5.1 close behind on everyday writing. Those are our benchmarks, so the best check is a blind test on your own requests.

Is there an OpenAI-compatible API for Hemmingway-1?

Yes. Send requests to https://hemmingway.io/v1 with a key from the API platform and the model hemmingway-27b. OpenAI's Python and JavaScript SDKs work by changing the base URL.

How do I stop an LLM adding commentary around the message?

You can ask in the prompt for the message only, but many models still add a preamble or options some of the time. A model trained to return only the message is more reliable, and you should count wrapped replies when you compare models.

Can I self-host a writing model instead of using an API?

Yes, if it has open weights. Hemmingway-1 is on Hugging Face under Apache-2.0 and runs with vLLM or Transformers, though at 16-bit the 27B weights alone take roughly 54 GB of GPU memory.

How much does the Hemmingway API cost?

Prices are per million tokens and are listed on the API platform. Plans for the Hemmingway app are on the pricing page.

Read next

  • The best open-source LLM for writingHemmingway-1 is a 27B open-weights model under Apache-2.0, built for writing that sounds like a person. How it scores, what it needs, and how to run it.
  • How to run Hemmingway-1 locallyRun Hemmingway-1 locally with vLLM or Transformers: the commands, how much memory a 27B model needs, and the hosted API if you have no GPU.
  • The best AI for writing emails and messagesWe tested the largest AI models on eighty real email and message requests in blind head-to-head matchups. Here are the scores, and what they mean.
  • An AI that sounds humanMost AI writing gives itself away in a line. Here is what makes text read as a person's, and how Hemmingway-1 was built and tested to sound like one.