Repository navigation
DRAFT Article: GovOps Compliance Plumbing
How Gemara, complyctl, Ampel, and OSCAL Compass can connect organizational policy to technical evidence.
How does a GovOps capability record connect to compliance policies? And what tools can help preserve the provenance of the evidence behind a compliance assessment? To connect these dots, we need to understand the relationships between the documents, the software evaluators, and the evidence they produce.
In the GovOps Authorization Capability Catalog (ACC), a capability represents an action on a resource_type. For example, action POST on resource_type https://example.com/api.
Gemara’s capability model provides a structured way to describe capabilities and reference them from other governance artifacts. The GovOps ACC profile adds extra fields useful for governance like action, resource_type, risk, business impact, region, or custom metadata. Relationships among Gemara entities connect those capabilities back to organizational policies.
From Gemara’s perspective, policy is “a clearly-scoped set of rules based on an organization’s Risk Appetite.” Its policy document captures organizational concerns such as responsibility, accountability, applicability, imported controls, and assessment plans.
For example, a payment policy could name Treasury as responsible, the CFO as accountable, the Payment Service as in scope, and an on-demand assessment for the authorized-approvers requirement.
An executable authorization policy serves a different purpose: it determines whether a particular action on a resource is permitted. An assessment check then examines whether a system’s configuration, behavior, or evidence satisfies a requirement.
Connecting these layers takes work. Someone must establish that the authorization rules implement the intended control, that the assessment tests the relevant requirement, and that the resulting evidence covers the system and period under review.

A Gemara policy can import control catalogs. Individual controls can reference threats, and threats can reference capabilities.
First, let’s look at an illustrative Gemara YAML policy entity. This simplified example shows the relationships; it is not a complete, schema-validated document.
title: Payment Approval Policy
metadata:
id: payment-approval
version: "1.0.0"
contacts:
responsible:
- name: Treasury Team
accountable:
- name: CFO
scope:
in:
technologies:
- Payment Service
imports:
catalogs:
- reference-id: treasury-controls
adherence:
assessment-plans:
- id: assess-payment-approval
requirement-id: authorized-approvers-only
frequency: on-demand
evaluation-methods:
- type: Behavioral
executor:
id: treasury-checker
type: SoftwareNow let’s look at an illustrative threat catalog excerpt, showing a threat-to-capability reference:
# Illustrative excerpt, not a complete document.
threats:
- id: unauthorized-payment
title: Unauthorized payment approval
description: An unauthorized actor approves a payment.
group: payment-threats
capabilities:
- reference-id: treasury-capabilities
entries:
- reference-id: payment-approveTogether, these references provide a path from organizational policy through controls and threats to the capabilities of the systems being governed.
OSCAL is a NIST-led family of machine-readable formats for control-related information. Its models cover catalogs, profiles, implementation descriptions, assessment plans, assessment results, and remediation tracking.
This makes OSCAL useful at the boundary between technical assessment workflows and compliance systems. A receiving GRC platform can ingest supported OSCAL artifacts and use established mappings to relate results to framework obligations.
Those mappings require engineering and review. A Gemara capability catalog does not automatically become an OSCAL assessment result. A passing technical check does not automatically establish compliance with SOC 2 or the EU AI Act. Teams must define the applicable obligations, map requirements, preserve evidence references, and identify the limits of each assessment.
So how do we get from Gemara capabilities to compliance reports? Open-source projects provide much of the plumbing, but their responsibilities differ.
| Tool | Main role | Question it helps answer |
|---|---|---|
| Gemara | Models policies, controls, threats, capabilities, and their relationships | “How does this capability relate to our organizational requirements?” |
| complyctl | Retrieves policies, coordinates evaluators, and assembles reports | “How do we run the assessment and report its findings?” |
| Ampel | Evaluates attestations against policy checks and can produce attested results | “Does this evidence satisfy these checks?” |
| OSCAL Trestle | Authors, validates, and manages OSCAL documents | “How do we represent and maintain our compliance documents?” |
| OSCAL Compass | Brings together tools for OSCAL authoring, assessment-engine integration, and normalization of results | “How do we connect technical assessment results to structured compliance workflows?” |
The first stop after Gemara YAML file creation is complyctl which coordinates compliance assessments: it retrieves Gemara policy documents, delegates technical checks to provider plugins, and collects their results into reports. A provider plugin is an adapter between complyctl and an assessment tool. For example, complyctl can invoke OPA through a plugin that uses Conftest to evaluate configuration files against Rego rules. A rule could flag Kubernetes workloads configured to run privileged containers, and the plugin would return that finding to complyctl for inclusion in the compliance report. The Rego checks are authored separately and mapped to compliance requirements; OPA does not execute the Gemara policy document.
Ampel evaluates evidence, such as attestations, against executable checks. Gemara’s YAML policy documents describe organizational requirements and assessment plans; Ampel’s separate policy files specify how evidence should be tested. Those checks must be authored and mapped to the relevant requirements. In a complyctl workflow, an Ampel provider plugin passes the assessment work to Ampel and returns its findings to complyctl for reporting. complyctl coordinates the assessment; Ampel evaluates the evidence.
Within OSCAL Compass, Trestle helps teams author, validate, and maintain OSCAL artifacts. Another component, Compliance to Policy (C2P), provides integrations with policy validation or enforcement engines and normalizes their results. These integrations can connect technical findings to compliance workflows, but any additional GovOps adapters would still need to be implemented.
These documents connect different stages of an assessment. Gemara describes the organizational requirements and what must be assessed. Ampel policies define executable checks over the supporting evidence. OSCAL provides structured formats for exchanging control information, assessment plans, and findings with compliance systems. Connecting them requires explicit mappings from each requirement to its checks, evidence, and results; changing the file format alone does not create those relationships.
For the proposed GovOps TRACE Profile, runtime records would correlate authorization decisions, attempted invocations, and observed effects with the ACC through capability_id.
A proposed GovOps provider plugin for complyctl would assess TRACE evidence against defined requirements. For example, it could check whether each observed payment approval has a corresponding permit decision and invocation record, then return findings—such as missing records or execution following a denial—to complyctl for reporting. Each check would be mapped to the requirement it assesses. The records’ capability_id would connect the findings to the ACC, whose references link capabilities to threats, controls, and organizational policies. This plugin and its assessment checks would need to be implemented.
The assessment could then be exported into the receiving compliance workflow while preserving requirement identifiers, catalog versions, evaluator versions, target scope, timestamps, and evidence provenance. Missing or stale evidence should remain visible as an assessment limitation.
Preserving a cryptographic chain of custody requires more than producing a report. The integration must retain signed source records or durable references to them, record verification results, and make transformations traceable back to their inputs. An OSCAL export is a way to represent assessment information; the supporting evidence and its verification history still need to remain available.
Governors—boards and executives accountable for organizational risk—need to know that controls are supported by current evidence. This architecture automates that accountability.
How to begin this journey? Start with one policy, one control, one threat, one capability, and one traceable result that a compliance team can inspect.