Why did we build it? Because pasting LLM snippets into Unreal and praying isn't a workflow — and because the Auto-Fixer turned out cheaper than a new keyboard. 🧱⌨️

Table of contents

• Why VERA
• Features
• The brain — bring your own LLM
• How it works
• Built-in tools
• Plugins
• MCP — drive the editor from your IDE
• Install
• Configuration
• Usage
• Architecture
• Contributing
• FAQ
• Support — The Co-Pilot Pact
• License

Why VERA

Most "AI for Unreal" tools are a chat box that hands you a snippet to paste. VERA is
an agent: you ask in plain language, and it plans, calls the tools it needs,
looks at the result, and fixes things if something fails — inside your editor.

• Your brain, your rules. OpenAI, Anthropic, Gemini, or any local
  OpenAI-compatible server. Run it 100% offline with a local model, or reach for a
  frontier model when you want more power. Keys live in your .env and never leave
  your machine.
• It actually sees. VERA renders the viewport (via SceneCapture2D, even with
  the editor minimized) and reasons over the image — to inspect an actor, judge an
  animation, or critique a composition.
• It acts safely. Read-only tools run freely; anything destructive asks for
  your approval first. A Read mode lets it look without touching anything.
• It's extensible. Capabilities ship as opt-in plugins — a folder with
  tools/ and a SKILL.md. Write your own in minutes.
• It's free & open. MIT licensed, no studio, no lock-in.

Features

The brain — bring your own LLM

VERA speaks the OpenAI /v1 standard, so it works with essentially any backend:

💡 VERA is an agent, so the model needs solid tool-calling. For local, use a
30B+ coder model (e.g. Qwen2.5/3-Coder-32B); small models ramble. The first
request to a cold local server loads the model — which can take minutes — so the
request timeout is configurable right in Setup.

How it works

You ──▶ VERA chat (Qt/WebEngine UI inside the editor)
            │  command + selected provider/model/mode
            ▼
        AgentLoop  ─────────────────────────────────────┐
            │  1. ask the LLM (your provider) for a plan │
            │  2. LLM requests a tool                    │  repeat until done
            │  3. run the tool (gate if destructive) ────┤
            │  4. feed the result back to the LLM        │
            └─▶ 5. final answer ─────────────────────────┘
                         │
                         ▼
              Unreal Editor (Python bridge → the `unreal` API)

Every turn streams to the UI: you see the plan, each tool call, and the result as
it happens — and you can Stop at any point.

Built-in tools

The agent ships with a core toolset (read-only tools need no approval; ✋ = gated):

Chained together, the animation tools are a full rig → retarget → animate →
visually verify pipeline, driven entirely from chat.

Plugins

Capabilities ship as opt-in plugins so the core stays lean — you enable only what
you want, and a plugin's pip dependencies are pulled in on demand.
All plugins below are bundled and included 100% for free out of the box:

Write your own plugin

VERA_Plugins/my-plugin/
├── plugin.json        # {"name","version","enabled", optional "deps":[...]}
├── tools/*.py         # Tool subclasses (name, description, input_schema, execute)
└── SKILL.md           # when/how VERA should use it (injected into the system prompt)

A minimal tool:

from vera.agent.tool import Tool, ToolResult

class HelloTool(Tool):
    name = "say_hello"
    description = "Say hello. Use when the user greets VERA."
    input_schema = {"type": "object", "properties": {"to": {"type": "string"}}}
    def execute(self, args, ctx):
        return ToolResult(f"Hello, {args.get('to', 'world')}!")

Drop the folder in VERA_Plugins/, toggle it on in the Plugins tab — done.

MCP — drive the editor from your IDE

VERA ships an MCP server, so the AI in your
favorite IDE or agent can drive your Unreal editor — write Python into it, read
the log, screenshot the viewport, or run a full VERA command — without leaving your
editor.

Drop this into your MCP client's config (e.g. .mcp.json):

{
  "mcpServers": {
    "vera-ue": {
      "command": "python",
      "args": ["-m", "vera.tools.mcp_server"],
      "env": {
        "PYTHONPATH": "C:/path/to/VERA",
        "VERA_UE_PROJECT_DIR": "C:/path/to/YourProject"
      }
    }
  }
}

PYTHONPATH must point at the VERA repo root (the folder containing the
vera/ package), so python -m vera.tools.mcp_server can find it. Some clients
(e.g. Claude Code) launch the server from the project root and work without it,
but most run from a different working directory — if you see
ModuleNotFoundError: No module named 'vera', this is the fix. You can also
point command at a specific interpreter (e.g. a full python.exe path).

Works with any MCP-capable client — Claude Code, Cursor, VS Code
(Cline / Continue / Copilot), JetBrains Rider (AI Assistant), Windsurf,
Zed, and more:

Install

From source (developers)

git clone https://github.com/ezesubu/VERA.git
cd VERA
python PackageVERA.py

1. Copy the assembled Plugin/ folder into your own Unreal Engine project's Plugins/VERA/ directory.
2. Enable Unreal's Python Editor Script Plugin.
3. Open VERA from the editor toolbar. On first launch it auto-installs its
   Python dependencies (one time) — no console magic.
4. In Setup ⚙, pick a provider and paste a key (or a local server URL), then chat.

Build the distributable plugin (UE 5.7)

python PackageVERA.py        # assemble from source + bundle deps + RunUAT + zip → Packaged/

The output is a compiled, drag-and-drop plugin ready for the Epic Games Launcher
/ Fab. Want another engine version? Clone and build it yourself — the pipeline targets
the latest UE.

Requirements

• Unreal Engine 5.7 (latest)
• The Python Editor Script Plugin (bundled with UE)
• Internet access only if you use a cloud provider (local models run fully offline)

Configuration

VERA reads a .env at the repo root (and the Setup panel writes to it for you):

🔒 Keys are saved to your .env and never sent back to the frontend.

Usage

Open the VERA panel and just ask. A few things to try:

• "How many actors are in this level, and how many are lights?"
• "Create a BP_SpikeTrap Blueprint with a static mesh and a box collision."
• "Retarget these animations from the UE4 mannequin to my character, then show me the idle."
• "Audit this level for mobile performance issues."
• "Set a horror vibe on the scene for a screenshot."
• "Remember that this project uses the SM_ prefix for static meshes."

Switch Ask / Auto / Read in the composer to control how much freedom VERA has.

Architecture

┌─────────────────────────── Unreal Editor ───────────────────────────┐
│                                                                      │
│   VERA panel (Qt WebEngine UI)  ◀──┐                                 │
│        │ command                   │ events (stream)                 │
│        ▼                           │                                 │
│   vera_server  ──▶  AgentLoop  ──▶ tools ──▶ Python bridge ──▶ unreal│
│        │                │                                            │
│        │                └─ plugins (VERA_Plugins/*)                  │
│        ▼                                                             │
│   MCP server  ◀── Claude Code / other MCP clients                   │
└──────────────────────────────────────────────────────────────────────┘
            ▲
            └─ LLM provider (OpenAI / Anthropic / Gemini / local)

• vera/agent/ — the AgentLoop, tool registry, sessions, the multi-provider client.
• vera/llm/ — the OpenAI-compatible adapter (duck-types the Anthropic surface).
• vera/tools/ — the MCP server and the UE socket connection.
• vera/core/ — the editor server (vera_server) and the progress blackboard.
• Content/Python/ — the editor scripts (including the Async Bridge that prevents timeouts during heavy generations) + the chat UI (vera_chat/).
• Content/Python/vera/vera_graph_utils.py — The universal graph standard library, resolving API differences across Blueprints, PCG, and Materials.
• VERA_Plugins/ — the studio plugins.

Contributing

Contributions are welcome — new tools, plugins, providers, fixes.

# run the test suite
python -m pytest tests/ -q

• Add a tool: create a Tool subclass in vera/agent/tools/ — the registry
  discovers it automatically.
• Add a plugin: see Write your own plugin.
• Add a provider: extend the registry in vera/agent/models.py.

The codebase is Python + a thin C++ editor module, fully cross-platform, and covered
by a test suite. Open an issue or a PR, or come chat in
Discord.

FAQ

Do I need to know Unreal or Blueprints?
No. You describe what you want in plain language and VERA builds it through the
engine's code layer — assets, actors, components, properties, whole systems.

Does VERA wire the visual Blueprint nodes for me?
Out of the box it creates the Blueprint, its components and properties, then
compiles and saves it. Wiring the visual Event Graph (the "spaghetti") is one
plugin away — a C++-backed plugin can reach the graph APIs that Python can't
and generate the nodes too. That's the point of the plugin system: no ceiling.

Is it free? Does it phone home?
MIT, free, and it can run 100% local with your own model — your keys and data
never leave your machine.

Support — The Co-Pilot Pact

VERA is independent and open — no studio, no investors, no lock-in. It's free and
runs on your own keys and hardware. If it earns its keep, you can keep it alive:

• 💎 Support on Patreon — monthly or a one-off gift
• ☕ Tip on Ko-fi · 🍺 Buy a Beer
• 💬 Join the Discord — free, come say hi
• ⭐ Star the repo and tell another dev — it genuinely helps.

License

MIT — use VERA in your commercial and AAA projects. See LICENSE.

Credits

Conjured in the dark by maVERAick — Sith Lord of the Unreal Editor — mortal
identity @ezesubu. ⚡🌑

Core AI Team & Contributors:

• Claude — Lead UI Architect
• Antigravity (Gemini) — Lead Artist & Infrastructure

Come to the dark side. We have agents.