Cotabby: local AI autocomplete for macOS, from a two-student team

The problem Cotabby targets: typing in fields no editor plugin reaches

Most AI writing tools live inside one application. A plugin for your code editor, a browser extension for one web app, a chat window you copy text into and out of. The gap is everywhere else: the Slack message, the iMessage reply, the support ticket, the search box, the long email. Those fields have no extension point, so a tool that wants to help there has to work at the macOS level rather than inside any single app. That is the position Cotabby takes. The README describes it as adding "AI autocomplete to almost any text field on your Mac," with a gray suggestion appearing inline next to the cursor as you type. Pressing Tab accepts it a word at a time; continuing to type ignores it. The intended user is a Mac owner who writes in many places and does not want a per-app integration for each one. The README is explicit that this is a beta, and that the project is "maintained by two students," which sets the expectation for support and release cadence before you install anything.

Three engines, and the on-device pipeline behind the Open Source one

The engine choice is the central design decision, and the README frames it as a Settings pick between three options. Apple Intelligence uses Apple's model and requires macOS 26 or later on supported hardware, with nothing to download. The Open Source engine runs a small model entirely on the Mac and works on macOS 14 and later, with or without Apple Intelligence. The third option is an OpenAI-compatible endpoint you configure yourself, which can be local Ollama, another host on your LAN, or a public HTTPS service, with credentials stored in Keychain.

The Open Source path is the one with real detail in the README. It runs local GGUF base models in-process through llama.cpp, via a separate project called CotabbyInference. The design choice worth noting is that Cotabby does not prompt an instruction-tuned chat model. It treats the model as a pure text continuer and conditions it on your name, writing style, language, and on-screen context. That is a different bet from wrapping a chat model in a completion prompt, and it explains why the built-in models are base checkpoints rather than instruct variants. Four models ship as downloads: tabby-2-nano at about 0.8 GB, tabby-2-mini at about 1.4 GB, tabby-2-base at about 4.5 GB, and tabby-2-pro at about 5.0 GB. The README maps them to use cases, with nano aimed at older or low-memory Macs and pro described as best quality. You can also drop any .gguf file into Cotabby's models folder and refresh the list from the menu bar, which means the model table is a starting point rather than a fixed set.

Installing Cotabby and getting a first suggestion

The README points at a direct DMG download from the latest GitHub release, and lists compatibility as macOS 14.0 or later. There is no Homebrew formula or package manager command documented, so the install is the disk image rather than a terminal one-liner. The repository also carries a project.yml and an Xcode project, which suggests building from source is possible, but the README does not walk through that path.

The README shows the download link as the release asset Cotabby.dmg, and the app itself is a menu bar item once it is running. The engine is chosen in Settings, under the Engine section, where the three options are Apple Intelligence, Open Source, and OpenAI-compatible. The README gives the path as:

Settings → Engine

If your Mac supports Apple Intelligence, the README calls that the easiest place to start because there is nothing to download. Otherwise select the Open Source engine and pick a model. The downloads are started from Cotabby's menu bar, not from a terminal. For a first run on a low-memory Mac, tabby-2-nano at roughly 0.8 GB is the smallest option, and the README describes it as the fastest.

Once a model is loaded, click into any text field, type a sentence, and wait for the gray continuation to appear. Tab accepts it one word at a time. If you want to try the inline macros, the README gives the example of typing a slash to reach quick math, unit and currency conversion, dates, and random values. Emoji autocomplete works the same way: the README gives :rocket: as the example, and you accept it without leaving the field. What you should see is a suggestion that arrives after a short delay and never blocks your typing.

Where Cotabby is the wrong tool, and what the README leaves unsaid

The clearest limitation is the platform floor. macOS 14.0 is the minimum, and the Apple Intelligence engine needs macOS 26 or later on supported Macs. If you are on an older release, or on hardware that Apple does not support for Apple Intelligence, your only on-device path is the Open Source engine, which means downloading a model and accepting its memory footprint. On a machine with limited unified memory, tabby-2-base and tabby-2-pro at roughly 4.5 GB and 5.0 GB are heavy neighbors for whatever else you are running, and the README's own size column is the honest signal here.

The second limitation is the beta label. The most recent release listed is v0.6.2-beta, and the README states the project is maintained by two students. That is a statement about capacity, not quality, but it has consequences: you should not expect an enterprise support contract, a published deprecation policy, or a guaranteed cadence. The repository does include a RELEASING.md and a CONTRIBUTING.md, which is more process than many small projects carry, but the README does not document a rollback path if an update breaks your setup, and it does not describe what happens to your settings or downloaded models across versions.

A third point is the OpenAI-compatible engine. It exists, and it is optional, but choosing it changes the privacy story. The README says a bounded request goes only to the endpoint you configure, and that the endpoint can be loopback, on your local network, or a public HTTPS service. If you point it at a public service, the on-device guarantee no longer applies to generation. That is a configuration decision, and it is easy to make by accident if you are testing endpoints.

Cotabby against Cotypist: same problem, different distribution model

Cotypist is the comparison people search for, and the difference is not the feature list so much as how the software reaches you and what it costs. Cotabby is AGPL-3.0 and the README presents it as free and open source, with an optional Ko-fi link for support. Cotypist is a paid product with a subscription, which is what the related searches around pricing and cancellation reflect. If you need a vendor to invoice, that is a real difference in procurement rather than a preference.

The second difference is where generation happens. Cotabby's default engines run on the Mac, and the README states there is no analytics, no telemetry, and no crash reporting, and that a normal install never writes what you type to disk. The optional endpoint engine is the exception, and it is opt-in. A subscription product's backend is not something you can inspect from the client, so the question of what leaves your machine is answered by policy rather than by reading the code. For someone whose reason for wanting local autocomplete is that they cannot send keystrokes to a third party, that distinction decides the choice on its own.

The third difference is the model. Cotabby lets you swap in any GGUF file small enough to run on-device and refresh the list from the menu bar, and the README points at the unsloth GGUF collection for variants. A closed product ships whatever model its vendor chose. That flexibility cuts both ways: you can trade quality for size with a smaller quant like Q3_K_M or Q4_K_S, and you can also pick something that performs badly and have no baseline to compare against.

Licence, upgrade cost, and what AGPL-3.0 means for a menu bar app

Cotabby is licensed AGPL-3.0. For an end user running the app on a personal Mac, the practical effect is close to nil: you can install it, use it, and read the source. The copyleft obligations attach when you distribute the software or a modified version, or when you run a modified version as a network service for other people. If your plan is to fork Cotabby, rebrand it, and ship it to customers, the AGPL is a constraint you need to understand before you start, and this is a case where talking to a lawyer is cheaper than guessing. The repository carries a THIRD_PARTY_LICENSES.md, which is the file to read for the bundled components, and the models themselves come from Hugging Face with their own terms that the README does not restate.

Upgrade cost is mostly model management rather than code. The app updates through its own releases, and the models are downloaded separately from the menu bar, so a version bump does not necessarily re-download gigabytes of weights. The real cost is disk and memory: keeping several of the built-in models around means several gigabytes, and the README's table makes the trade explicit. If you bring your own GGUF files, you own the job of tracking which ones still work with the current inference layer, since CotabbyInference is a separate repository and the README does not promise that every GGUF will load.

Editorial conclusion

Cotabby fits Mac users on macOS 14 or later who want inline completions without an account and are comfortable running a beta maintained by two students. It is the wrong choice if you need a stable, versioned product, if you are on an Intel Mac that cannot run the bundled GGUF models at usable speed, or if you want a hosted service with a published uptime record, because the README documents none. Before relying on it, verify three things on your own machine: that your Mac meets the macOS 14.0 floor or the macOS 26 bar for Apple Intelligence, that the engine you pick actually produces suggestions in the specific app you type in most, and that the model you download fits your free memory, since tabby-2-pro is roughly 5.0 GB.

Frequently asked questions

Official sources

1. FuJacob/cotabby on GitHub
2. License: AGPL-3.0
3. Project website
4. README
5. Releases