Making games with Ollama, and what that does not buy you

The reason to search this is usually a hope: that with the model on my own machine, the whole thing runs on my own machine. That hope is wrong here and it is better to know now than after a download.

Flockbay needs an internet connection to build with. Asset generation and world data come over the network. Those are not the model, they are separate services doing separate work, and hosting a model in Ollama does not touch them. Put a laptop on a plane with Ollama running perfectly and you still cannot build.

What does work without a connection is playing what you already built. The game runs locally on the copy of Godot bundled with the app, at your machine's framerate. That distinction — building needs the network, playing does not — is the honest version, and we are not going to add an offline mode later to make this page age better.

It changes who pays for tokens and where the conversation goes. If you are driving Flockbay from an agent whose model is served by Ollama, that part of the loop is yours: your hardware, your model choice, your cost of zero beyond electricity, and the prompts staying on the machine.

It also changes your ceiling in both directions. You are not subject to somebody else's rate limits, and you are subject to your own GPU. Which of those matters more depends entirely on your machine and we are not going to pretend to know.

We are also not going to tell you which model to run. We have not benchmarked local models against each other for this and any ranking we published would be a guess dressed up as data. Try what you have.

This is the genuinely interesting part. Pointed at a bare game project, a model has to invent nearly everything: what the scene means, where things belong, how terrain and water and weather are represented, what a character even is in this codebase. Every one of those inventions is a chance to be subtly wrong, and small models are worse at recovering from subtle wrongness than large ones.

Flockbay exposes a capability layer over MCP instead. The operations are at the level a game is described in rather than the level a file is edited at. Each real capability is a body of code the model does not write from nothing and a class of failure that stops happening.

The practical consequence is that a locally hosted model is not obviously a bad idea here in the way it is when you point one at a raw engine. We are not claiming a specific model works well — that depends on your model and your machine and we have not measured it. We are saying the layer is built so that reliability comes from the tools rather than from the size of the model, and that is the reason to try.

More on this: Making games from OpenCode

To be exact: we have not built anything for Ollama, and Ollama has not built anything for us. Ollama serves models. What connects to Flockbay is an agent, and it connects because both sides speak MCP.

So the shape is three pieces. Ollama serving the model. An MCP-capable agent using it. Flockbay, running on Windows (Mac comes later), with one MCP server inside it that carries the capability layer, the assets and the game itself. Popular clients should work, behaviour will vary between them, and we have not tested them all.

Get the connection details from the app and its docs rather than from a page like this. Configuration published on a marketing page goes stale quietly, and a wrong instruction costs an evening.

More on this: The best LLM for Godot: how to test one yourself

The world is yours to judge. In a 3D project that means terrain, water, weather, buildings, characters. In a 2D project — the other of the two pictures a new project makes you choose between before it will create anything — it means ground painted a cell at a time, with the tiles and the edges and the collision falling out of the coverage, and sprites placed by eye. An agent can call the same world tools, local model or otherwise, and you can change anything by hand with the builder in the Godot editor.

You also still judge the result. You play the game and say whether it is right, and the agent goes again. Not writing the code has never meant not having an opinion about the game.

Connecting your own agent over MCP is free. What Flockbay costs has the detail.

More on this: Making games from Goose

Ollama runs the model; it does not call tools on its own. So the connection goes to an agent that runs your Ollama model and speaks MCP: Goose, OpenCode or Cline. Goose is shown here.

The Flockbay app writes this for you with the real paths filled in: open the account menu, choose MCP connection, press Turn on, pick Goose and press Copy. The three paths are specific to your machine and stay the same from one sitting to the next, so you paste it once. Below is the shape, with the paths as placeholders.

Add it to ~/.config/goose/config.yaml, under the extensions you already have, and point Goose at your Ollama model as usual.

More on this: Godot MCP: connect Claude Code, Codex or Cursor to your Godot game