---
title: "Get started with JASCON"
description: "Open a national catalogue in the browser, run the reference validator, write a first requirement, import OSCAL, compute risk coverage and install the skill for coding agents. Each step takes minutes."
lang: en
url: https://jascon.net/start.html
---

Get started

# From a browser tab to a validated bundle

Seven steps, in the order most people take them. The first needs a browser. The second needs Python or a Windows machine. None needs an account, a server or a licence key.

## Open a catalogue you know

The app loads a bundle from a link and keeps it in your browser. Start with the framework you work with: the object browser builds its filters from the data, so SP 800-53 offers families and baselines and Grundschutz++ offers modal verbs, protection goals and target objects.

| Corpus | Objects | Types | Licence of the content |  |
|---|---|---|---|---|
| AU.ISMInformation Security ManualAustralian Signals Directorate | 1,731 | 1,150 Requirements · 581 RequirementSets1,150 controls; classification and Essential Eight baselines as Sets | [CC BY 4.0](https://jascon.net/converted_examples/AU.ISM/SOURCE-LICENSE.md) | [Open in the app](https://jascon.net/app/index.html#load=../converted_examples/AU.ISM/ism-core-bundle/&tool=browse) |
| DE.BSIGrundschutz++ AnwenderkatalogBSI, Germany | 1,289 | 1,000 Requirements · 289 RequirementSetsGerman prose, statement grammar and protection goals as facets | [CC BY-SA 4.0](https://jascon.net/converted_examples/DE.BSI/SOURCE-LICENSE.md) | [Open in the app](https://jascon.net/app/index.html#load=../converted_examples/DE.BSI/bsi-core-bundle/&tool=browse) |
| US.CSFCybersecurity Framework 2.0NIST | 226 | 185 Requirements · 41 RequirementSetsFunctions, categories and subcategories as nested Sets | [CC0 1.0](https://jascon.net/converted_examples/US.CSF/SOURCE-LICENSE.md) | [Open in the app](https://jascon.net/app/index.html#load=../converted_examples/US.CSF/csf-core-bundle/&tool=browse) |
| US.IFA-GoodReadOSCAL example system (SSP, plan, results, POA&M)NIST, fictional content | 16 | 6 Components · 3 Implementations · 2 Findings · 2 Requirements · 2 Risks · 1 AssessmentThe lifecycle types: Component to Attestation, with two Risks | [CC0 1.0](https://jascon.net/converted_examples/US.IFA-GoodRead/SOURCE-LICENSE.md) | [Open in the app](https://jascon.net/app/index.html#load=../converted_examples/US.IFA-GoodRead/ifa-core-bundle/&tool=assess) |
| US.SP800-53SP 800-53 Rev 5.2.0 with the 800-53B baselinesNIST | 1,221 | 1,196 Requirements · 25 RequirementSetsStatement-scoped parameters; four baselines as membership Sets | [CC0 1.0](https://jascon.net/converted_examples/US.SP800-53/SOURCE-LICENSE.md) | [Open in the app](https://jascon.net/app/index.html#load=../converted_examples/US.SP800-53/sp800-53-core-bundle/&tool=browse) |

The example bundle of the handbook holds one object of every type, including a Risk, two Tailorings and two Checks: [open the example bundle](https://jascon.net/app/index.html#load=../jascon/examples/&tool=browse). A [single-file reader](https://jascon.net/reader/index.html) without a folder around it exists as well; download it and drop a bundle folder on it.

## Run the reference validator

The validator runs the 822 conformance vectors, then re-verifies every object of the shipped bundles with both digests. The last line reads `ALL GREEN` or lists each failure with its rule and its reason.

Pass one or more bundle folders to validate your own content. `--require-risk-basis` turns a selected requirement without a justifying risk into a failure.

On Windows the PowerShell twin does the same on PowerShell 5.1 with nothing installed. It takes minutes where Python takes seconds.

*Python, with uv*

```sh
git clone https://github.com/christoph-puppe/JASCON.git
cd JASCON
uv run --no-project --with jsonschema python jascon/scripts/validate_core.py
```

*Python, with pip*

```sh
pip install jsonschema
python jascon/scripts/validate_core.py
# your own bundle:
python jascon/scripts/validate_core.py path/to/your-bundle
```

*Windows PowerShell 5.1, no install*

```sh
powershell -ExecutionPolicy Bypass -File jascon\scripts\validate_core.ps1
```

## Write a first requirement

Choose a prefix under a domain you control and keep it. Identifiers are compared as strings and never fetched, so the address does not have to serve anything.

Split the text into statements where the binding force, the obligated party or a parameter changes. Declare each parameter with a type and refer to it in the prose with `{param:name}`.

The Browse page of the app has a form for this under "Write requirements and sets". It declares the parameters it finds in the prose. The Home page exports the working set as a bundle with a manifest and both digests per object.

[Handbook, chapter 4: writing requirements](https://github.com/christoph-puppe/JASCON/blob/main/jascon/references/ch04-writing-requirements.md)

*req-backup-1.json — an invented example*

```json
{
  "id": "https://grc.your.example/req/BACKUP-1",
  "version": "2026-11",
  "label": "BACKUP-1",
  "lifecycle": "active",
  "statements": [
    { "id": "s1",
      "modality": "must",
      "obligated-parties": ["https://grc.your.example/party/operations"],
      "parameters": [
        { "name": "restore-interval", "type": "duration" }
      ],
      "prose": {
        "en": "A restore from backup is tested at least every {param:restore-interval}.",
        "de": "Eine Wiederherstellung aus dem Backup wird mindestens alle {param:restore-interval} getestet."
      } }
  ]
}
```

## Bring your OSCAL, and take it back out

The Import page of the app reads an OSCAL catalogue or profile and reports every rule it applied. Rule sets exist for Grundschutz++, SP 800-53 and CIS Benchmarks; a catalogue of another shape goes through the generic rules, which keep what the kernel has no field for in a facet under your namespace and drop nothing without a line in the report. For batch work the repository holds eleven converters in Python, one per measured corpus, on a shared library.

In the other direction, `export_oscal.py` writes OSCAL 1.2.2 catalogues. The exports of the shipped bundles lie beside them under `converted_examples/*/oscal-export/`. What OSCAL has no construct for (modality, obligated parties, overlapping membership) travels in namespaced props and returns on import.

[Open the Import page](https://jascon.net/app/index.html#import)

## Add risks and compute the coverage

Load a catalogue, select a baseline with a Tailoring, and write the risks that justify the selection on the Risk page. The Coverage view lists every selected requirement that no assessed risk names.

Two prototype risk catalogues help with the first pass: 24 typical risks of office IT and 23 of an industrial plant, in English and German, each with suggested SP 800-53 controls. Import copies an entry into a Risk of your own; the decision stays yours.

[The risk catalogues and their limits](https://github.com/christoph-puppe/JASCON/blob/main/risk-catalogs/README.md)

*import a catalogue into your bundle*

```sh
python3 risk-catalogs/tools/risk_catalog.py import risk-catalogs/office-it \
    --bundle path/to/your-bundle \
    --org https://grc.your.example \
    --owner https://grc.your.example/party/ciso \
    --out path/to/risks
```

## Write a machine check

For a technical rule, the Checks page of the app writes a Check (kernel 2.0.0, release candidate): the facts a collector reports, the comparisons that decide, and the collector code in bash, sh, Python, PowerShell, Ansible or as an HTTP request. A language model can draft checks, one rule at a time or for every automated rule of a CIS import, once you enter a key. Each draft is judged by the kernel rules and a read-only lint, and you decide what is saved. The app does not run collectors.

[Open the Checks page on the example](https://jascon.net/app/index.html#load=../jascon/examples/&tool=checks) [How a check decides](https://jascon.net/checks.html)

## Take in a vendor's advice

An advice pack is a file a vendor publishes: Components with recommendations for named requirements (kernel 2.0.0, release candidate). The Home page of the app shows what a pack holds before anything is written, says whether its publisher is claimed, attested or proven, and prints a receipt after the import. On the Implement page you make the product a member of your system and adopt a recommendation as your own edge. The same file a second time writes nothing.

The worked pack is fictional and signed with a public test key. No vendor has published a pack yet.

[Preview the worked pack in the app](https://jascon.net/app/index.html#load=../jascon/example-packs/dbvendor-server-7-advice/) [How a pack works](https://jascon.net/model.html#advice)

### For vendors: write a pack

The pack builder is one HTML file that runs offline. You describe your product and each recommendation in a form; the page checks the pack with the same rules a customer's import runs, signs the release with your Ed25519 key or prepares the bytes for openssl or your signing service, and writes the ZIP. With the catalogue loaded, it offers the clauses and parameters of each requirement and checks every suggested value. An OSCAL component definition you already have is imported as a draft, with a report of what it could not place.

[Open the pack builder](https://jascon.net/pack-builder/index.html) [Download it as one file](https://jascon.net/pack-builder/index.html)

## Work with a coding agent

The folder `jascon/` is a skill for Claude: the handbook as fourteen numbered requirements, the kernel schema, the conformance vectors, the converters and a worked example bundle. An agent that has it writes objects against the schema and runs the validator on its own output.

The division of labour is the one the app uses: a model drafts, the kernel rules decide, a person accepts.

*install the skill*

```sh
# for your user
cp -r jascon ~/.claude/skills/jascon
# or for one project
cp -r jascon .claude/skills/jascon
```

Reading paths

## Chapter 2 first, then by chair

The handbook has fifteen chapters and seven appendices. Everyone reads chapter 2, which takes an hour. After that the paths part.

[Chapters 3 to 8, then 14 You publish a framework Identity and namespaces, statements, Sets and baselines, tailoring, facets, mappings. Then the migration playbooks, when the catalogue is real.](https://github.com/christoph-puppe/JASCON/blob/main/jascon/references/ch03-identity-versions-lifecycle.md) [Chapters 3, 12, 13, 11 You build a tool Identity for the mental model, then the validator chapter and safe consumption. Integrity before anything touches a signature.](https://github.com/christoph-puppe/JASCON/blob/main/jascon/references/ch12-building-a-validator.md) [Chapters 9, 10, 11, 15 You operate, assess or buy Systems and inheritance, assessment and deviations, what a signature proves, and what a conformance claim entitles you to demand.](https://github.com/christoph-puppe/JASCON/blob/main/jascon/references/ch09-systems-components-inheritance.md)

Reference: [the shapes, field by field](https://github.com/christoph-puppe/JASCON/blob/main/jascon/references/appendix-a-shapes.md) · [the kernel schema](https://github.com/christoph-puppe/JASCON/blob/main/jascon/schemas/jascon-2.0.0.schema.json) · [objections and answers](https://github.com/christoph-puppe/JASCON/blob/main/jascon/references/appendix-f-objections.md) · [glossary](https://github.com/christoph-puppe/JASCON/blob/main/jascon/references/appendix-g-glossary.md)
