Hades

In the underworld of your Unity project, nothing is hidden from Hades. And now, nothing is hidden from your AI agent.

Hades is Unity-aware AI infrastructure for Claude Code. It builds a queryable knowledge graph of your entire Unity project — every scene, prefab, script, asset, and dependency — so your AI agent knows your project's structure instead of guessing at it. Out of the box you get 88 MCP tools, 22 skills, and 6 commands. Everything runs locally, and everything is version-controllable.

Stock Claude Code reads ~200k tokens of YAML, finds 1 prefab, misses 3
variants, and tells you to add code that breaks them. Hades answers
correctly — 4 prefabs, 3 scenes — in 7 tool calls for 27% less cost.
That gap is the whole project.

Know, don't guess

Most AI tools search and predict: they grep for text that looks relevant and let the model infer the rest. The answers are probabilistic — and often wrong in ways you can't see.

Hades lets your agent know and analyze. When it asks "what references PlayerController," it reads a structural fact from the graph, not a guess from scattered snippets. Dependency analysis traces real edges. Ask the same question twice, get the same answer. One graph query replaces a dozen file reads — and the agent never makes you explain your project twice.

What Hades gives your AI agent

How the pieces fit together

flowchart TD
    Agent["AI Agent<br/>(Claude Code)"]
    Agent <-->|"88 MCP tools (via Bridge)"| Hades

    subgraph Hades["Hades — inside the Unity Editor"]
        Graph["Graph<br/>project knowledge graph"]
        Asphodel["Asphodel<br/>persistent memory"]
        Charon["Charon<br/>observability"]
    end

    Graph -->|"indexes"| Unity["Unity Project<br/>scenes · prefabs · scripts · assets"]
    Asphodel -->|"stored as"| Mem[".arcforge/memory/*.md"]
    Graph -.->|"traced by"| Charon
    Asphodel -.->|"traced by"| Charon

Your agent talks to Hades through the 88 MCP tools (carried over the Bridge launcher and hub). Inside the Unity Editor, Graph indexes your project's structure, Asphodel persists project memory as version-controlled markdown, and Charon traces every operation so nothing is hidden.

How Hades compares

Most AI-for-Unity tooling falls into one of two camps. Action bridges let an agent execute editor actions but have no model of your project. Code-graph / RAG tools understand code but are blind to Unity's asset layer — prefabs, scenes, GUIDs, serialized references. Hades does both, and it's Unity-native.

See it in action

Open Claude Code from your Unity project directory and ask:

Tell me about this project

The agent uses the graph to give a project-specific overview — not a generic summary.

Where do we use PlayerController?

Structural search across scenes, prefabs, and scripts — not just text grep.

I want to remove OldNetworkManager. What would break?

Dependency analysis that traces references through the full project graph before you change anything.

Want proof? With and without Hades: one prompt, side by side — the same task run twice under identical conditions. Stock Claude Code misses 3 prefab variants and recommends a change that would break inheritance; Hades returns the correct impact map for 27% less cost. Includes full uncut recordings and reproduction steps.

What to trust (and what to verify)

Hades is honest about its own certainty — every result carries a confidence signal, and the tools tell you when not to rely on them. As a rule of thumb:

Hades is a navigator, not an oracle: it makes understanding your project fast and structural, and it surfaces its own blind spots so you (and your agent) stay in the loop before anything destructive. See Interpreting results for what each confidence signal means, and Limitations for the boundaries that are there by design.

Prerequisites

• macOS — currently the only tested platform. Windows and Linux are untested; reports welcome.
• Unity 6000.0+
• Node.js 20+
• Claude Code (or any MCP-compatible agent client)

Installation

Step 1: Unity Package

From git URL:

In Unity's Package Manager, click Add package from git URL and enter:

https://github.com/TheArcForge/Hades.git

From local folder (for testing or offline use):

In Unity's Package Manager, click Add package from disk... and select the package.json inside your local Hades folder.

On first open after install, Hades automatically builds the project knowledge graph. This is a one-time step (behind a progress bar) — a few seconds on a typical project, up to a few minutes on a very large one. After that, updates are incremental and near-instant.

Step 2: Claude Code Plugin

Option A: Persistent install (recommended)

/plugin marketplace add TheArcForge/hades-plugin
/plugin install hades

Option B: Per-session

claude --plugin-dir /path/to/hades-plugin

That's it. Open Claude Code from your Unity project directory and the tools are available immediately.

First time? See the full Getting Started guide for a step-by-step walkthrough with verification at each step.

How it works

Claude Code connects over stdio to a lightweight launcher, which routes HTTP requests to the Hades Hub, which in turn forwards tool calls to the correct Unity Editor instance. The Hub runs once per machine and handles multi-project routing automatically. All data stays local — no cloud services, no telemetry, no vendor lock-in. See Documentation/arcforge-hades-architecture.md for full architectural details.

Troubleshooting

See Documentation/troubleshooting.md for the full troubleshooting guide.

Project status

Hades is v1 — field-tested on a large production Unity project, but young. Static analysis has known boundaries (see Limitations), and it hasn't yet been exercised across many projects, Unity versions, or platforms. That's where you come in: if a result looks wrong on your project, please open an issue — concrete repros on real projects are exactly how v1 gets solid. The tools are built to tell you when they're uncertain, so trust the confidence signals and verify before anything destructive.

Documentation

• Interpreting results — what each confidence signal means and how to act on it
• Limitations — the boundaries that are there by design
• Architecture — system design, data flow, component responsibilities
• Plugin Manifest — tool and skill reference
• Roadmap — development phases and status
• Vision — long-term goals and design philosophy

License

MIT