Labsco
quazaai logo

Fennara MCP

from quazaai

Fennara MCP connects AI agents like Codex, Cursor, Claude Code, and Claude Desktop to Godot-aware tools for real Godot projects. It focuses on feedback from Godot: GDScript diagnostics, scene validation, runtime errors, scene inspection, node properties, screenshots, SemanticSearch, and patch-and-rerun workflows.

🔥🔥🔥✓ VerifiedFreeQuick setup
#automation#git

Godot MCP

AI agents need more than a remote control for Godot.

MCP can let an AI client call tools inside Godot. That matters. But serious AI game development depends on the loop after the command: diagnostics, validation, runtime errors, screenshots, and enough context for the model to fix what it broke. Fennara is open source and supports Godot projects using GDScript, C#, or both.

View GitHubLatest Release

Mental model

Traditional Godot MCP

AI calls editor command.

Editor returns result.

AI guesses next step.

Fennara

AI changes project.

Godot feedback comes back.

AI patches and reruns until it works.

What Godot MCP usually means

Most Godot MCP tools expose editor commands to an AI client. They turn the editor into an API surface, which is useful when the operation is small and predictable.

create node

set property

open scene

save scene

read logs

take screenshot

run project

connect signal

edit input map

manage materials

run tests

If the task is “rename Camera3D to MainCamera,” command-style tools are clean. The harder case is a fuzzy build request that needs design, implementation, debugging, visual inspection, and repair.

Where command plumbing stops

A command can succeed while the project is still broken. The scene may save, but the script can fail to parse. The script may parse, but runtime errors can appear. The UI may run, but animation tracks or resource paths can be wrong.

A useful Godot agent needs to know whether generated GDScript or C# parsed, whether the edited scene still serializes, whether native class APIs were guessed correctly, and whether the running game emitted errors or warnings.

It also needs visual evidence when the task is visual. Screenshots, runtime output, and compact model-facing summaries matter because raw logs and giant scene dumps are easy for models to mishandle.

Fennara is built around sending that kind of feedback back into the next model step, so the AI can patch and rerun instead of handing you a project that only looked complete from the outside.

Why not just use Cursor or Copilot alone?

Cursor, GitHub Copilot, Claude Code, and Codex are strong general coding tools. Fennara is the Godot-specific layer that gives those AI apps live editor context through MCP instead of leaving them to guess from project files alone.

Swipe the table sideways to compare columns.

Capability Cursor or Copilot alone AI app + Fennara MCP Fennara Godot plugin Live Godot scene tree No native editor access Yes, through Fennara MCP tools Yes, inside the Godot plugin Script diagnostics Usually inferred from text only Runs Godot-aware diagnostics Runs Godot-aware diagnostics GDScript and C# projects Usually inferred from files only Supports GDScript, C#, and mixed projects Supports GDScript, C#, and mixed projects Scene editing Edits text files or suggests steps Can edit scenes through Godot APIs Can edit scenes through Godot APIs Runtime/editor feedback Manual copy-paste from Godot Tool results return to the AI app Tool cards stay in the editor chat Works with your existing AI app Yes Yes: Codex, Cursor, Claude Code, Claude Desktop, and Antigravity workflows Use the plugin chat directly Best use case General coding help Godot-aware agent work from an MCP client Godot-aware chat inside the editor

The point is not to replace your AI app. The point is to connect it to Godot so it can inspect the scene, read diagnostics, validate edits, and recover from mistakes with real editor feedback.

Fennara vs traditional Godot MCPs

Traditional MCPs are not bad. They are useful. Fennara’s bet is that commands are table stakes, and feedback is the moat.

Question Traditional Godot MCP Fennara Main question What editor commands can the AI call? What feedback does the AI need to build successfully? Best at Small direct edits and editor automation Larger agent workflows that need validation and repair Typical result ok, error, changed data, logs if requested diagnostics, runtime errors, scene validation, screenshots, and next-step context Failure mode The AI may think the task is done because the command succeeded The AI sees what broke and can patch the actual broken file Mental model Godot as a remote-control API Godot as an agent feedback environment

The agent loop Fennara is built for

Human developers do not write code and hope. They run it, inspect errors, look at the editor, review the screen, and patch the exact thing that failed. Fennara gives that loop to the AI. It is not C# only and not GDScript only; mixed Godot projects are supported too.

1

create or edit the Godot project

2

run diagnostics and validate scene state

3

capture runtime errors, warnings, and screenshots

4

format the important feedback for the model

5

patch the broken file and rerun the check

Not just a Godot remote control.

Fennara is a Godot-aware agent environment: commands when they help, feedback when the work gets real, and tracked changes so you stay in control. The source, setup notes, releases, and updates live on GitHub.

Open GitHubGitHub RepoLatest Release