Skip to content

Making games from OpenCode

By Eduardo Orellana · Updated

There is no OpenCode integration to install. Flockbay ships one MCP server, OpenCode is an MCP client, and that is the whole of the connection. 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

No integration, just the protocol

It is worth being blunt about this before anything else. We have not built anything specific to OpenCode: there is no OpenCode plugin of ours, and nobody here has certified a version of it. What exists is that Flockbay ships one MCP server inside the desktop app, flockbay, listed in the official MCP Registry, and OpenCode is a client that speaks MCP.

That is a weaker claim than a partnership and a more durable one. Nothing about the connection depends on us tracking someone else's release notes. Any client that speaks the protocol should be able to reach the same surface, and OpenCode happens to be one of the popular ones.

It also means behaviour will vary. Different clients handle long tool listings, errors and permissions differently, and we have not tested every one. The app and its own docs are the place to get the current connection details from; anything written here about flags or file contents would go stale and be worse than nothing.

More on this: Can I edit the code myself?

What your agent is actually calling

One server, with three jobs. It exposes the scene tools, which go through the Godot editor rather than around it. It exposes the asset library. And it reaches the game itself: an agent can edit it in the open Godot editor, run it, look at it and play it. Between them, an agent has something to call that is closer to the level a game is discussed at.

The contrast is with pointing a terminal agent at a bare Godot project directory, which many people have tried. What the agent finds there is a folder of scenes, resources and scripts, with the meaning of the game distributed across all of them and written down nowhere. It can read and edit, competently, and it will still be inferring what a scene is for on every single turn.

The editor and the running game are the difference between an agent editing files that happen to make a game and an agent operating a game. That is the part that took the work, and it is the part that is worth pointing OpenCode at.

Judging the game is the half your agent does not do

Your agent builds the scenes through the same tools Flockbay's own AI calls, in whichever kind of project a new one settles before it will create anything: 2D or 3D. In a 3D project it is the player controller, characters and props; in a 2D project, TileMapLayers and sprites; terrain, water or a sky come from a Godot plugin when the game needs them. Then it plays what it built: a headless run or a window, input events, stdout and the debugger, GDScript parse errors included, and a viewport capture. But the eye that decides the game is right is yours.

So a session is two windows, not one. OpenCode is in the terminal, building the scenes and writing the behaviour. The app is beside it, with the game open in the Godot editor, and that is where you play it. A level can assemble itself from the terminal here. It cannot judge itself, and no amount of protocol makes it do that.

The upside is that you have two ways to answer what you see. When a taste call is wrong, the crate a little to the left, the tree on the other side of the path, drag it yourself in the Godot editor's own 3D or 2D view, and Ctrl⌘+Z takes a change back. A sentence gets you a layout; your hand can get you the exact layout. When anything else is wrong, you say so to the agent. Neither problem hides inside the other, which is the usual reason a long agent session goes sideways.

More on this: Making games from Gemini CLI

When Flockbay is the better idea

Flockbay's own AI ships in the app. It agrees a brief with you, builds the scenes, writes GDScript into the project and plays the result. It already knows Flockbay's tools, so there is nothing to connect and nothing to keep working. For most people it is simply the shorter path and it is the one we would suggest first.

Bringing OpenCode is worth it when you have real reasons: you want your own model choice, you already have a working set of habits in the terminal, or you are doing something around the game as well as inside it and would rather one agent held the whole thing. Those are good reasons. "I have a terminal open anyway" is a weaker one.

You can also do both. Nothing forces a choice, and using Flockbay for most of the work while driving the app from OpenCode for the parts you care about is a perfectly reasonable way to work.

What you need running

Flockbay is a desktop application for Windows, macOS and Linux, and Godot ships inside it, so there is no separate engine install. The project it operates on is a real Godot project in a folder on your machine. When you press play the game runs locally on that bundled Godot.

Connecting your own agent over MCP is free for your first build, and a plan keeps it building after that. The platform is free, and building in it is free to start. What Flockbay costs has the detail. The engine and the tools are the same either way.

Building needs an internet connection, because the AI and asset generation come over the network. That stays true no matter where your agent or your model is running. Playing what you have built does not need the connection.

More on this: Making games from Cline

Connecting it is one paste

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 OpenCode 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 opencode.json in your game’s folder, or to %USERPROFILE%\.config\opencode\opencode.json for every project (~/.config/opencode/opencode.json on macOS and Linux).

More on this: Making games from Cursor

JSON
{
  "mcp": {
    "flockbay": {
      "type": "local",
      "command": [
        "<node>",
        "<coordinator>",
        "--external-stage-mcp"
      ],
      "environment": {
        "FLOCKBAY_MCP_DESCRIPTOR": "<descriptor>"
      },
      "enabled": true
    }
  }
}

Questions

Is there an official OpenCode integration?
No. Flockbay ships one MCP server and OpenCode is an MCP client. There is nothing bespoke on either side, and we have not tested every client.
Where do I find the connection details?
In the Flockbay app: Connectors, then Connect your agent (MCP), then Set up (the project menu's Connect your agent (MCP)… opens the same dialog); press Turn on, pick OpenCode, Copy. The end of this page shows the same setup with the paths as placeholders.
Does my agent build the levels too?
Yes, through the same scene tools Flockbay's own AI uses, and the Godot editor is open beside it for you. That does not change based on which agent you use. Judging whether the game is right stays with you.
Do I need to pay for this?
Not for your first build. 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 still use Flockbay?
Yes, and for most work it is the simpler path. Using your own agent instead, or alongside, is supported rather than exclusive.
Does this work offline?
No. Building needs an internet connection because the AI and asset generation come over the network. Running the finished game does not.

Free to download for Windows, macOS and Linux. Connecting your own agent over MCP is free for your first build, and a plan keeps it building after that.

Download Flockbay free