Skip to content

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

By Eduardo Orellana · Updated

If your agent speaks MCP, the model behind it can be one you are running yourself. That changes where the thinking happens. It does not make Flockbay an offline tool, and this page is mostly about that difference. Free AI to start: Flockbay's AI and your own Claude, ChatGPT, agent or API key are free for your first build; after that, a plan keeps you building. It runs on Windows, macOS and Linux, on the official Godot engine.

The main page on this subject is Connect your own agent.

AppImage, x86_64. Ubuntu 22.04, Debian 12, Fedora 39 or newer.

Intel or AMD Chromebook, with Linux turned on.

Download for macOSDownload for WindowsDownload for Linux

Start with the part people get wrong

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 your Flockbay account 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.

What running the model yourself does change

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.

What a local model gets from Flockbay

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, what a .tscn file's resource IDs and UIDs must say, 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 hands it the Godot editor and the running game over MCP instead. The editor writes the scene file, and the game is played to check each change, so the model reads stdout and the debugger rather than guessing. Each of those 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.

More on this: How do I use Flockbay with my own AI agent?

There is no Ollama integration

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, macOS or Linux, with one MCP server inside it that carries the scene tools, the asset library 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: Making games from OpenCode

The judging is still yours

The game is yours to judge, not to build. The agent builds the scenes, local model or otherwise: props and characters in a 3D project, TileMapLayers and sprites in a 2D one, with terrain, water or a sky from a Godot plugin. It can play the game to check its work. Whether it looks right is your call, and when one call is pure taste, make it yourself in the Godot editor's own view, with Ctrl⌘+Z behind it.

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 for your first build, and a plan keeps it building after that. What Flockbay costs has the detail.

More on this: An AI agent that works inside a Godot project

Ollama needs an agent in front of it

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 Connectors, press Set up on Connect your agent (MCP), 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: Making games from Goose

YAML
extensions:
  flockbay:
    name: flockbay
    type: stdio
    cmd: '<node>'
    args:
      - '<coordinator>'
      - '--external-stage-mcp'
    envs:
      FLOCKBAY_MCP_DESCRIPTOR: '<descriptor>'
    enabled: true
    timeout: 300

Questions

Does running Ollama make Flockbay work offline?
No. Asset generation and your Flockbay account still go over the network, so building needs a connection regardless of where the model runs. Playing what you built does not.
Is there an Ollama integration?
No. Flockbay ships one MCP server. An MCP-capable agent connects to it, and the model behind that agent can be one Ollama is serving.
Which local model should I use?
We have not benchmarked local models for this. Try what your machine runs comfortably.
Is this free because the model is local?
Connecting your own agent over MCP is free for your first build, and a plan keeps it building after that. You pay your agent's provider for the model.
Can I use Flockbay instead?
Yes. Flockbay's own AI is in the app: it agrees a brief with you, builds the scenes, writes the GDScript into your project and plays it to check, with nothing to connect. For most people it is the shorter path.

Free to download for Windows, macOS and Linux. Building needs an internet connection; playing what you built does not.

Download Flockbay free