Zum Hauptinhalt springen

Architecture & Security Model

azuma nori is engineered around a core principle: Absolute Data Sovereignty. We understand that providing source code to third-party servers is often a non-starter for enterprise compliance audits. To solve this, nori utilizes a localized, multi-agent architecture.

Zero-Code-Upload Security Model​

When you run an analysis, your proprietary source code is never uploaded to an Azuma server.

Instead of uploading files to a central Azuma server for parsing, the Standalone Client acts as a local orchestrator. It dispatches API calls directly to your configured Large Language Model (LLM) provider (like Anthropic, OpenAI, or a private on-premise endpoint) using your own API keys. The LLM provider processes the data ephemerally, and the parsed results are returned directly to your local .nori directory.

Where the code snippets are evaluated depends on the model you choose: a cloud LLM sees them under your own account and API key (never through Azuma), while a local or on-premise model keeps them entirely within your own infrastructure.

The Azuma backend receives strictly filtered telemetry (scores, metrics, and completion statuses), but it never ingests or proxies your source files.

Read-Only Analysis​

nori reads the code it analyses. It never writes to it.

Every agent CLI transport — Claude, Codex, Cursor, GitHub Copilot, and Antigravity — is launched read-only, so the agent can open, search, and reason about your repository but cannot create, modify, or delete a file in it. Claude, Codex, Cursor and GitHub Copilot run in that tool's own read-only mode. Antigravity, whose plan mode no longer restricts anything since Antigravity CLI 1.4, runs under nori's own check instead: the Antigravity CLI asks nori before every action the agent takes, and nori allows only reading the folders it granted. Either way the restriction is enforced by the CLI, not by convention or by a prompt asking the model to behave.

Because a permission mode can be misconfigured, revoked, or changed by a tool update, nori does not simply trust it. Before each run, nori verifies the restriction with a harmless test write. If that write succeeds — meaning the read-only mode is not actually in effect — the run stops before any analysis begins, with a message explaining what was expected and what happened. A run that starts has had its read-only guarantee checked, not assumed.

The only directory nori writes to is its own data directory (the .nori workspace you chose during project setup), which holds configuration, the generated source index, run results, and reports. Your source tree is left byte-for-byte unchanged, which is what makes it safe to point nori at a production checkout, a release tag, or a customer's repository under audit.

nori also never builds, restores, installs, or executes anything from the code it analyses. Every conclusion comes from reading. Where that limits what can be established — a property that could only be confirmed by running the code — nori reports it as could not check, never as a failure.

The Two-Phase Pipeline​

To efficiently evaluate a codebase without exceeding LLM context windows or incurring massive token costs, nori splits the process into two phases:

1. The Source Index Phase (Build the source index)​

Before evaluating compliance rules, nori builds the source index (called the "Wiki" in versions before 1.26.0). This phase scans your directory and builds highly compressed, localized Markdown indices summarizing your architecture, dependencies, and file structures.

Performance Note: Nori applies a context-compression pass during this phase, stripping filler prose from the indices before they are sent to the model in the next phase. How much that removes depends on what the source index holds — prose compresses, while tables, paths and code barely do — so nori measures each run and reports the saving it actually achieved rather than promising a figure in advance.

2. The Evaluation Phase (Run analysis)​

Once the source index is built, the orchestrator begins evaluating the actual compliance policy (e.g., BSI TR-03161).

Rather than asking a single LLM to evaluate the entire standard, the orchestrator splits the work across multiple bounded sub-agents, each responsible for evaluating a specific subset of the policy's controls. These sub-agents are injected with the local source index context, allowing them to search for evidence precisely where it matters.

Analysis-Only Mode​

The two-phase pipeline described above is the default project mode (Discovery & Analysis). For teams who want faster, lighter runs — or whose codebase is small enough to evaluate directly — nori also offers an Analysis-Only mode.

In Analysis-Only mode, nori skips the Source Index Phase entirely: no source index is built. The orchestrator's evaluation sub-agents run the same bounded, per-control split, but they search the repository directly on demand instead of reading from a pre-built source index.

This trades the up-front source index build (and its one-time token cost) for evaluation that reads the source live. It suits smaller repositories, quick re-checks, and situations where you don't want to build or maintain a source index. The source index UI is hidden for these projects; however, any per-document evidence you supply — the document index built from uploaded specifications and design documents — is still indexed and injected into the evaluators, so that context continues to inform the analysis.

The Zero-Code-Upload guarantees are identical in both modes: whether or not a source index is built, your source is only ever seen by your own configured LLM provider, and the Azuma backend still receives filtered telemetry only.

Final Summarization​

After all sub-agents finish evaluating their assigned controls, their findings are passed to a final summarization step.

This step has one job: aggregate the raw JSON output from the sub-agents into human-readable executive summaries. Crucially, it operates under a strict directive guaranteeing that it must never drop, mask, or summarize away any Critical Failures or Warnings found by the sub-agents. This ensures absolute audit fidelity.