# How Egonex-AI's Multi-Agent Pipeline Orchestrates Knowledge Graph Construction

> Discover how Egonex-AI's multi-agent pipeline orchestrates a deterministic sequence of specialized agents for efficient knowledge graph construction. See the process and key components.

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

---

**Egonex-AI's Understand-Anything tool orchestrates knowledge graph construction through a deterministic sequence of specialized agents—project-scanner, file-analyzer, domain-analyzer, architecture-analyzer, and graph-reviewer—that feed JSON artifacts into a central GraphBuilder class to produce a validated, layered knowledge graph.**

The Egonex-AI/Understand-Anything repository implements a modular **multi-agent pipeline** that transforms raw codebase files into structured knowledge graphs. Triggered by the `understand` skill when users invoke `/understand --full`, the pipeline coordinates discrete agents through the skill definition in [`understand-anything-plugin/skills/understand/SKILL.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/skills/understand/SKILL.md). Each agent handles a specific extraction phase, storing intermediate results under `.understand-anything/` before the GraphBuilder assembles the final graph.

## The Agent Orchestration Flow

The pipeline executes six specialized agents in a strict sequence, with each agent consuming the outputs of its predecessors and producing typed JSON artifacts for the next stage.

### Project Scanning with project-scanner

The **project-scanner** agent ([`understand-anything-plugin/agents/project-scanner.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/agents/project-scanner.md)) initiates the pipeline by walking the target repository and cataloging every file path. It categorizes files by type—code, config, document, service, or pipeline—and generates [`scan-inventory.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/scan-inventory.json) containing the complete inventory of file-level nodes.

```json
{
  "files": [
    {"path":"src/main.ts","type":"file"},
    {"path":".github/workflows/ci.yml","type":"pipeline"}
  ]
}

```

### File Structure Extraction with file-analyzer

The **file-analyzer** agent ([`understand-anything-plugin/agents/file-analyzer.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/agents/file-analyzer.md)) processes each entry from the inventory. It invokes language-specific Tree-Sitter parsers to extract functions, classes, definitions, services, endpoints, and pipeline steps. The agent outputs per-file JSON blobs to `file-analysis/<path>.json` alongside a centralized [`meta.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/meta.json) containing summaries, tags, and complexity metrics.

The skill calls the `extract-structure.mjs` script, which instantiates the GraphBuilder and feeds structural analysis data into the builder's intake methods.

### Domain Concept Identification with domain-analyzer

The **domain-analyzer** agent ([`understand-anything-plugin/agents/domain-analyzer.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/agents/domain-analyzer.md)) identifies business concepts and domain models that transcend individual source files. It produces [`domain-nodes.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/domain-nodes.json), a structured list of domain and flow nodes that will later attach to architectural layers, ensuring the knowledge graph captures semantic meaning beyond code structure.

### Architecture Synthesis with architecture-analyzer

The **architecture-analyzer** agent ([`understand-anything-plugin/agents/architecture-analyzer.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/agents/architecture-analyzer.md)) groups file-level nodes into logical layers based on node type heuristics:

1. **CI/CD Layer**: Created when `pipeline` nodes exist in the inventory
2. **Infrastructure Layer**: Contains `service` and `resource` nodes
3. **Application Layer**: Houses remaining `file`, `class`, and `function` nodes

This agent outputs [`layers.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/layers.json), mapping each layer name to its constituent `nodeIds`.

### Graph Assembly with GraphBuilder

The **GraphBuilder** class ([`understand-anything-plugin/packages/core/src/analyzer/graph-builder.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/packages/core/src/analyzer/graph-builder.ts)) serves as the central aggregation point for all pipeline data:

```ts
export class GraphBuilder {
  addFile(filePath:string, meta:FileMeta): void { … }
  addFileWithAnalysis(filePath:string, analysis:StructuralAnalysis, meta:FileAnalysisMeta): void { … }
  addNonCodeFileWithAnalysis(filePath:string, meta:NonCodeFileAnalysisMeta): void { … }
  build(): KnowledgeGraph { … }
}

```

The builder creates file nodes, function/class child nodes, and non-code child nodes (such as `pipeline` and `resource` types). It establishes relationships through **`contains`**, **`imports`**, and **`calls`** edges based on the analysis data. When the final agent completes, `GraphBuilder.build()` returns the complete `KnowledgeGraph` object, serialized to [`.understand-anything/knowledge-graph.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/.understand-anything/knowledge-graph.json).

### Validation with graph-reviewer

The **graph-reviewer** agent ([`understand-anything-plugin/agents/graph-reviewer.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/agents/graph-reviewer.md)) performs QA checks on the assembled graph before final delivery. It verifies that every file-level node appears in exactly one layer, that `pipeline` nodes maintain at least one `triggers` edge, and that no duplicate node IDs exist. If validation fails, the pipeline aborts and surfaces a diagnostic report; otherwise, the graph is marked approved and passed to the dashboard UI.

## Running the Full Pipeline

Execute the complete multi-agent pipeline using the skill entry script:

```bash

# Install dependencies (pnpm workspace)

pnpm install

# Build core and skill packages

pnpm --filter @understand-anything/core build
pnpm --filter @understand-anything/skill build

# Execute the full pipeline

understand-anything-plugin/skills/understand/scan-project.mjs \
  --project <path> \
  --full

```

The `--full` flag triggers the entire agent sequence, storing intermediate JSON artifacts under `.understand-anything/` and outputting the final validated graph.

## Summary

- The **multi-agent pipeline** operates as a deterministic chain defined in the `understand` skill, processing codebases through six specialized agents.
- **project-scanner** inventories files, **file-analyzer** extracts structure, **domain-analyzer** identifies business concepts, and **architecture-analyzer** organizes nodes into layers.
- The **GraphBuilder** class aggregates all agent outputs to construct typed nodes and edges (`contains`, `imports`, `calls`).
- **graph-reviewer** enforces integrity constraints before finalizing the knowledge graph to [`.understand-anything/knowledge-graph.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/.understand-anything/knowledge-graph.json).
- Intermediate results are stored as JSON artifacts, making the pipeline auditable and repeatable.

## Frequently Asked Questions

### What is the exact execution order of agents in the pipeline?

The pipeline executes in this strict sequence: first **project-scanner** creates the inventory, then **file-analyzer** extracts code structure, followed by **domain-analyzer** for business concepts, then **architecture-analyzer** for layer grouping, then **graph-builder** assembles the graph, and finally **graph-reviewer** validates the output. This order ensures each agent has access to the previous stage's JSON artifacts.

### How does the GraphBuilder establish relationships between nodes?

The GraphBuilder creates edges based on analysis metadata fed by the file-analyzer. It generates **`contains`** edges for parent-child relationships (files containing functions or classes), **`imports`** edges for dependency relationships, and **`calls`** edges for invocation relationships. These edges are established through the `addFileWithAnalysis` and `addNonCodeFileWithAnalysis` methods before `build()` finalizes the graph.

### Where does the pipeline store intermediate results during execution?

All agents write JSON artifacts to the `.understand-anything/` directory within the target project. Specific files include [`scan-inventory.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/scan-inventory.json) from the scanner, `file-analysis/<path>.json` from the analyzer, [`domain-nodes.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/domain-nodes.json) from the domain agent, [`layers.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/layers.json) from the architecture agent, and [`knowledge-graph.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/knowledge-graph.json) from the final builder.

### What validation rules must the knowledge graph pass?

The **graph-reviewer** enforces three critical constraints: every file-level node must belong to exactly one architectural layer, every `pipeline` node must have at least one `triggers` edge connecting it to other nodes, and the entire graph must contain zero duplicate node IDs. Violations trigger pipeline abortions with diagnostic reports pointing to specific integrity failures.