# Capabilities and availability

> What the current Keryn browser build can do, which capabilities need another host, and what remains planned.

Source: https://keryn.dev/docs/concepts/capabilities/

Keryn connects technical observations to evidence, attack paths and security decisions. A finding is a claim to investigate; its proof level, source, coverage and validation determine what you can conclude. [Evaluation results](https://keryn.dev/evals/) show the measured limits of individual engines and comparisons.

Keryn is in pre-release. [Keryn Web](https://keryn.app) is the one surface available to everyone today. The 0.5.2 pre-release builds that design partners have (CLI, editor extensions, desktop app) are updated separately from it: a change to Keryn Web does not update them. Check [downloads](https://keryn.dev/download/) and the [changelog](https://keryn.dev/changelog/) for the build you use.

## Where each capability runs

The [product map](https://keryn.dev/docs/concepts/products/) groups these capabilities into products. This table is generated from Keryn's capability manifest, so it cannot say more than the product does. **Available** means in the latest release of that surface and named by evidence (a Keryn Web screen or a CLI command). **Preview** means it exists in pre-release builds or behind a flag. **Next release** means it is on the main branch and not in the latest release. **Planned** means it is not built. A dash means nothing is stated for that surface; it is not a plan. Hover a status to see its evidence.

| Capability | Keryn Web | CLI | Editors | Keryn Cloud |
|---|---|---|---|---|
| Source analysis (pattern rules, same-file and cross-file flows) | Available | Available | Preview | – |
| Committed secrets | Available | Available | – | – |
| Infrastructure and pipeline configuration rules: Terraform for AI services, GitHub Actions and GitLab CI (part of scan) | – | Available | – | – |
| AI-BOM: models, SDKs, agents, tools and MCP integrations (CycloneDX export) | Available | Available | – | – |
| Policy gates | – | Available | – | – |
| Dependencies from lockfiles: licences and advisory matching | Available | Available | – | – |
| Container images, dependency SBOMs and fix proposals | – | Next release | – | – |
| Supply-chain signals (malicious packages, typosquats, install scripts) | – | Next release | – | – |
| Agent files, skills and MCP configuration | Available | Available | – | – |
| Binary and model-file evidence | Available | Available | – | – |
| Forge: analysis of compiled Java and .NET and other artifacts | Available | Next release | – | – |
| Trust graph and attack paths | – | Available | – | – |
| AI product security posture assessment | Available | Available | – | – |
| Recorded risk decisions and evidence export | Available | Available | – | – |
| Third-party scanner report import (findings, outputs and the gate) | Available | Available | – | – |
| Offline evidence import (ModelScan and Promptfoo results bound to an assessment; nothing is executed) | – | Next release | – | – |
| Model-proposed triage of findings (verdicts and summaries) | Available | Next release | – | – |
| AI attribution: AI tool use and AI-assisted commits per repository, developer and organisation | – | Next release | – | – |
| API Workbench (validated API test suites) | Available | Next release | – | – |
| Web testing against a URL (Cloud passive checks; the CLI scan is next release) | – | Next release | – | Available |
| Hosted MCP endpoint (Keryn Cloud tools) | – | – | – | Available |
| Organization audit trail and export | – | – | – | Available |
| Organization data export and evidence deletion | – | – | – | Available |
| Enterprise single sign-on and directory provisioning | – | – | – | Preview |
| Application security posture management: snapshots, comparison, an ordered work list and an estate report | – | Next release | – | – |
| Continuous DAST and offensive validation | – | – | – | – |
| AI adversarial workbench | – | – | – | – |
| Runtime controls (IAST, RASP and request inspection inside the application: Keryn Runtime) | – | Next release | – | – |
| Supply-chain assurance (provenance and build integrity) | – | – | – | – |
| API security (inventory, drift, authorization analysis) | – | – | – | – |
| Cloud-native application context | – | – | – | – |
| AI and agent development security (policy-bound agent actions) | – | – | – | – |

## Current scanner and review capabilities

| Capability | What to expect | Qualification |
|---|---|---|
| Source analysis | Pattern rules, same-file flows and cross-file analysis where the runtime is available; proof levels and source locations accompany findings. | Unsupported rules, skipped files, partial scans and timeouts remain visible. Parsing a language does not imply complete semantic analysis. |
| JavaScript and TypeScript | Node security checks handle common call shapes and TypeScript runtime wrappers, including assertions, non-null expressions and `satisfies`. | Dynamic names, Unicode controls and reference-tool semantics have remaining differences. The [ESLint comparison](https://keryn.dev/evals/eslint-security/) retains those gaps. |
| Rails project context | Applicable checks use project dependency/version facts rather than assuming every Ruby project is Rails. | Unknown applicability means incomplete coverage. The [Brakeman comparison](https://keryn.dev/evals/brakeman/) is a location comparison, not equivalent Rails coverage. |
| AI-BOM and policy | Inventory models, SDKs, agents, tools and MCP integrations, inline prompts and prompt drift, and workflow authority (approval gaps, blast radius) on the agent surface; export CycloneDX and apply configured policy gates. The CLI, Keryn Web, the browser extension and VS Code run the same engines. | Inventory shows observed references; it does not establish runtime use or authorization. |
| Dependencies (SCA) | Lockfile inventory with each package's licence (SPDX), a licence policy, and advisory matching when the build has advisory data or the user explicitly requests an online check. Each vulnerable dependency carries an assessment (affected, not affected, or undecided with incomplete coverage); `keryn sca assess` runs the same assessment on a batch. | An offline scan without applicable advisory data cannot clear dependency risk. A known vulnerable version does not by itself prove reachable code. Licences are read from lockfiles, vendored metadata and SBOMs only, so many packages stay unknown; see [what SCA does not cover yet](https://keryn.dev/docs/guides/sca/#not-covered-yet). |
| Secrets | Committed credentials found with the gitleaks rule set; the value is redacted in every output. | A secret in a form no rule describes is not found; validity is not checked. See [secrets](https://keryn.dev/docs/guides/secrets/). |
| Supply-chain signals | Offline indicators for known malicious packages (six ecosystems), possible typosquats, risky install scripts, static install-hook content signals and dependency-confusion conditions; on main, see [supply-chain signals](https://keryn.dev/docs/reference/sca/supply-chain/). | Heuristics require investigation; package popularity or a spelling similarity is not proof of malicious intent. |
| SCA outputs and actions (next release) | Dependency SBOMs as CycloneDX 1.6 and SPDX 2.3, VEX read and written, CVSS v4 and v2 scoring, container images (`keryn sca image`) and dependency fix proposals (`keryn sca fix`). See the [SCA guide](https://keryn.dev/docs/guides/sca/). | On main, not in 0.5.2. Images need an advisory snapshot or `--online`; fixes cover direct dependencies and open a draft pull request only in a repository you own, only when asked. |
| Agent files and binary evidence | Inspect MCP/agent configuration and skill files, and supported binary formats encountered in the scan. | Static evidence does not reproduce tool execution. Binary format, available models and host support bound the result. |
| Graph and decisions | Trust Canvas, organization/repository review, controls mapping, the AI product security posture assessment (pre-filled from a scan, in Keryn Web under Settings, Posture, and as `keryn posture`), recorded risk decisions and evidence exports. Forge builds a semantic security graph from source, JVM, LLVM, .NET CIL, WebAssembly and native code, in Keryn Web (Scans → Artifact / Forge) and `keryn forge`. | A modeled attack path or accepted risk is distinct from a reproduced exploit or verified remediation. |
| Agent Inspector and API Workbench | Review agent/tool context and API test definitions through the application's developer tools. The API Workbench runs a validated suite from the browser against targets that allow the page's origin (CORS); the credential stays in memory and a receipt can be downloaded. `keryn api run` runs any target. | Active execution depends on an explicitly configured target, authority and capable runtime. Opening a workbench does not authorize a test. |
| Workbench commands (CLI) | Graph, adjudicate, remediate, verify, attest, OSCAL, evidence, triage, measure, n-day database and native SCA inventory, matching, requirements and assessment run through `keryn` from the CLI archives (pre-release builds for design partners), which ship `keryn-native` beside `keryn` (Linux x64 today; other platforms name the missing binary). `keryn dast nuclei` sends one bounded GET for a Nuclei public profile when the opt-in Nuclei module is built. | Commands that start containers, read a ledger or reach the network need the host and authority they name. |

Use [static analysis](https://keryn.dev/docs/guides/sast/), [software composition analysis](https://keryn.dev/docs/guides/sca/), [Trust Canvas](https://keryn.dev/docs/guides/trust-canvas/) and [coverage](https://keryn.dev/docs/concepts/coverage/) for the operating details. In Keryn Web, the **Developer tools** menu links this page and the evaluation results.

## Engine research and product availability

The eval catalog includes pattern compatibility, default-scan location comparisons, Forge source/compiled-code fixtures, labelled security benchmarks, passive web analysis, protocol tests and AI evaluation kernels. A passing engine fixture does not establish that its command is available in every app. Each suite retains its own engine revision, reference, corpus and denominator.

The [Python](https://keryn.dev/evals/forge-python/) and [TypeScript](https://keryn.dev/evals/forge-typescript/) Forge pages distinguish source-producer fixtures from compiler-export inputs. [Juliet](https://keryn.dev/evals/forge-juliet/) reports supported-CWE coverage separately from detection within its sampled cases. The AI evaluator comparisons do not claim a hosted red-team service or complete browser integration.

## Platform scope still being integrated

These are planned product capabilities and integration work, not a list of features already available in Keryn Web.

| Area | Intended capability and acceptance boundary |
|---|---|
| Application Security Posture Management (ASPM) | Application inventory and ownership, evidence correlation, exposure/reachability context, prioritization, assignment, risk acceptance and verified risk reduction. Snapshots, comparison, an ordered work list and an estate report are on main as CLI commands for the next release (see the table above); a web view, a hosted store and complete orchestration remain integration work. |
| Continuous DAST and offensive validation | Authorized, trigger-driven web/API testing after relevant changes, with authentication, role/object coverage, bounded execution, reproducible evidence and retests. Continuous Offensive Security Testing describes the operating process, not a new source scanner. |
| AI adversarial workbench | Interactive investigation of model behavior, multiagent workflows, tool chains, prompt injection and excessive agency. Reviewed episodes can become regression evaluations; this research workflow is distinct from HTTP-oriented DAST. |
| Runtime controls | IAST observations, RASP protection and WAF/WAAP enforcement with application identity, policy versions and feedback into evidence and remediation. The CLI side of Keryn Runtime is on main for the next release (see the table above). Observe-only validation, latency/error budgets, false-positive measurement and rollback precede blocking. |
| Supply-chain assurance | Broader package and artifact intelligence, SBOM/provenance verification, build/toolchain integrity and validated dependency remediation. |
| API security | Inventory and schema drift, authentication/authorization analysis, sensitive-data paths and business-logic validation across supported protocols. |
| Cloud-native context (CNAPP) | Deployment, identity, configuration, workload and exposure context linked to application evidence. Integration and host coverage must be demonstrated before claiming a complete cloud security platform. |
| AI/agent development security | Policy-bound actions across coding agents, skills, extensions, MCP servers, pipelines and running applications. Autonomous remediation requires explicit authority and independently verified outcomes. |

Shared evidence identities, schemas, content packs and bindings support these areas. Domain engines retain their specialized semantics. Unknown or missing evidence must not become a clean verdict, and a newly published page does not qualify a runtime.

## Availability depends on the application and host

| Application/runtime | Responsibilities and boundaries |
|---|---|
| Browser and static web app | Local file analysis and evidence review in WebAssembly; browser permissions and networking restrictions apply. Native process instrumentation and network interception need another host. |
| CLI and CI | Reproducible scans, policy gates, imports and exports on explicit inputs; native adapters require installed tools and deliberately configured access. |
| Desktop, including Tauri | Local workflows with a shared web UI and WASM analysis; any filesystem, process or network privilege is a separate host capability. |
| Editor and browser extensions | In-context feedback and permitted observations; VS Code scans with the full rule library and the same engines as the CLI. The site trust scan needs cross-origin requests, so it runs in the browser extension and the CLI, not the web page. Editor APIs, extension permissions and store availability determine the supported actions. |
| Servers, APIs, cloud and container workloads | Authorized jobs, tenant/identity boundaries, durable evidence and optional runtime collectors; deployment-specific qualification is required. |
| Mobile, embedded and other delivery surfaces | Planned profiles must declare their engines, interfaces, resource limits and independent validation before support is advertised. |

[Apps and integrations](https://keryn.dev/docs/guides/apps/) lists existing delivery surfaces. Evidence of success on one platform does not imply support on another.
