ARCHITECTURE CONTRACT · EXPLORER · DETERMINISTIC CHECKS

One architecture contract.
For you and your agent.

Define components, responsibilities and allowed dependencies. Review the implementation, the declared Target and their differences in the ArchQ Explorer. Your coding agent queries the same contract and findings.

Architecture checks for coding agents

Local · No LLM in the checker · MIT · Python, Dart, TypeScript with different analysis scope

ArchQ ExplorerArchKeel 2.0.0
ArchKeel 2.0.0: our own architecture123 files · 36 components

As-Is

What the code actually contains.

Target

What the contract declares.

Diff

Where implementation and Target differ.

Search · Health check · Perspectives · Fullscreen · SVG and Mermaid export

Open a component to explore its responsibilities, interfaces and dependencies. As-Is, Target and Diff show our own code and the contract declared for it.

Recorded snapshot · aa159e5 · retrieved 2026-10-12. Analysis limits and UNKNOWN are recorded in the report.

Open the full report ↗Latest published report ↗
Source evidence for findingsDeclared-change checksUNKNOWN stays visible

ONE CONTRACT / TWO WAYS TO READ IT

You review the architecture.
Your agent works from the same contract.

Components, responsibilities, public interfaces and allowed dependencies live in the Architecture Contract. The Explorer makes that contract and the observed implementation readable. CLI queries give the agent structured facts and findings.

01

Human

Decide boundaries and responsibilities. Review Target and Diff in the Explorer.

02

Coding agent

Query the contract and focused findings as machine-readable data. Implement within the decided boundaries.

03

ArchKeel

Check the rules deterministically. Show violations with source evidence and unresolved analysis as UNKNOWN.

The Explorer is available today as a generated offline report. Studio’s collaborative whiteboard and chat interface are planned.

GREEN TESTS ARE NOT ENOUGH

A decided boundary
becomes a checkable finding.

A coding agent can cross a boundary without failing a behavior test. This rule declares the boundary. The finding identifies the source location.

YOUR CONTRACTJSON · rule excerpt
{
  "id": "DEP-RENDER-NO-STORE",
  "kind": "forbidden_dependency",
  "source": "shop.render",
  "target": "shop.store",
  "include_type_checking": true,
  "rationale": "Text projection consumes typed values without touching persistence.",
  "provenance": ["docs/architecture/shop.md"],
  "decided_by": "architect"
}

10 lines from the Shop rule. The full contract also contains components and other rules.

ARCHKEEL / DOCUMENTED FINDINGFAIL

render → store

Presentation reaches into persistence. This dependency is forbidden by the contract.

shop/render/text.py:9from shop.store import OrderRepository
rule
DEP-RENDER-NO-STORE
finding
rule.violated
evidence
closed_world.observed_forbidden
Inspect the Shop fixture and full contract ↗

Source: Shop fixture in the README.

EVIDENCE / PYTHON REPLAY

Eight tests still pass.
One call can no longer be resolved.

A switch to dictionary dispatch keeps eight behavior tests green. Static analysis can no longer resolve the new call. The candidate is rejected for that regression.

before → candidate
# before · sample/work.py
from sample.helpers import credit, debit


def run(key: str, amount: int) -> int:
    if key == 'credit':
        return credit(amount)
    if key == 'debit':
        return debit(amount)
    raise KeyError(key)

# candidate · sample/work.py
from sample.helpers import credit, debit


def run(key: str, amount: int) -> int:
    handlers = {'credit': credit, 'debit': debit}
    return handlers[key](amount)
Behavior tests8/8 → 8/8
Unresolved calls0 → 1
Architecture violations0 → 0
archkeel checkFAIL · exit 1

This replay measures static visibility. It does not establish a runtime defect. The source record contains the full conditions and call counts.

Conditions & source ↗Result JSON ↗Reproduce ↗

WHY ARCHKEEL?

When would you add ArchKeel
to your architecture checker?

Import Linter and Tach check Python boundaries; ArchUnit tests JVM architecture, including calls and accesses. dependency-cruiser and Nx check dependencies in JavaScript/TypeScript projects.

ArchKeel combines declared-change checks, regression checks on comparable analysis evidence, and focused snapshot queries that retain UNKNOWN. ANMA and code-governance also support agents. Choose ArchKeel when you need this review loop.

01

Declared change

Compare the candidate with an expectation published before submission.

02

Detect evidence loss

Fewer findings are insufficient when analysis can see less.

03

Focused evidence

Query the contract and findings by scope. Keep global results and UNKNOWN.

Compare the tools against the review loop you need.

Compare tools and limits

SonarQube, CodeScene and C4 tools: which fits? →

YOUR FIRST CHECK

Install.
Review the boundaries.

Python 3.11+ and a Git repository with at least one commit. Use a Python version compatible with your project.

Ask your agent to read the architecture docs, propose boundaries, and let you decide which dependencies are allowed.

Read the setup guide ↗
local setup
uv tool install archkeel
archkeel skill install codex
# or: archkeel skill install claude
For a reviewed contractarchkeel validate

For the declared-change gate: archkeel check with the protocol configured. report produces evidence and can exit 0 despite FAIL or UNKNOWN.

CLI exit codes ↗

ArchKeel 2.0.0 is released. Historical examples use their documented versions. Release notes ↗

ARCHKEEL CHECKS ARCHKEEL

Our architecture. Our findings.

We check our own code with the same tool. The snapshot in the Explorer contains these rule assessments:

PASS

49 rules

Completed rules without violations.

FAIL

0 rules

Rules with recorded violations.

UNKNOWN

4 rules

Rules whose required evidence is incomplete.

Overall result: UNKNOWN. Passing rules leave the remaining analysis gaps open.

Inspect findings and evidence ↗

FAQ

What does ArchKeel check?

What is ArchKeel?

Architecture checks for coding agents. ArchKeel checks declared architecture boundaries and changes in AI-assisted code. The CLI runs locally and deterministically, without an LLM in the checker.

When is another checker enough?

If you only need import or module constraints in your existing stack, your current checker may be sufficient. ArchUnit also offers JVM structural tests.

What can ArchKeel not prove?

Complete runtime correctness or good architecture. Analysis is static and depends on the language profile.

Is Studio available today?

The collaborative Studio interface is planned. The CLI and its reports are available. See the Studio concept on Vision & Roadmap.

Check your next candidate.