# Controls, posture and hand-off reports

> Map a scan to OWASP LLM and Agentic, MITRE ATLAS, NIST AI RMF, ISO 42001, the EU AI Act, NIST 800-53 and ISO 27001, pre-fill a posture assessment from the command line, read what an AI vendor says publicly, and write a self-contained hand-off report. All of it runs locally.

Source: https://keryn.dev/docs/guides/controls-and-posture/

## Goal

Turn a scan result into what a reviewer asks for: which controls in the frameworks they work in have findings against them, which have none, how the product's AI security posture reads, and a document to hand over.

## Before you start

- The Keryn CLI ([install](https://keryn.dev/docs/start/install/)), or [Keryn Web](https://keryn.dev/docs/guides/web-app/) for the controls view, the hand-off reports and vendor trust. The posture assessment is a CLI feature for now; see [step 2](#2-pre-fill-a-posture-assessment).
- A saved scan result: `keryn scan . --json result.json`.
- These commands read the file and make no network request. The mappings are references, not claims; see the end of this page.

## 1. Map the findings to controls

```sh
keryn scan . --json result.json --quiet || true
keryn controls result.json | head -4
```

```text
10 of 16 findings map to a control category

OWASP Top 10 for LLM Applications 2025: 6 with findings, 4 clear, 0 not tested
  LLM01          findings  2    Prompt Injection
```

Each finding's rule carries an OWASP LLM or OWASP Agentic category. Keryn's crosswalk carries that category on to the other frameworks, so one finding can appear under several controls. The frameworks are OWASP LLM 2025, OWASP Agentic 2026, MITRE ATLAS, NIST AI RMF 1.0, ISO/IEC 42001, the EU AI Act, NIST SP 800-53, ISO/IEC 27001 and CWE. Every control is in one of three states:

| State | Meaning |
|---|---|
| findings | at least one finding maps to it |
| clear | Keryn's rules for it ran and found nothing |
| not tested | none of Keryn's rules cover it, so silence says nothing |

`--framework <id>` lists every control of one framework (`owasp-llm`, `owasp-agentic`, `mitre-atlas`, `nist-ai-rmf`, `iso-42001`, `eu-ai-act`, `nist-800-53`, `iso-27001`, `cwe`), and `--json` writes the same data for a script. In Keryn Web the same view is **Controls** in the results.

![The Controls view of Keryn Web for the help-desk scan: the OWASP LLM categories with findings, and tabs for the other frameworks from OWASP Agentic to CWE.](https://keryn.dev/screens/web-controls-1280-light.webp)

*Controls in Keryn Web: the OWASP LLM categories of the help-desk scan, with a tab for each of the other frameworks. Taken from keryn.app main-DIcUUbkq.js.*

## 2. Pre-fill a posture assessment

> **Note**
> In Keryn Web, open **Settings → Posture** after a scan: the assessment is pre-filled from the scan result, as `keryn posture` does on the command line below. The posture hand-off report in step 3 is unchanged.

```sh
keryn posture result.json | head -1
```

```text
Context from the scan: usesAgents=false, usesExternalTools=false, usesGenerativeAI=true, usesRag=false
```

The posture assessment is a questionnaire of 12 domains, 36 capabilities and 132 questions (Quick is 36 questions, Standard 72, Full all 132), with maturity bands and a 7, 30, 60 and 90-day roadmap. The scan fills in what it can see. For each question it prints one of two things with the reason:

- `suggest N`: the scan found evidence that supports a score of N (for example, an AI-BOM exists).
- `at most N`: open findings cap what you can honestly claim (for example, open tool-misuse findings cap "Are prompt-influenced tool calls mediated?").

It never answers for you. The rest of the questions are yours. Without the web view, answer them in a file and give it to the report command: `--answers <posture.json>` takes `{"mode": "quick", "context": {}, "answers": {}}`, where `mode` is `quick`, `standard` or `full`, `context` overrides what the scan inferred, and `answers` maps a question id to a score from 0 to 5. The report applies your answers over the scan's suggestions.

```sh
keryn handoff posture result.json -o posture.html
```

The posture report holds the score, the domains, the gaps and the roadmap. When the folder has [release-decision](https://keryn.dev/docs/guides/release-decisions/) files, open Holds go into the first 7 days of the roadmap and accepted risks that end within 30 days into the first 30; `policy.yml` `release.expiring_days` sets that window.

## 3. Write a hand-off report

```sh
keryn handoff gaps result.json -o gaps.html
```

```text
keryn: gaps report -> gaps.html
```

`handoff` writes one self-contained HTML file: no script, nothing loaded from elsewhere, readable offline and printable to PDF from a browser.

| Kind | What it holds |
|---|---|
| `gaps` | control gap assessment, framework by framework, control by control |
| `evidence` | scope, AI-BOM, controls and findings with quoted evidence and hashes |
| `tools` | agent tool permission matrix: what each tool can do, whether it is gated, and the routes that reach a model |
| `posture` | score, domains, gaps and roadmap; `--answers <posture.json>` adds your answers over the scan's suggestions |

In Keryn Web the first three are under the **Reports** menu in the scan results. The posture report needs answers, so in the released app it is a CLI report. When the folder has `.keryn/decisions.yml` or `.keryn/scope.yml`, the reports also read them: the control gap assessment shows the scope, the coverage you declared and the accepted gaps (who, until when), and the evidence pack adds the release decision and, with `-o`, an OpenVEX file written beside it. `--root <dir>` says which folder to read; without those files a report is what it was before.

## 4. Read what an AI vendor says about your data

In the AI-BOM view of Keryn Web, a component whose vendor Keryn knows has a **Vendor trust** line that opens a compact card: whether the vendor says it trains on customer data, its data retention, whether zero data retention is offered, the attestations it states, and whether it publishes a subprocessor list, a DPA, a `security.txt` and an AI policy. Each row quotes the sentence it came from and links to that page, and the card says the date the pages were read.

The cards come from a catalogue shipped with the app, built offline from each vendor's own public pages (220 vendors, read on 2026-11-06). Opening a card makes no request. "Unclear" and "Not found" mean the pages Keryn read did not say; they do not mean the vendor does not. The text is pattern-matched, so verify it at the source link before you rely on it. The browser extension and the VS Code extension show the same cards.

## What you just proved

Every line in these outputs traces back to a finding with a rule id, a file and a line, through a mapping you can read. The files are plain: the report has no script and requests nothing, so it can be attached to a ticket or handed to an auditor as it is. The [evidence bundle](https://keryn.dev/docs/guides/evidence/) is the tamper-evident companion if the recipient needs to verify the findings themselves.

## What this is not

Mappings are Keryn's reading of how a finding category relates to a control, offered as a reference. A control marked "clear" means Keryn's rules for it found nothing in the code it read, not that you meet it. Control labels are Keryn's own short paraphrases; the frameworks' own text is the authority. Nothing here is a conformance, certification or compliance claim.

## Next

- See an agent's trust boundaries and chains: [the Trust Canvas](https://keryn.dev/docs/guides/trust-canvas/).
- Group a console summary by one framework: `--summary-by owasp_llm` on [`keryn scan`](https://keryn.dev/docs/reference/cli/scan/); the [taxonomies](https://keryn.dev/taxonomies/) show rule coverage per entry.
- Verify findings independently: [evidence for auditors](https://keryn.dev/docs/guides/auditors/).
