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.

CorpusObjectsTypesLicence of the content
AU.ISMInformation Security ManualAustralian Signals Directorate1,7311,150 Requirements · 581 RequirementSets1,150 controls; classification and Essential Eight baselines as SetsCC BY 4.0Open in the app
DE.BSIGrundschutz++ AnwenderkatalogBSI, Germany1,2891,000 Requirements · 289 RequirementSetsGerman prose, statement grammar and protection goals as facetsCC BY-SA 4.0Open in the app
US.CSFCybersecurity Framework 2.0NIST226185 Requirements · 41 RequirementSetsFunctions, categories and subcategories as nested SetsCC0 1.0Open in the app
US.IFA-GoodReadOSCAL example system (SSP, plan, results, POA&M)NIST, fictional content166 Components · 3 Implementations · 2 Findings · 2 Requirements · 2 Risks · 1 AssessmentThe lifecycle types: Component to Attestation, with two RisksCC0 1.0Open in the app
US.SP800-53SP 800-53 Rev 5.2.0 with the 800-53B baselinesNIST1,2211,196 Requirements · 25 RequirementSetsStatement-scoped parameters; four baselines as membership SetsCC0 1.0Open in the app

The example bundle of the handbook holds one object of every type, including a Risk, two Tailorings and two Checks: open the example bundle. A single-file reader 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
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
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
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
req-backup-1.jsonan invented example
{
  "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

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
import a catalogue into your bundle
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   How a check decides

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   How a pack works

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   Download it as one file

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
# for your user
cp -r jascon ~/.claude/skills/jascon
# or for one project
cp -r jascon .claude/skills/jascon