# A Knowledge Base for Your Game Project — Memory the AI Keeps Between Chats

Keep game design decisions, rules and docs in a Knowledge Base the AI agent reads and updates, committed to Git with your project and shown as a 3D graph.

_Last updated: 2026-10-26_

Every new chat with an AI agent starts with an empty memory. You explain the combat rules again, the naming conventions again, the art style again, and the agent still forgets the decision you made last week about save files. The Knowledge Base in AI Game Developer fixes that: a game project knowledge base the agent reads, searches and updates, kept as Markdown notes inside your project and committed to Git with the rest of the game.

This post shows how it works on a session from our demo game, Skyward Keep, what belongs in a Knowledge Base, and how to work with it so the agent makes decisions that stay consistent across sessions. The video is a real recording of the app: the agent's replies are scripted for the demo, and every tool call in it ran for real.

[Media: A decision filed in one chat and recalled in a brand-new one.]

## What the Knowledge Base Is

The Knowledge Base is a folder of plain Markdown notes at .ai-game-dev/knowledge/ in your project. Because it is ordinary files in the repository:

- It is versioned in Git, so every change to a design decision has a history and can be reviewed in a pull request.
- It travels with the project: a teammate who clones the repository gets the same knowledge, and so does their agent.
- You can read and edit the notes in any editor, not only in the app.

On top of the files, the app keeps an index. It tracks links between notes, reports broken ones, and gives the agent tools to browse, search, read and organise the notes. The index updates incrementally as notes change, so a note the agent writes in one session is available in the next.

## Spaces: How the Notes Are Organised

Any Knowledge Base folder with a README is a space, with a title and a short description of what belongs in it. The agent sees a short catalogue of spaces, opens one only when it needs it, and can create new ones. That keeps its context small: it does not load every note into every conversation, it goes to the space that matters for the task.

A layout that works well for a game:

- design: core loop, mechanics, progression, economy.
- systems: how combat, inventory, saving or dialogue are implemented.
- art: style guide, palette, asset naming and import settings.
- audio: music direction, sound effect conventions, mixing levels.
- decisions: a log of choices with their reasons.
- references: links and notes on games and tools you are learning from.

You do not have to create the structure by hand. Ask the agent: "Create Knowledge Base spaces for design, systems, art and decisions, each with a one-paragraph description."

## Recording Decisions So They Stick

The most valuable notes are decisions. When you state one in chat, the agent records it together with its reason and what it replaced, and links the new note from its space's README.

In the demo, the decision is about the art style:

"Let's commit to the hand-painted style: soft textures, warm rim light, no outlines. It read better at 64 px than the cel-shaded test."

The agent first checks what the Knowledge Base already says and finds an open question in a style exploration note: cel-shaded with thick outlines, or soft hand-painted textures. It then writes a new note in the art direction space, Visual style: hand-painted, with the decision, the reason (the hand-painted hero stayed readable at 64 pixels, while the cel-shaded outlines turned into noise) and what it replaces. It marks the open question as resolved with a link to the new note, and links the note from the space's README. The note is plain Markdown, committed with the project, so every new chat and every teammate gets it.

[Media: The decision is filed as a note, linked into its space and visible in the graph]

Decisions worth recording look like this:

- "We use a fixed timestep of 50 Hz for physics because the platforming needs consistent jump heights. This replaces the variable timestep."
- "Enemy health is always a multiple of 10, so damage numbers stay readable."
- "All item icons are square, centred, on a plain dark background."

The next time a session works on physics, enemies or UI, the agent finds the decision in the Knowledge Base and follows it. In the demo, a brand-new chat is asked "Which art style did we pick for Skyward Keep, and why?", and it answers with the decision and the reason, citing the note as its source.

[Media: A brand-new chat finds the decision and the reason]

When you change your mind, say so, and the note is updated with the new reason, while Git keeps the old version.

### Ask the Agent to Check the Knowledge Base

You can point the agent at the Knowledge Base directly: "Before you change the inventory, read the systems space and tell me which rules apply." Or ask for a summary with the /kb command, which shows the tree of notes, their links and any broken links, for the whole base or for one folder.

## Keeping the Knowledge Base Healthy

A knowledge base is only useful if it stays connected and current. The tools help with that:

- Links between notes are tracked, with outgoing links, backlinks and broken links per note or per folder.
- A lint check reports broken links, orphan notes and notes that do not follow the conventions. Notes filed in a space are not counted as orphans.
- Notes can be moved between folders as the project grows.

Every few weeks, ask the agent to run the lint check and fix what it finds. Treat it like refactoring code: small, regular clean-ups keep the whole thing usable.

## The 3D Graph

The Knowledge Base opens as an animated 3D graph in its own window. Folders are rings, notes are nodes sized by how connected they are and coloured by folder, with lines for containment and links. It is a quick way to see which parts of the design are well documented and which notes stand alone.

You can open it from several places: the status bar entry, which shows how many notes the project has and pulses when the agent writes a note; the "Open the Knowledge Base graph" button in the session's Tools row; "Open in Knowledge Base graph" on a folder or note in the Explorer; and the Knowledge Base view in the right panel.

## What to Put In, and What to Leave Out

Write notes for things the agent cannot work out from the code: intentions, constraints, reasons and conventions. Leave out things the code already says, such as a list of every class, which go stale fast.

A good first week with a new project:

1. Ask the agent to create the spaces.
2. Write one note on the core loop and one on the art style.
3. State decisions in chat as you make them, and let the agent file them.
4. At the end of the week, open the graph and ask the agent to lint the base.

The Knowledge Base arrived in release 0.21.0 and became easier to reach, with spaces, in 0.22.1 (https://ai-game.dev/releases/0.22.1). It works in Unity, Godot and Unreal projects alike, and in plain folders. Download the app at ai-game.dev/download and give your next session a memory.

## Related

- The AI Game Developer App: https://ai-game.dev/docs/app
- Best practices: https://ai-game.dev/docs/best-practices
- Download the app: https://ai-game.dev/download

---

Source (HTML): https://ai-game.dev/blog/game-project-knowledge-base-for-ai