ARCHITECTURE CHECKERS / COMPARISON

ArchKeel vs Import Linter,
Tach, ArchUnit & agent contracts

Which tool fits which problem? The table shows the documented focus. A capability not mentioned here is not treated as absent.

When ArchKeel is not the first choice

For import rules in an existing stack, its checker may be sufficient. For JVM architecture tests, ArchUnit fits the ecosystem. ANMA and code-governance are alternatives for agent-guided module setup. Consider ArchKeel when you also need declared-change checks and comparable analysis evidence.

Documented focus · reviewed 11 October 2026 · primary sources linked per tool
Tool	Stack	Focus	When to choose
Import Linter ↗	Python	Import contracts: forbidden, layered and independent modules.	When Python import rules solve your problem.
Tach ↗	Python	Module dependencies and public interfaces with visibility checks.	When you need Python module boundaries and interface checks.
ArchUnit ↗	JVM	Architecture tests over classes, packages, calls and accesses.	When you need architecture tests inside a JVM test suite.
dependency-cruiser ↗	JS / TS	Declarative dependency rules and graphs.	When your JavaScript/TypeScript project needs dependency rules.
Nx boundaries ↗	Nx-Workspace	Tag-based project boundaries, lint rules and conformance.	When you already use Nx and need project boundaries.
ANMA ↗	Python / Go / TS	YAML contracts generate agent context, hooks and CI. Interface checking is documented for Python only.	When generated guidance and PreToolUse hooks fit your workflow.
code-governance ↗	Python / TS	AST-based boundaries and a Claude Code plugin; documented diff mode.	When agent-guided setup and module checks fit your workflow.
agent-maintainer ↗	Python	Maintains a broader quality and repair workflow using other checkers.	When you want to combine several quality gates for agents.
ArchKeel ↗	Python / Dart / TS	Contracts, declared changes, comparable analysis evidence and focused snapshot queries. Analysis scope differs by language.	When declared changes and analysis regressions belong in your architecture review.

Where do SonarQube, CodeScene, Structurizr and IcePanel fit?

SonarQube combines code quality with architecture management in supported commercial editions. CodeScene prioritizes technical debt. Structurizr and IcePanel support architecture modelling. Choose according to the review question you need to answer.

Documented focus · reviewed 11 October 2026 · vendor sources linked per tool
Tool	Focus	When to choose
SonarQube ↗	Code quality and security; current and intended architecture in supported commercial editions.	You want findings and architecture issues in an existing Sonar workflow.
CodeScene ↗	Code Health and Git activity reveal hotspots and help prioritize technical debt.	You need to decide where refactoring effort will matter most.
Structurizr ↗	Versioned C4 models, diagrams, documentation and architecture decisions as code.	Your team wants to review architecture documentation in Git.
IcePanel ↗	Collaborative C4 modelling, reusable objects and views for different audiences.	Your team needs a shared visual model for design discussions.
ArchKeel ↗	Declared boundaries and changes, comparable analysis evidence, As-Is / Target / Diff.	Your review must check the agreed change and preserve what the analysis can resolve.

Selection guide: when Sonar and the other tools fit better →

Is ArchKeel an alternative to Import Linter?

Partly. Import Linter checks contracts on imports between Python modules. For forbidden dependencies, layers or independent modules, that is a direct fit. Consider ArchKeel when your review also needs declared-change checks, comparable analysis evidence and a contract that humans and agents can query.

What does the dispatch replay show beyond import rules?

The Python function changes from explicit calls to handlers[key](amount). All eight behavior tests stay green. The imports do not change, but one call can no longer be resolved statically. archkeel check rejects the candidate because calls_unresolved rises from 0 to 1. The replay establishes lost analysis evidence, not a runtime defect.

return handlers[key](amount)

behavior tests       8/8 → 8/8
unresolved calls      0 → 1
archkeel check        FAIL · exit 1

Inspect the code and finding ↗ · Conditions and source · Run the replay

A recorded ArchKeel replay; no comparative Import Linter benchmark was run.

When are Tach or ArchUnit a better fit?

Tach fits Python module boundaries and public interfaces. ArchUnit fits architecture tests in a JVM test suite; it also checks classes, calls, accesses and inheritance. If those checks solve your problem, you may not need a second review workflow.

How do the contract and Explorer help with agent review?

The Architecture Contract records components, responsibilities, interfaces and allowed dependencies. Humans review As-Is, Target and Diff in the Explorer. Coding agents query the same contract and findings as structured data. For candidate comparisons, an expectation published before submission adds the permitted changes and the analysis measurements that must be preserved.

When is ArchKeel not the first choice?

For import rules alone, your existing checker may be enough. ANMA and code-governance are also options for agent context and hooks. ArchKeel needs maintained contracts, CI and comparable baselines. Static evidence does not replace behavior tests or your architectural judgment.

What are the limits of this comparison?

The table describes each tool’s focus from its linked documentation. It does not rank speed or assert untested missing capabilities. Authentic ordering in the change check requires trusted Git or host evidence; the reference explains the setup.

ArchKeel is developed by rapiddweller. This comparison is a rapiddweller product page.

Inspect the contract and evidence Set up ArchKeel