Skip to main content

DSSE Signing: Cryptographic Proof of AI Governance Decisions

DSSE Signing: Cryptographic Proof of AI Governance Decisions

Security teams do not usually get challenged on whether they can export a file. They get challenged on whether the file can be trusted. That is the difference between ordinary operational logging and cryptographic evidence. In Keeptrusts, the strongest documented answer lives in Regulated Execution, where compliance evidence can be exported as JSON with DSSE envelopes and SHA-256 digest chains. That matters because AI governance is often reviewed by people who were not present when the decisions were made.

Use this page when​

  • You need to explain why signed evidence is stronger than screenshots, CSVs, or narrative summaries.
  • You are preparing audit or incident evidence for a regulated AI workflow.
  • You want to connect runtime decisions in kt events to a tamper-evident export story.

Primary audience​

  • Primary: Security engineers, compliance teams, and technical auditors
  • Secondary: Platform engineers building regulated AI workflows

The problem​

Operational logs are necessary, but they are not the same as proof. A CSV can be copied, transformed, or partially filtered before anyone else sees it. A dashboard screenshot can show a conclusion without showing the underlying data. Even a JSON export is only as trustworthy as the handoff process around it. That is not a criticism of logging. It is a reminder that evidence for regulated environments needs a stronger integrity story.

AI systems make that challenge sharper because the review audience is often external to the engineering team. A compliance reviewer may want proof that a deletion occurred, that a retention rule was applied, or that an approval decision was recorded. An incident lead may need evidence that a workflow remained inside a regulated deployment profile. In both cases, “trust us, this export came from the right place” is a weak answer.

The solution​

Use signed evidence as the high-assurance layer on top of the event stream.

Regulated Execution documents four evidence types that matter for AI governance reviews: deletion receipts, execution manifests, retention attestations, and approval decision records. The exported JSON format includes DSSE envelopes and SHA-256 digest chains. That gives auditors and reviewers a concrete integrity model rather than a purely operational one.

This does not replace kt events. It complements it. Events tell you what the governed platform observed and decided. DSSE-signed evidence packages give you a stronger artifact for formal reviews, especially when the workflow includes regulated processing, approval controls, or retention-sensitive handling.

The practical architecture is simple. Keep the ordinary event stream available for day-to-day operations, then use signed evidence when the review requires tamper-evident proof. That preserves speed for operators and rigor for auditors.

Implementation​

The regulated-execution block is the first step because the DSSE evidence story belongs to that feature set, not to a generic policy-local flag.

regulated_execution:
  deployment_profile: sovereign_region
  workload_class: regulated
  fail_mode: closed
  local_only_processing: false
  cross_border_policy: deny

pack:
  name: dsse-governance-proof
  version: 1.0.0
  enabled: true

policies:
  chain:
    - pii-detector
    - data-routing-policy
    - audit-logger

policy:
  pii-detector:
    action: redact
    redaction:
      marker_format: label
      include_metadata: true

  data-routing-policy:
    require_zero_data_retention: true
    require_no_training: true
    max_retention_days: 0
    on_no_compliant_provider: block

  audit-logger: {}

Then create and retrieve an evidence artifact through the export workflow:

kt export-jobs create \
  --from "2026-05-01T00:00:00Z" \
  --to "2026-05-31T23:59:59Z" \
  --format json

kt export-jobs get --id exp_abc123
kt export-jobs download --id exp_abc123 --output regulated-evidence.json
kt events tail --since 24h --json

This sequence matters for two reasons. First, it gives you the ordinary decision history and the higher-assurance evidence artifact in the same review window. Second, it keeps the chain of custody explicit. You know what time window was selected, which job created the export, and which artifact was downloaded.

Avoid inventing extra verification steps that are not documented. The right claim is that Keeptrusts exports signed evidence with DSSE envelopes and SHA-256 digest chains for regulated execution workflows. That is already strong. It does not need embellishment.

Results and impact​

The immediate impact is better review quality. Instead of debating whether an export was altered after download, the team can hand off a signed evidence pack designed for independent verification. That lowers friction with auditors and reduces the number of bespoke explanations security teams have to write.

The second impact is cleaner separation of responsibilities. Operators can keep using the event stream for investigation and monitoring. Compliance and governance teams can escalate to the signed evidence artifact when the review moves from operational questions to evidentiary questions. That split is healthy because it keeps neither audience waiting for the other.

Key takeaways​

  • DSSE signing is the cryptographic evidence layer documented under Regulated Execution.
  • Use kt events for operational visibility and signed evidence packs for formal proof.
  • Evidence types include deletion receipts, execution manifests, retention attestations, and approval decision records.
  • Strong evidence comes from explicit export workflows and preserved review windows, not from ad hoc screenshots.
  • Do not overclaim undocumented verification features when the documented DSSE story is already sufficient.

Next steps​