Integrations

GitHub Actions

Gate your CI pipeline on formal reasoning validity. insinuateai/prova-action@v1 calls the Prova API, writes a Step Summary, posts a PR comment, and fails the step if reasoning is INVALID -- all in a single YAML block.

What you get

+CI fails automatically on INVALID reasoning — nothing ships with broken logic
+Step Summary shows the full verdict table in every run
+PR comment posts certificate ID and link on every pull request
+All outputs (certificate_id, verdict, confidence_score, certificate_url) available to downstream steps
+Permanent audit trail tied to the git SHA for every AI decision
+Zero dependencies — runs on node20, no npm install needed

1. Add your API key

In your GitHub repo: Settings → Secrets and variables → Actions → add PROVA_API_KEY.

Get an API key from your Prova dashboard.

2. Basic workflow

Minimum viable setup. Replace steps.your-ai-step.outputs.reasoning with wherever your pipeline emits the reasoning chain.

yaml

name: Verify AI Reasoning

on: [push, pull_request]

jobs:
  prova:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Verify reasoning chain
        id: prova
        uses: insinuateai/prova-action@v1
        with:
          api_key: ${{ secrets.PROVA_API_KEY }}
          reasoning_chain: ${{ steps.your-ai-step.outputs.reasoning }}
          fail_on_invalid: true
          post_pr_comment: true
          github_token: ${{ secrets.GITHUB_TOKEN }}

3. Full pipeline with all options

yaml

name: AI Pipeline with Prova Gate

on:
  pull_request:
    branches: [main]

jobs:
  prova-gate:
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write  # required for PR comments

    steps:
      - uses: actions/checkout@v4

      # Your existing step that produces an AI reasoning chain
      - name: Run AI analysis
        id: ai
        run: |
          REASONING=$(python scripts/run_analysis.py)
          echo "reasoning=$REASONING" >> $GITHUB_OUTPUT

      # Drop in Prova — one step, zero config
      - name: Prova reasoning gate
        id: prova
        uses: insinuateai/prova-action@v1
        with:
          api_key: ${{ secrets.PROVA_API_KEY }}
          reasoning_chain: ${{ steps.ai.outputs.reasoning }}
          domain: financial              # optional: medical | legal | financial | code
          source_url: https://your-doc.example.com/report.pdf  # optional
          retain: true                   # store reasoning in certificate
          fail_on_invalid: true          # default: block on INVALID
          post_pr_comment: true          # default: comment on PRs
          github_token: ${{ secrets.GITHUB_TOKEN }}

      # Use the outputs in downstream steps
      - name: Deploy (only if VALID)
        run: |
          echo "Certificate: ${{ steps.prova.outputs.certificate_url }}"
          echo "Verdict: ${{ steps.prova.outputs.verdict }}"
          ./scripts/deploy.sh

Inputs

Input	Required	Default	Description
reasoning_chain	yes	—	The AI chain-of-thought text to verify
api_key	yes	—	Your Prova API key
fail_on_invalid	no	true	Fail the CI step on INVALID verdict
post_pr_comment	no	true	Post certificate summary as a PR comment
github_token	no	—	Required for PR comments (${{ secrets.GITHUB_TOKEN }})
domain	no	—	Domain hint: medical \| legal \| financial \| code \| general
source_url	no	—	URL of the source document
retain	no	true	Store reasoning text in the certificate

Outputs

Output	Description
certificate_id	The Prova certificate ID (e.g. PRV-2026-A3F2)
verdict	VALID or INVALID
confidence_score	Confidence score 0-100
certificate_url	Public URL of the full certificate

Common patterns

Soft gate (observe, never block)

Record certificates and get PR visibility without blocking the pipeline. Good for rolling out Prova incrementally.

yaml

# Soft gate: record certificate but never block the pipeline
- name: Prova reasoning certificate
  id: prova
  uses: insinuateai/prova-action@v1
  with:
    api_key: ${{ secrets.PROVA_API_KEY }}
    reasoning_chain: ${{ steps.ai.outputs.reasoning }}
    fail_on_invalid: false    # observe without blocking
    post_pr_comment: true
    github_token: ${{ secrets.GITHUB_TOKEN }}

Parallel verification across multiple chains

Use a matrix strategy when your pipeline produces several independent reasoning chains (e.g. underwriting + compliance + risk in parallel).

yaml

# Verify multiple reasoning chains in parallel
jobs:
  prova-gate:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        chain: [underwriting, compliance-check, risk-score]
    steps:
      - name: Verify ${{ matrix.chain }}
        uses: insinuateai/prova-action@v1
        with:
          api_key: ${{ secrets.PROVA_API_KEY }}
          reasoning_chain: ${{ steps.ai.outputs[matrix.chain] }}
          domain: financial

PR comment permissions

PR comments require permissions: pull-requests: write in your job. Add this at the job level:

yaml

jobs:
  prova-gate:
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write

If your org enforces read-only default permissions, set post_pr_comment: false and rely on the Step Summary instead.

Next steps

→API reference — direct API usage and structured input →Certificate guide — understanding verdicts and failure types →Verify independently — kernel-check a Lean 4 proof yourself →Other integrations — LangGraph, CrewAI, Python, Node.js