Patent Continuation
Choose a model for your machine
Model choice matters more than it looks, and memory is the first filter. Pick the card that matches your hardware.
These sizes are unified memory, measured on a Mac, where the processor and the graphics chip share one pool. On a PC with a separate graphics card, the card's own memory is the number that decides which model runs at a usable speed: a model larger than the card spills onto the processor, which is many times slower, and a draft that takes minutes on a GPU can time out. With an 8 GB card, use the 16 GB card's models regardless of how much system memory the machine has.
The app checks the fit too: before Ollama loads a model at a larger context window, the app works out what that window costs in memory, counting each request your server runs at once. It says when the load is tight, and refuses one that cannot fit this machine before anything is sent.
The strongest of these tiers. It needs server hardware, and it is the one tier without a one-command install. Its newer sibling glm-5.3 scored 0.9 higher, too close to call, but returns no draft unless a reasoning setting is passed, which your server has to support; if yours does, it is the one to try.
Finished nine of the ten specifications tested, failing only the longest at about 240 pages. Worth knowing before you buy hardware: the 32 GB model below actually scores a little higher on our tests, and the gap is too small for our benchmark to tell apart, so more memory does not buy you a better local model until you reach the server tier. Pick this one if you want the most thoroughly tested option; pick the 32 GB one if you want the higher score in less memory.
Much stronger drafting than the model this tier used to name, at the same memory. Two trade-offs, both measured on a 32 GB machine: it is slow, taking 2 to 19 minutes for one draft depending on length, and it could not finish a 240-page specification at all. It handled everything up to about 145 pages. For one longer than that, use gemma4:26b instead, which finished every specification tested but drafts less well.
Marginal, and uneven across specifications. Workable for trying the app; treat its output as a rougher first pass than the tiers above. It finished nine of the ten specifications tested; qwen3.5:9b scored 65.0 beside it, too close to call, and finished all ten, so use that for a specification this one refuses. On a PC, note that this model needs about 9 GB of graphics memory and the 9b about 14 GB on a long specification. Reading a parent's file history is lighter work than drafting, and there this tier is not marginal: qwen3.5:9b found every rejection in the prosecution records we measured it on.
Each card's index and drafted figure comes from the same benchmark run: 50+ models over 10 real patent families, with what the numbers do and do not support stated there.
Serve the model, then draft
Serve the weights yourself
Ollama does not carry this model's weights: its only tag, glm-5.2:cloud, routes to Ollama's hosted service, which would send your specification off the machine and defeat the reason for running at this tier, so the app refuses it. The weights are published openly by the model's authors, so this tier means serving them yourself with a server such as llama.cpp or vLLM, the two of that kind a run of the app was measured through end to end, and pointing the app at that endpoint. Every tier below is a single pull.
Get the program
From the download page: on a Mac, the app, which you drag to Applications; on Windows or Linux, the signed command-line program (on Linux, make it executable). Both are signed, so they open as downloaded.
Draft
Point it at your specification and the filed parent claims.
CD_LOCAL_OPENAI_BASE_URL=http://your-server:8000/v1 \
./continuation-drafter draft --provider local-openai --model glm-5.2 \
--spec spec.txt --parent parent-claims.txtNo API key: a server you run does not issue you one. If the address is on this machine the app says nothing, because nothing left it. If it is another box, even one of yours, the app names the destination before your specification is sent, because a machine on your own network is still across a network.
Such a server chooses its context window when it loads the model,
with --max-model-len on vLLM or -c on llama.cpp (shared among
its slots). The app reads the window the server declares before
your specification is sent, and refuses a call that would not fit rather than draft
from a cut specification, so load the model with a window your specification fits.
Need help getting started? Write to [email protected]; it goes to a person.
Not enough memory, or would rather not install a model?
Run it through your own provider account instead. That sends the specification to that provider, so it suits published material, and for anything unpublished it is a judgment you make per matter. How that works.