The Architecture Inference Tool
Derive a repository’s components and the relationships between them from its structure and imports — the high-level architecture an agent needs to reason about the system, recovered automatically and on infrastructure you control.
The architecture diagram is always out of date
The real architecture lives in the code, but the diagram lives in a slide from two years ago. When the documented design and the actual structure diverge, every decision built on the diagram is suspect.
Docs drift from code
Architecture diagrams are stale the moment the code changes.
Structure is implicit
The real components and boundaries are buried in the file layout and imports.
Onboarding is slow
New engineers reconstruct the architecture from scratch.
Agents lack the big picture
Without a component map, an agent reasons file-by-file, not system-wide.
Architecture recovered from the code
Components
Infer the building blocks
From structure and imports.
The tool groups the repository into components based on its structure and import patterns, recovering the building blocks of the system as it actually exists rather than as it was once drawn.
- Component grouping
- Structure-based inference
- Import-driven boundaries
- Per-ref analysis
From real code
Relationships
How components connect
The edges, not just the nodes.
It derives the cross-component relationships, so an agent can see how the system’s parts depend on one another — the context needed to reason about change at the architecture level.
Cross-component
Governance
On-premise analysis
Source stays internal.
Inference runs against a snapshot inside your perimeter with audit logging, so architecture recovery never exposes code.
IP-safe, logged
Parameters
The architecture_inference tool accepts these inputs when an agent calls it. Required inputs are flagged.
Where architecture inference pays back
Living architecture
Replace the stale slide with an inferred, current view.
Onboarding
Give new engineers the real component map on day one.
Refactor planning
See component boundaries before reshaping them.
Modernization
Understand a legacy system before migrating it.
Doc generation
Feed inferred architecture into the architecture-doc generator.
Agent reasoning
Let an agent reason at the system level, not just per file.
Assigned to agents, orchestrated as networks
On VDF AI, an industry’s use cases map to agents, and you assign tools like this one to those agents. Compose multiple agents into a governed, on-premise network.
What changes after you assign it
Questions about the Architecture Inference tool
What does the architecture inference tool do?
It derives a repository’s components and the relationships between them from its structure and import patterns, recovering the system’s real architecture automatically. Assigned to an agent, it provides the system-level context needed to reason about change.
How is it different from the dependency analyzer?
The dependency analyzer maps packages and module imports; architecture inference steps up a level to group code into components and map how those components relate.
Will it match our documented design?
It reflects the architecture as it exists in the code, which often reveals where the documented design has drifted from reality.
Is our code exposed?
No. Inference runs on-premise with audit logging; source never leaves your perimeter.
How does it pair with other tools?
It builds on the dependency analyzer and repository map and feeds the architecture-doc generator for living documentation.
Tools that work well alongside this one
Where this tool delivers value
Recover your architecture from the code
See architecture inference give an engineering agent a current component map — on-premise.