# The 6 Specialized Agents in Understand Anything: Functions and Architecture

> Explore the 6 specialized agents in Understand Anything: project-scanner, file-analyzer, architecture-analyzer, tour-builder, graph-reviewer, and domain-analyzer. Understand their functions and how they build a navigable knowle...

- Repository: [Egonex/Understand-Anything](https://github.com/Egonex-AI/Understand-Anything)
- Tags: architecture
- Published: 2026-06-23

---

**Understand Anything uses six specialized agents—project-scanner, file-analyzer, architecture-analyzer, tour-builder, graph-reviewer, and domain-analyzer—to transform raw source code into a navigable knowledge graph.**

The Egonex-AI/Understand-Anything repository implements a multi-agent pipeline that breaks codebase analysis into discrete, focused responsibilities. When you execute the `/understand` command, five core agents collaborate to build a structural knowledge graph, while the optional `/understand-domain` command activates a sixth agent to extract business-domain concepts.

## The Multi-Agent Pipeline Architecture

Understand Anything orchestrates its agents sequentially to convert repository files into a richly annotated graph stored at [`.understand-anything/knowledge-graph.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/.understand-anything/knowledge-graph.json). Each agent consumes the output of the previous stage, adding metadata, relationships, or validations until the graph is complete. This design ensures that file discovery, parsing, architectural classification, and validation remain modular and debuggable.

## Core Agents in the Standard Pipeline

The standard `/understand` command activates five agents that handle structural and navigational analysis.

### 1. Project Scanner (File Discovery)

The **project-scanner** agent recursively traverses the repository to discover every file, detect the programming language or framework of each file, and build an initial import map. This foundational step creates the inventory that subsequent agents analyze. According to the source code in [`agents/project-scanner.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/agents/project-scanner.md), this agent handles the initial file system exploration and language detection logic.

### 2. File Analyzer (Structural Parsing)

The **file-analyzer** agent parses each discovered file using Tree-sitter to extract functions, classes, imports, and other structural elements. It creates graph nodes and edges that represent the code's structural relationships, transforming raw syntax into a queryable graph format. The implementation details in [`agents/file-analyzer.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/agents/file-analyzer.md) document the Tree-sitter integration and node/edge creation rules.

### 3. Architecture Analyzer (Layer Classification)

The **architecture-analyzer** agent consumes the structural graph and classifies each node into an architectural layer such as **API**, **Service**, **Data**, **UI**, or **Utility**. This classification enables high-level architectural queries and visualization. The logic for layer detection resides in [`agents/architecture-analyzer.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/agents/architecture-analyzer.md).

### 4. Tour Builder (Guided Onboarding)

The **tour-builder** agent generates guided learning tours that walk users through the codebase in dependency order. It provides plain-English explanations for each step, making the codebase accessible to new contributors. The tour generation algorithms are documented in [`agents/tour-builder.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/agents/tour-builder.md).

### 5. Graph Reviewer (Validation)

The **graph-reviewer** agent validates the knowledge graph for completeness and referential integrity. By default, it runs a lightweight inline review, but you can trigger a full LLM-based review using the `--review` flag. This validation step ensures the graph is coherent before it powers the dashboard or chat features. See [`agents/graph-reviewer.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/agents/graph-reviewer.md) for validation specifics.

## The Sixth Agent: Domain Analysis

The `/understand-domain` command adds a sixth specialized agent to the pipeline.

### Domain Analyzer (Business Context)

The **domain-analyzer** extracts business-domain concepts—including domains, flows, and process steps—and links code artifacts to real-world functionality. This agent bridges the gap between technical structure and business logic, enabling queries about "what the code does" rather than just "how it is structured." The extraction logic is implemented in [`agents/domain-analyzer.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/agents/domain-analyzer.md).

## Running the Agents: CLI Commands

You can execute the full pipeline or run individual agents for debugging purposes. The following commands demonstrate how to invoke each agent:

```bash

# Run the full standard pipeline (5 agents)

understand

# Run only the project-scanner to see discovered files

understand --agent project-scanner

# Run only the file-analyzer on a specific path

understand --agent file-analyzer src/

# Run only the architecture-analyzer (adds layer tags)

understand --agent architecture-analyzer

# Generate a guided tour without the full graph build

understand --agent tour-builder

# Validate the graph (default inline, full LLM review optional)

understand --agent graph-reviewer
understand --agent graph-reviewer --review

# Extract business domains (activates the 6th agent)

understand-domain

```

Each command writes output to [`.understand-anything/knowledge-graph.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/.understand-anything/knowledge-graph.json) and prints a status log. In normal usage, you simply run `/understand` or `/understand-domain` and the pipeline orchestrates the agents automatically.

## Summary

- **Six specialized agents** power Understand Anything: project-scanner, file-analyzer, architecture-analyzer, tour-builder, graph-reviewer, and domain-analyzer.
- **Standard pipeline** (`/understand`) runs the first five agents to build a structural knowledge graph.
- **Domain analysis** (`/understand-domain`) adds the sixth agent to extract business concepts and link code to real-world functionality.
- **Validation** occurs via the graph-reviewer, which supports both lightweight inline checks and full LLM reviews.
- **Output** is stored in [`.understand-anything/knowledge-graph.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/.understand-anything/knowledge-graph.json) and powers the dashboard, chat, and diff-analysis features.

## Frequently Asked Questions

### What is the difference between `/understand` and `/understand-domain`?

The `/understand` command runs the five core agents (project-scanner through graph-reviewer) to create a structural knowledge graph of your codebase. The `/understand-domain` command runs the same five agents plus the **domain-analyzer**, which extracts business-domain concepts like processes and flows to map code artifacts to real-world business functionality.

### How does the graph-reviewer validate the knowledge graph?

The graph-reviewer checks the graph for **completeness** and **referential integrity**, ensuring all nodes and edges are properly connected and no orphaned references exist. By default, it performs a lightweight inline validation, but you can activate a comprehensive **LLM review** by passing the `--review` flag to catch semantic inconsistencies.

### Can I run individual agents without executing the full pipeline?

Yes. Use the `--agent` flag followed by the agent name to run a specific agent in isolation. For example, `understand --agent project-scanner` runs only the file discovery phase, while `understand --agent file-analyzer src/` parses only the specified directory. This is useful for debugging specific pipeline stages.

### What file format does Understand Anything use to store the knowledge graph?

Understand Anything persists the knowledge graph as a **JSON file** located at [`.understand-anything/knowledge-graph.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/.understand-anything/knowledge-graph.json). This file contains the complete graph structure including nodes, edges, architectural classifications, and domain annotations generated by the agents.