Ollama Reads 4,096 Tokens by Default. Eleven Commits of Diffs Are Six Times That.

The top result for generating release notes with a local model stopped shipping in July 2025. Here is what works instead, and the context limit nobody mentions.

Flat illustration of amber blocks streaming in from the left and piling up against a small bright opening, with only a few passing through
11 min read
2,172 words

Search for how to generate release notes with a local LLM and the first practical answer you are handed is a Bash script called changeish. Its latest release is 0.2.0, dated 1 July 2025, and nothing has been pushed to the repository since 6 July 2025 — roughly sixteen and a half months of silence on a project with seventeen stars.

The staleness is not even the problem. Its README describes it as “A powerful, open-source Bash tool to automatically generate beautiful, structured changelogs,” but there is no LICENSE file in the repository, and the GitHub API returns its licence as null. GitHub’s own documentation on licensing a repository is blunt about what that absence means: “the default copyright laws apply”, you “retain all rights to your source code”, and “no one may reproduce, distribute, or create derivative works from your work”. If you were planning to drop this into a work repository on the strength of a search result, that is the first thing to know about it.

GitHub releases page for changeish showing version 0.2.0 tagged Latest, released by itlackey on Jul 1, 2025, with commit 27dd7e6
changeish's releases page, captured 19 Nov 2026: the latest release is still 0.2.0 from 1 July 2025.

What a search for this actually hands you

The rest of page one is not in better shape. The ai-changelog package on PyPI last published version 0.0.14 on 11 December 2023. DiffLog is genuinely active — last pushed on 13 September 2026 — but it has three stars and is a .NET CLI first, with the model as an afterthought. The one article from a company rather than an individual is a general piece about AI changelogs that never addresses running the model on your own machine.

What none of them mention, not one, is the thing that decides whether any of this works: how much of your commit history the model can actually see at once. That omission is the reason this article exists, and it is worth establishing the boring baseline before getting to it.

The tool that works has no AI in it

git-cliff is the healthiest project in this space by a wide margin — version 2.14.2, released 18 September 2026, Apache-2.0 licensed, 12,432 stars, last pushed on 2 November 2026. It calls itself “A highly customizable Changelog Generator that follows Conventional Commit specifications,” and its introduction says it works by utilizing “conventional commits as well as regex-powered custom parsers.”

Search its entire repository for openai and you get zero results. There is no model in it anywhere.

It is worth seeing what that buys you, because the output is better than people expect from something deterministic. git-cliff generates its own release notes, and the 2.14.2 notes come out grouped under Features, Bug Fixes, Documentation, Testing and Miscellaneous Tasks, each entry carrying its pull request number and short commit hash. Nothing was summarised, nothing was invented, and nothing was sent anywhere. For a large number of projects that is the whole job, finished, and the correct move is to stop reading here and run git-cliff.

Whether you are one of those projects is not a matter of taste. It is decided by your commit messages.

Your commit messages decide whether you need a model

The Conventional Commits 1.0.0 specification is short. A message is <type>[optional scope]: <description>, optionally followed by a body and footers, and the rule that matters is stated flatly: “Commits MUST be prefixed with a type.” The spec lists “Automatically generating CHANGELOGs” as the first reason to bother.

A parser needs that prefix. Without it there is nothing to group on, which is why git-cliff’s FAQ recommends “using a Git history that follows the Conventional Commits specification as the primary strategy.”

So the practical question is how much of a real history conforms. I measured two ranges of git-cliff’s own repository on 19 November 2026, counting a subject as conforming if it matched the spec’s required type prefix. Between v2.12.0 and v2.13.0, 85 of 85 non-merge commits conformed. Between v2.13.0 and v2.14.0, 42 of 43 did.

Then I ran the same check against this site’s own repository. Zero of the last 100.

That is not carelessness, it is a different convention: our commits read Add: <title>, Edit: <title>, Brief: <slug>. Perfectly consistent, completely invisible to a conventional-commit parser. And that is the real shape of this problem — compliance is close to all-or-nothing, because it is set by a team’s habit rather than drifting commit by commit. If you conform, you do not need a model. If you do not conform, no amount of configuration will make a parser understand Brief: pico-w-bluetooth-proxy-active-connections, and a model starts looking like the answer.

This is the point at which almost everyone pipes git log into Ollama. It is also the point at which it quietly stops working.

Generate release notes with a local LLM and you hit the context window first

Ollama’s FAQ is unambiguous: “By default, Ollama uses a context window size of 4096 tokens.”

Ollama documentation reading 'By default, Ollama uses a context window size of 4096 tokens', followed by the OLLAMA_CONTEXT_LENGTH=8192 ollama serve example and the /set parameter num_ctx 4096 command
Ollama's FAQ, captured 19 Nov 2026: the default context window is 4,096 tokens, and OLLAMA_CONTEXT_LENGTH is how you change it.

Now the other side of the comparison. Still on git-cliff’s repository, measured the same day, here is what a release range weighs. Between v2.14.1 and v2.14.2 there are eleven non-merge commits. Their subject lines alone come to 590 characters. Add the commit bodies and it is 5,082. Add a diffstat instead and it is 3,763. Pipe the whole thing with full patches — git log --no-merges -p — and it is 95,890 characters.

I did not count tokens, and neither should anyone quoting these figures: there is no tokenizer on the machine that took the measurements, so the characters are measured and the tokens are arithmetic. But the arithmetic is not close enough for the ratio to matter. At the common rough estimate of four characters per token, 95,890 characters is roughly 24,000 tokens, about six times a 4,096-token window. Take a deliberately generous five characters per token and it is still over 19,000, which is still more than four times over. There is no tokenizer for which eleven commits of patches fit.

The bodies are the surprise. Eighty-five commits between v2.12.0 and v2.13.0 are 5,343 characters as subject lines and 73,923 characters once you include the bodies — fourteen times larger, because this is a project where people write real commit messages. Subjects for eighty-five commits fit in the default window with room to spare. The same eighty-five commits with their bodies do not fit in three of them, on either estimate.

Here is the part that should make you cautious: Ollama’s FAQ does not say what happens when you exceed the window. It documents no truncation behaviour, no error, no warning. I have not tested it, so I am not going to tell you it silently truncates. What I will tell you is that the documentation gives you nothing to check against, and a changelog built from half the commits reads exactly as confident as one built from all of them. You would not know from the output. That is the same category of problem as what an AI agent can and cannot carry between sessions: the limit is real, the failure is quiet, and nothing in the result announces it.

Feed it subjects, not patches

The fix is to decide what the model sees instead of letting git log decide for you. Four forms, with what each cost on those same eleven commits:

git log --no-merges --pretty='%s'        v2.14.1..v2.14.2   #    590 chars
git log --no-merges --pretty='%s' --stat v2.14.1..v2.14.2   #  3,763 chars
git log --no-merges --pretty='%s%n%b'    v2.14.1..v2.14.2   #  5,082 chars
git log --no-merges --pretty='%s' -p     v2.14.1..v2.14.2   # 95,890 chars

--no-merges is worth a word, because its value depends on how your project merges. git-cliff rebases, so all three ranges I measured contain exactly zero merge commits and the flag changes nothing there. On a repository that merges branches the ordinary way, every one of those merge commits arrives carrying a subject no changelog wants and bulk you are paying for.

Subjects plus a diffstat is the sweet spot, and it is the one most people skip. It fits comfortably, and it tells the model which files a change touched — which is often exactly the context that a thin commit subject is missing. Full patches are the form to abandon entirely. You are not asking the model to review the code; you are asking it to describe a change that the commit already names.

If you do need more room, raise it deliberately rather than hoping. Ollama documents three routes: OLLAMA_CONTEXT_LENGTH=8192 ollama serve sets the server default, /set parameter num_ctx 4096 changes it inside an ollama run session, and the num_ctx option inside an /api/generate request sets it per call. Worth knowing before you reach for a large number: context costs memory on the machine running the model, and on constrained hardware it is the setting that decides whether the thing loads at all — the same trade-off as getting a 35B model onto an 8GB card. If you have not set Ollama up yet, the complete guide to running local LLMs with Ollama covers the rest of it.

The shape of the right answer, in a tool nobody has used yet

There is a third option, and it is two days old.

ReleaseNotesGenerator published v1.0.0 on 17 November 2026 under Apache-2.0 — a licence, unlike changeish. It is a local-first Java application that, in its own words, “resolves a release range, reads commits, categorizes changes, and renders a Markdown document.” Git does that part. Ollama is optional, off by default, and limited to a short list of jobs: “creating a concise release summary”, “rewriting individual change descriptions”, and “preserving the original set and category of changes through structured validation.” Its README states the principle in one sentence: “Optional integrations enrich an existing local result. They do not replace Git as the source of release changes.”

That is the architecture, and it is why the context problem stops biting. The expensive step — rewriting descriptions — runs one change at a time, so its input is a single commit’s worth of text whether the range holds eleven commits or eight hundred. The release summary is the one step that has to look across the whole set, and the README does not say what it feeds it; if your release is a large one, that is the part to check before trusting the output. The deterministic pass does the grouping it is good at; the model does the sentence-level rewriting it is good at; neither is asked to do the other’s job.

Now the honesty. The repository was created on 8 September 2026, the release is from this week, and it has zero stars. Nobody has run this in anger. It wants Java 21, it defaults to the gemma3:4b model on http://localhost:11434, and it can manage Ollama in a Docker container for you. I am not recommending it as a safe default, because two days of existence cannot support that recommendation. I am pointing at the design, which you can copy in a short shell script: group deterministically first, and let the model rewrite one entry at a time.

What breaks

A model cannot recover information that was never written down. On a repository where commits read Add: <title>, a local model given those subjects will produce fluent sentences that say nothing the subject did not already say, and the diffstat is doing all the real work. The cure for a bad changelog is usually a commit message convention, not a model — which is an unsatisfying answer, and still the correct one.

gemma3:4b is a small model, and rewriting an existing line is close to the limit of what to trust a small model with unsupervised. Asking it to judge which changes matter, or to infer user impact from a diff, is where it starts inventing.

ReleaseNotesGenerator’s privacy claims — no telemetry, no analytics, no developer-controlled backend receiving your repository — are the project’s own statements about itself. They are plausible and the code is there to read, but nobody has audited them, and a repository’s contents are not something to hand over on the strength of a README.

And changeish stays off the list regardless of how well it works. Unlicensed code is not yours to use. That is the pattern across every job like this: in bulk-generating alt text for a media library, as here, the thing that breaks is rarely the model. Here it is a missing file that takes ten seconds to check for.

Sources

Every figure in this article traces to one of these. Dates are when the page was read.

  1. FAQ - How can I specify the context window size?
    OllamaAccessed Nov 19, 2026Official docs
  2. changeish - Local AI powered commit message Bash CLI tool
    itlackey (GitHub)Accessed Nov 19, 2026Official docs
  3. Release Notes Generator (v1.0.0)
    petrsafrata (GitHub)Accessed Nov 19, 2026Official docs
  4. git-cliff - Introduction and FAQ
    git-cliffAccessed Nov 19, 2026Official docs
  5. Conventional Commits 1.0.0
    Conventional CommitsAccessed Nov 19, 2026Official docs
  6. Licensing a repository
    GitHub DocsAccessed Nov 19, 2026Official docs
  7. ai-changelog 0.0.14
    PyPIAccessed Nov 19, 2026Official docs

Written by

Kai Devlin AI Automation Engineer

Full-stack developer who builds and runs AI automation systems in production. Runs local LLMs on personal hardware, builds N8N pipelines that actually ship, and deploys on Cloudflare Pages. Every guide on Pipeline Monk is tested on real consumer hardware — a Ryzen 7 5800HS with 16GB RAM and a GTX 1650. If it works on that, it works.