Layer architecture graph

This page reads a knowledge graph built by Understand-Anything through static repository analysis: file-level nodes grouped into 14 layers, with only the imports edges aggregated across layer boundaries. The raw graph is too large to ship (14,555 nodes), so the page consumes a single small JSON emitted by the aggregation script (src/data/geode/layer-graph.json).

◯ size = files in the layer— edge = cross-layer imports (thicker = more)▬ gold = the 5 heaviest, labelled● runtime● tests● docs / site● config

Node size is the layer's file count; edge thickness is the number of imports between two layers. Direction is folded (both ways summed), and only the five heaviest edges carry a gold label. Imports within a single layer are excluded from this cross-layer view.

The five heaviest dependencies

1. 207 — Self Improving And Seed Generation ↔ Tests
2. 205 — Agent Runtime ↔ Tests
3. 141 — LLM And Prompts ↔ Tests
4. 109 — Config Auth Observability ↔ Tests
5. 105 — Memory Hooks Wiring ↔ Tests

All five touch Tests because the suite imports each runtime layer directly, which makes it the widest-reaching node in the cross-layer import graph.

Hubs and isolated layers

• Tests (0 in / 976 out) — Widest importer: the test suite reaches into every runtime layer (imports-out only, nothing imports the tests back).
• Agent Runtime (241 in / 125 out) — Runtime hub: the most-imported code layer — the agentic loop and its result model that the other runtime layers depend on.
• Public Site (258 files, 0 edges) — No cross-layer import edges: it connects through prose references and the build, not through Python imports.
• Architecture Docs (70 files, 0 edges) — No cross-layer import edges: it connects through prose references and the build, not through Python imports.
• Research Audit Docs (135 files, 0 edges) — No cross-layer import edges: it connects through prose references and the build, not through Python imports.

Layer-by-layer

Snapshot 2026-07-03. Files = analyzed file count, In/Out = cross-layer imports, Cross-degree = In+Out.

Reading tour (7 steps)

The graph's tour is a recommended reading order for someone opening the repository for the first time: start at the identity documents, then the execution loop, tools, the prompt/provider stack, wiring, the audit plugin, and end at the public site.

1. Project Identity. Start with the public README and runtime identity documents to understand what GEODE is.doc: README.mddoc: GEODE.mddoc: AGENTS.md
2. Agentic Loop. Follow the core while(tool_use) execution loop and its result model.src: core/agent/loop/agent_loop.pysrc: core/agent/loop/models.pysrc: core/agent/loop/_context.pysrc: core/agent/loop/_response.py
3. Tool Execution. Inspect tool processing, approval gates, result serialization, and native tool registry surfaces.src: core/agent/tool_executor/processor.pysrc: core/agent/tool_executor/executor.pysrc: core/tools/registry.pyconfig: core/tools/definitions.json
4. Prompt And Provider Stack. Review prompt assembly and provider adapters that turn runtime state into model calls.src: core/llm/prompt_assembler.pysrc: core/llm/providers/anthropic.pysrc: core/llm/providers/openai.pysrc: core/llm/providers/glm.py
5. Memory, Hooks, And Wiring. See how context, lifecycle events, bootstrap, IPC, and gateway execution surround the loop.src: core/memory/context.pysrc: core/hooks/system.pysrc: core/wiring/container.py
6. Petri Audit Extension. Explore the plugin that evaluates GEODE behavior with Petri-style alignment audits.src: plugins/petri_audit/runner.pysrc: plugins/petri_audit/cli_audit.py
7. Public Site. Inspect the Next.js site, generated source-of-truth data, diagrams, and docs surface.src: site/src/data/geode/sot.tssrc: site/src/app/docs/architecture/agentic-loop/page.tsxsrc: site/src/components/geode/agentic-loop-diagram.tsx

How this map is generated

Generated with Understand-Anything v2.8.1 from HEAD b742381, 2026-07-03

Regeneration is two steps. First, an Understand-Anything v2.8.1 re-scan of the repository refreshes .understand-anything/knowledge-graph.json; then the aggregation script runs from the site. The raw graph is a local-only artifact and is never committed (in a worktree, pass its absolute path via KG_JSON).

# 1. rescan (Understand-Anything v2.8.1) -> .understand-anything/knowledge-graph.json
# 2. aggregate into the small JSON + the deck SVG:
KG_JSON=/abs/.understand-anything/knowledge-graph.json npm run build-layer-graph

The same aggregation also emits a light-palette SVG for slide decks at public/diagrams/layer-graph-deck-light.svg.

Read next

• Architecture deep-dive. Data flows across the layers.
• System index. The flat catalog of every subsystem and its path.
• Why five layers. Why the boundaries fall where they do.