Starting point
A consulting method, be it a supplier review, a risk assessment or a maturity check, is a consultancy's know-how. In practice it lives inside the software that implements it: the steps in the user interface, thresholds as constants in the code, checks sometimes in the browser and sometimes on the server. Anyone who wants to change the method, adapt it to a new standard or use it in a second tool has to read program code.
Three problems follow. Clients and auditors cannot see which version of the method a result was produced with. An AI cannot run the method unless someone describes its rules all over again, and nobody defines which data it may see while doing so. And the method cannot be separated from the clients' data, because both live in the same application. We wanted a format in which the method itself is the source: readable for the consultancy responsible for it, and executable for every program that implements it.
Solution
MethodPack describes a method in a YAML or JSON file: steps and questions, answer scales, formulas, rules whose findings are blockers, warnings or notes, reference catalogues, actions, sign-offs, AI tasks and outputs such as reports. A second file, the instance, holds the answers and results of a single assessment. It refers to the method by id, version and a digest of its content; the method file itself never holds client or personal data. So the method remains the consultancy's know-how, and every report names the version it was produced with.
The method checks itself. A validator applies 18 rules, from references to nothing, cycles in formulas and missing translations to an AI task that would see personal data. Test cases live in the method file, and two independently written engines, one in Python and one in TypeScript, must give the same result in every test case. Sign-offs are rules, not conventions: roles, the four-eyes principle and blocking findings are part of the method, and every application on the runtime enforces them in the same way. A change after sign-off sets the step to "changed"; reports keep printing the approved values and mark them.
AI tasks are fenced proposals. Each one states its purpose, the fields the model may see, the format of the answer and who confirms it. The runtime never calls a model itself: it builds the request, leaves personal fields out or replaces them with placeholders, and records a digest of the input. A proposal becomes an answer only through a person, and a proposal whose input has changed since cannot be accepted any more, only rejected.
Licensed catalogues stay with the licence holder: the method names only the keys, and the entries come at run time from a catalogue file, also converted from OSCAL or CSV, which the instance pins but never contains. A control library and separate mapping files count a control answered once as covered or partly covered for the requirements of other methods. A new version of a method checks that its version bump fits its changes, and a running assessment moves to the new version after a dry run, with a migration for renamed questions and changed answers.
The format comes with a reference app that opens a method file in the browser and takes an assessment with four-eyes sign-off through to the report, in German and English and without a server: the data stays in the browser and leaves it only as an exported instance file. Our GRC platform uses the same runtime.
- Method and assessment kept apart: the instance pins the method version by digest
- 18 checks and test cases in the method file, two independent engines with the same result
- Roles, four-eyes principle and blockers as part of the method, enforced the same way in every application
- AI tasks with a purpose, permitted inputs and confirmation by a person; personal fields stay out
- Catalogues by key, entries from a catalogue file, also from OSCAL or CSV
- Answer once, count for several methods: mapping files between controls and requirements
- Versions with a check of the version bump, a dry run and migration
A look inside the product
Recreated view with sample data.
Result
MethodPack is at draft 0.1 of its specification and not yet published. The specification, four JSON Schemas, the validator, the TypeScript runtime and the reference app were built in September and October 2026; the first version, from the specification to the reference app in the browser, took four days. Every change passes an automated gate that covers both engines, their comparison and the app's browser tests.
The specification, schemas and tools are intended for publication under open licences. Signing of method files is planned; today the version number and the digest define which version applies. Our GRC platform is already built on the runtime, as its first application besides the reference app.
Three decisions carry the format: keeping the method apart from the clients' data, fixing every rule in the file rather than in the application, and admitting AI only as a proposal that a person confirms.
- Draft 0.1 of the specification, not yet published
- First version, from specification to reference app, in four days
- Intended for publication under open licences; signing planned
- Our GRC platform is built on the runtime