There is a post trending on Hashnode right now about how the page your agent reads is not the page you see. It is true for agents browsing the web, and it is just as true in the other direction: the document you hand to a model is not the document you hold in your hand.
I learned this building a small tool that explains Swiss administrative letters in plain Italian, entirely on my machine. The model involved is a 1B-parameter Gemma running on CPU through Ollama. The tool is about 306 lines of Python 3.10, standard library only. And the single biggest lesson was not about the model at all. It was about the unglamorous layer between the letter and the model.
The letter is not text yet
A payment order from the debt-collection office arrives as paper, or as a PDF that behaves like paper. Fixed layout, stamps, reference numbers in odd places, a table where the amount due sits three cells away from its label. Humans read it with their eyes. A model reads whatever string you build for it.
So before any AI is involved, there is a pipeline, and it is pure plumbing: get the letter's text out, normalize the encoding, collapse the layout artifacts into lines that mean something. None of this is intelligent. All of it decides whether the intelligent part works.
The split, again
Once the text exists, the design rule I keep coming back to applies: deterministic code for everything that must be exact, the model for everything that must be understandable.
The code finds the deadline. The code finds the amount, the reference number, the sending office. These are the fields where a mistake costs someone money or a missed deadline, so they belong to the part of the system that cannot improvise. The model receives those extracted fields alongside the cleaned text and does the one job it is good at: explaining, in calm everyday Italian, what this letter is and what the sender wants.
A 1B model can paraphrase a sentence reliably. It cannot be trusted to read a deadline twice and report it faithfully. That is not an insult to the model; it is just what these models are. The pipeline is how you respect that.
What "preparing a document" actually means
Concretely, the middle layer does three kinds of work, and none of them appear in demos:
- Cleaning. Extraction leaves you with hyphenated words, headers repeated on every page, numbers split across lines. The text has to be stitched back into sentences before a small model can do anything sane with it.
- Anchoring. The fields that matter get found by code and passed to the model explicitly, so the explanation is built around values nobody guessed.
- Bounding. The model sees the letter and the extracted fields, and nothing else. No conversation history, no system prompt poetry, no extra context it could lean on when the letter is ambiguous. If the letter is unclear, the honest output is "this part is unclear", not a confident fill.
That last point is the one I would underline. The quality of a small local model is mostly determined before it runs: by what you put in front of it, and by what you deliberately keep away from it.
The one measurement, as always
On my machine, on CPU, one measured run: about 40 seconds per letter end to end, most of it the model. The plumbing is milliseconds. If you take one thing from this post: the 40 seconds is the boring part. The work that makes the output trustworthy is the layer nobody screenshots.
The tool described is real and personal. The 40-second figure is a single measurement on a single machine, stated as such.
