# Ai Claim Readiness Chackpoint (`filipmajchrzak/ai-claim-checkpoint`) Actor

Checks whether an AI workflow claim has sufficient bound evidence before promotion, publication, or handoff. Designed for professional and B2B AI workflows.

- **URL**: https://apify.com/filipmajchrzak/ai-claim-checkpoint.md
- **Developed by:** [Filip Majchrzak](https://apify.com/filipmajchrzak) (community)
- **Categories:** AI, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.49 / verified decision

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## AI Claim Readiness Checkpoint v0.5 (R7 paid beta)

AI Claim Readiness Checkpoint is a paid experimental Apify Actor for a soft, deterministic software-release evidence check. The paid public beta is intended and offered exclusively for businesses and professional users acting in a business or professional capacity; it is not intended as a consumer offering. A public Apify Actor can nevertheless be run by any Apify user, so this is buyer-visible contractual eligibility, not a technical consumer-access control. The v0.5/R7 hosted wrapper evaluates submitted test and review metadata against one fixed, versioned policy preset and produces a decision with a reproducible evidence bundle. Its evaluation engine remains the byte-frozen R6 runtime identified below.

The Actor does not use an AI model to judge whether a claim is true.

### Supported check

The public beta supports only `software_release_basic_v1`.

The preset requires:

- test evidence with zero failed tests;
- review evidence with `PASS` status;
- both observations no more than 30 days old at the supplied logical time;
- canonical JSON evidence with SHA-256 bindings.

The adapter does not use the wall clock, invent missing evidence, change submitted statuses, or repair failed evidence.

### Input

Use explicit UTC timestamps in `YYYY-MM-DDTHH:MM:SSZ` form. The default input is synthetic and is not a real release record.

```json
{
  "inputMode": "easy",
  "preset": "software_release_basic_v1",
  "claimId": "public-demo-synthetic-allow-001",
  "subject": "SYNTHETIC_PUBLIC_DEMO_NOT_A_REAL_RELEASE",
  "logicalTime": "2026-08-09T00:00:00Z",
  "tests": {
    "observedAt": "2026-08-08T12:00:00Z",
    "passed": 12,
    "failed": 0
  },
  "review": {
    "observedAt": "2026-08-08T13:00:00Z",
    "status": "PASS",
    "reviewer": "synthetic-public-demo"
  }
}
```

Set `tests` or `review` to `null` only when that evidence is unavailable.

Possible preset decisions are:

- `ALLOW` — the submitted evidence mechanically satisfied the fixed policy;
- `BLOCK` — submitted evidence contradicted a required control;
- `NEED_MORE_EVIDENCE` — required evidence was missing.

### Using the result

Do not rely on the Actor process status alone. Continue a workflow only when all of these are true:

- the Actor run succeeded;
- `OUTPUT.status` is `VERIFIED_GATE_DECISION`;
- `OUTPUT.decision` is `ALLOW`;
- `VERIFICATION.status` is `PASS`;
- `VERIFICATION.sidecar_verified` is `true`;
- `OUTPUT.decision` equals `VERIFICATION.decision`;
- `OUTPUT.bundleSha256` and `OUTPUT.bundleBytes` equal `VERIFICATION.bundle_sha256` and `VERIFICATION.bundle_bytes`.

Otherwise stop and inspect the reason codes or failure record.

The separately hash-pinned R6 verifier covers the replay bundle and its decision. It does not verify the public wrapper metadata added to `OUTPUT`.

#### Safe offline verification

Never execute `verify_bundle.py` merely because it is present in an untrusted replay bundle. First compare its SHA-256 with the v0.5/R7 trust anchor published alongside the Store release:

```text
5f9ad6f81ea07536582b69d2657962aafcf2c7613564680e7b546ff404350293
```

For example, after extracting the file but before executing it:

```sh
printf '%s  %s\n' '5f9ad6f81ea07536582b69d2657962aafcf2c7613564680e7b546ff404350293' 'verify_bundle.py' | sha256sum -c -
python verify_bundle.py evidence_bundle.zip --sidecar evidence_bundle.zip.sha256.txt --trusted-verifier-sha256 5f9ad6f81ea07536582b69d2657962aafcf2c7613564680e7b546ff404350293
```

Stop if the external hash check fails. The digest establishes byte binding to this published version, not the identity of whoever redistributed a bundle.

`ALLOW` does not prove that a release claim is true, safe, compliant, secure, competitive, production-ready, or sale-ready.

### What a paid evaluation buys

The paid unit is one completed, verified mechanical evaluation and its replayable output bundle. It is not a payment for an `ALLOW` result, certification, legal advice, security review, or a favorable outcome.

The configured Apify pay-per-event event is `verified-decision`. One event has the same price whether the verified decision is `ALLOW`, `BLOCK`, or `NEED_MORE_EVIDENCE`. After all verified result records have been committed, the Actor stores a durable `BILLING_ATTEMPT` record with state `RESERVED_NO_RETRY`, then reads back both the exact verified `OUTPUT` and the matching fence; only then may it make the single charged Dataset request. A later serialized restart or resurrection that sees either this matching fence or the already committed verified `OUTPUT` preserves the earlier result and makes no new Dataset or charge attempt. Malformed or rejected input, fail-closed outcomes, and unverified outcomes do not intentionally emit this custom event.

`BILLING_ATTEMPT` is a write-ahead no-retry fence, not a receipt: it does not prove that the request reached Apify, that a Dataset item was stored, or that a charge was accepted. If fence persistence or read-back is uncertain, or if the final Dataset-and-charge request returns an ambiguous error, the Actor delivers the verified Key-value store result but suppresses any retry. This can give the buyer a verified result without a confirmed paid event or Dataset row. The plain Key-value store fence protects serialized process re-entry; it is not claimed to be an atomic compare-and-create lock for hypothetical overlapping containers, and storage deletion can remove it. See [PAID\_BETA\_TERMS.md](PAID_BETA_TERMS.md) and [SUPPORT\_POLICY.md](SUPPORT_POLICY.md) for the billing-review procedure.

The public Apify Store offer is configured at **USD 0.49 per `verified-decision`**. `verified-decision` is the primary and only paid event, the minimum max cost per run is USD 0.49, separate synthetic `Actor start` and automatic Dataset-item paid events are absent, and platform-usage pass-through is disabled. A pre-publication 0.5.1 smoke run confirmed `chargedEventCounts.verified-decision = 1`. Buyers should rely on the price and billing terms displayed by Apify for each transaction.

### Outputs

Every verified outcome first commits the nine product artifacts listed below to
the Key-value store. A normal run that safely reaches the final charged Dataset
request also writes one Dataset item. The operational `BILLING_ATTEMPT` record
is conditional: it is written only after the verified `OUTPUT`, and it can be
absent when fence persistence is uncertain. It is intentionally not included in
`summary.artifactKeys` because it is a billing-control record rather than a
product artifact.

| Key | Content |
| --- | --- |
| `OUTPUT` | Machine-readable checkpoint summary |
| `RESULT` | Canonical OCOI decision |
| `AUDIT_RECORD` | Canonical audit record |
| `REPORT` | Human-readable HTML report |
| `EVIDENCE_BUNDLE` | Deterministic replay ZIP |
| `EVIDENCE_BUNDLE_SHA256` | Detached SHA-256 digest |
| `VERIFICATION` | Separately hash-pinned verifier result |
| `RUNTIME_BINDING` | Frozen runtime hashes |
| `VERIFIER_LICENSE` | MIT License for `verify_bundle.py` included in the replay bundle |
| `BILLING_ATTEMPT` | Conditional operational write-ahead `RESERVED_NO_RETRY` fence bound to the run, decision, verified `OUTPUT`, and replay bundle; not proof of billing success and not a member of `summary.artifactKeys` |

### Boundaries

This Actor is a soft checkpoint. It executes no release action and does not prevent a separately privileged workflow from bypassing its result.

Every public-beta verified output states:

- `actionExecuted=false`;
- `hardEnforcement=false`;
- `nonBypassable=false`;
- `truthVerified=false`;
- `experimentalBeta=true`;
- `privateEvaluationOnly=false`;
- `supportedPreset=software_release_basic_v1`.

Malformed, mixed, unknown, oversized, or inconsistent input fails closed. Runtime-byte changes, unexpected output files, digest disagreement, or verifier disagreement also fail closed.

### Data handling

Submit only synthetic or non-sensitive software-release metadata.

Do not submit credentials, secrets, API tokens, private keys, personal data, health data, regulated data, confidential client material, export-controlled material, or legally privileged material. Use non-personal identifiers for the release subject and reviewer.

The Actor processes the input fields and writes the decision, submitted metadata, audit records, and replay bundle to the run's default Apify Key-value store. A run that reaches the final charged Dataset request also submits one Dataset item. Actor application log messages contain only a fixed decision or bounded failure code; the application does not intentionally log submitted identifiers. Apify platform and system logging is outside the Actor code's control.

The Actor code does not call third-party services or copy run data to developer-controlled storage. It uses Apify only for run input, logs, and default output storage. Network isolation is not claimed.

The Actor does not use inputs or outputs for model training, advertising, or external analytics. Apify platform storage, retention, deletion, infrastructure, and transfer terms apply. Delete runs and their storages through the Apify Console or API when they are no longer required.

The publisher does not have routine permission to inspect a user's private run. For support, provide only sanitized information and grant explicit, case-specific access before the publisher reviews a private run or its storage. See [PRIVACY\_NOTICE.md](PRIVACY_NOTICE.md) and [SUPPORT\_POLICY.md](SUPPORT_POLICY.md) for the current public-beta data-handling and support rules.

### Pricing and license

The commercial model is Apify pay per event at USD 0.49 using only the custom `verified-decision` event described above. The Actor is published as a paid public beta. Independent-user U1–U5 validation and external-customer accounting are monitored post-publication. The Store checkout/run screen is authoritative for the effective transaction price and any Apify charges.

The publisher is **STUDIO MASAŻU FILIP MAJCHRZAK**, owned by Filip Majchrzak. The hosted Actor implementation is proprietary and its full source is not publicly distributed. Copyright © 2026 Filip Majchrzak. Public availability grants permission to invoke the hosted Actor, not to obtain or redistribute its proprietary source.

One deliberate exception is the hash-pinned `verify_bundle.py` source included in every replay bundle. That verifier source is licensed under the MIT License in `BUNDLED_VERIFIER_LICENSE.md` and the run's `VERIFIER_LICENSE` record. This exception does not license the rest of the Actor implementation.

Users retain their rights in submitted data and may download and use generated outputs for lawful purposes. Third-party components remain subject to their respective licenses.

The beta is provided as-is and as-available, without a service-level agreement or guaranteed availability, response time, maintenance period, or fitness for a particular purpose.

Use of the paid beta is also subject to [PAID\_BETA\_TERMS.md](PAID_BETA_TERMS.md), [PRIVACY\_NOTICE.md](PRIVACY_NOTICE.md), Apify's displayed terms, and any non-waivable rights under applicable law. If these terms conflict about a Store price or platform charge, the current Apify purchase/run screen controls that platform transaction.

### Support

Use the **Issues** tab on this Actor's Apify page for bugs and usage questions. Support is best effort and has no guaranteed response or resolution time. There is no SLA.

Assume Issue content may be public. Include only sanitized examples, a run ID, and output status. Never post input data, secrets, replay bundles, or confidential details. Report suspected security, privacy, or billing-event issues privately to `fmajchrzak.ai@gmail.com`; do not place exploit details in a public Issue. Full support and charge-review boundaries are in [SUPPORT\_POLICY.md](SUPPORT_POLICY.md).

### Runtime binding

- Engine: OCOI Evidence Gate Lite `0.1.1`
- Public runtime freeze: `OCOI-EGL-PUBLIC-RUNTIME-FREEZE-20260811-R6`
- Public core SHA-256: `09997e6c7de8e3045bbf80df5e4470107c2b823f3a200a8113fd3e119e24e84a`
- Evaluator SHA-256: `b1a1bd61268d37f7dc6daa37d69d4092dae53472ad3e75fe611742685749dd6c`
- Trusted launcher SHA-256: `41f30710ca9a1498b460acb7341cb386853bc2d59120da530e14e7c0b1aebfbf`
- Portable verifier SHA-256: `5f9ad6f81ea07536582b69d2657962aafcf2c7613564680e7b546ff404350293`
- Freeze record SHA-256: `577944cfa06593e1e6363fe85cd7fef959e8b4aaa3fd27c9d92592778284ec58`

The historical R4 and R5 runtime files remain byte-identical for evidence preservation; the v0.5/R7 paid wrapper uses the frozen R6 evaluation engine.

The verifier launcher is a separate, hash-pinned program. This is not certification or verification by an external organization.

# Actor input Schema

## `inputMode` (type: `string`):

Use the only supported guided public-beta mode.

## `preset` (type: `string`):

Fixed, versioned public-beta software-release policy preset.

## `claimId` (type: `string`):

Non-sensitive stable identifier using letters, numbers, dots, underscores, or hyphens.

## `subject` (type: `string`):

Non-sensitive identifier for the software release, build, or artifact. Do not enter confidential or personal data.

## `logicalTime` (type: `string`):

Explicit UTC time used for evidence-age checks. Wall-clock time is never substituted.

## `tests` (type: `object`):

Provide synthetic or non-sensitive test counts, or set this field to null when test evidence is unavailable.

## `review` (type: `object`):

Provide synthetic or non-sensitive review metadata, or set this field to null when review evidence is unavailable.

## Actor input object example

```json
{
  "inputMode": "easy",
  "preset": "software_release_basic_v1",
  "claimId": "public-demo-synthetic-allow-001",
  "subject": "SYNTHETIC_PUBLIC_DEMO_NOT_A_REAL_RELEASE",
  "logicalTime": "2026-08-09T00:00:00Z",
  "tests": {
    "observedAt": "2026-08-08T12:00:00Z",
    "passed": 12,
    "failed": 0
  },
  "review": {
    "observedAt": "2026-08-08T13:00:00Z",
    "status": "PASS",
    "reviewer": "synthetic-public-demo"
  }
}
```

# Actor output Schema

## `decisionSummary` (type: `string`):

Structured verified checkpoint result stored in the default Dataset.

## `outputJson` (type: `string`):

Canonical machine-readable hosted-checkpoint summary.

## `gateResult` (type: `string`):

Canonical decision emitted by the versioned, hash-bound OCOI evaluator.

## `auditRecord` (type: `string`):

Canonical audit record emitted by the versioned, hash-bound OCOI evaluator.

## `htmlReport` (type: `string`):

Human-readable static OCOI decision report.

## `replayBundle` (type: `string`):

Deterministic ZIP binding the decision and submitted canonical inputs.

## `replayBundleSha256` (type: `string`):

Detached SHA-256 sidecar for the deterministic replay bundle.

## `verification` (type: `string`):

Result from the separately hash-pinned replay-bundle verifier.

## `runtimeBinding` (type: `string`):

R6 engine, trusted launcher, portable verifier, and freeze-record hashes used for this run.

## `verifierLicense` (type: `string`):

MIT License for verify\_bundle.py included in the replay bundle.

## `billingAttempt` (type: `string`):

Write-ahead RESERVED\_NO\_RETRY record. Its presence suppresses later serialized paid attempts; it does not prove that Apify accepted a charge or Dataset item.

## `allFiles` (type: `string`):

All records in the run's default Key-value store.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "inputMode": "easy",
    "preset": "software_release_basic_v1",
    "claimId": "public-demo-synthetic-allow-001",
    "subject": "SYNTHETIC_PUBLIC_DEMO_NOT_A_REAL_RELEASE",
    "logicalTime": "2026-08-09T00:00:00Z",
    "tests": {
        "observedAt": "2026-08-08T12:00:00Z",
        "passed": 12,
        "failed": 0
    },
    "review": {
        "observedAt": "2026-08-08T13:00:00Z",
        "status": "PASS",
        "reviewer": "synthetic-public-demo"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("filipmajchrzak/ai-claim-checkpoint").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "inputMode": "easy",
    "preset": "software_release_basic_v1",
    "claimId": "public-demo-synthetic-allow-001",
    "subject": "SYNTHETIC_PUBLIC_DEMO_NOT_A_REAL_RELEASE",
    "logicalTime": "2026-08-09T00:00:00Z",
    "tests": {
        "observedAt": "2026-08-08T12:00:00Z",
        "passed": 12,
        "failed": 0,
    },
    "review": {
        "observedAt": "2026-08-08T13:00:00Z",
        "status": "PASS",
        "reviewer": "synthetic-public-demo",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("filipmajchrzak/ai-claim-checkpoint").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "inputMode": "easy",
  "preset": "software_release_basic_v1",
  "claimId": "public-demo-synthetic-allow-001",
  "subject": "SYNTHETIC_PUBLIC_DEMO_NOT_A_REAL_RELEASE",
  "logicalTime": "2026-08-09T00:00:00Z",
  "tests": {
    "observedAt": "2026-08-08T12:00:00Z",
    "passed": 12,
    "failed": 0
  },
  "review": {
    "observedAt": "2026-08-08T13:00:00Z",
    "status": "PASS",
    "reviewer": "synthetic-public-demo"
  }
}' |
apify call filipmajchrzak/ai-claim-checkpoint --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,filipmajchrzak/ai-claim-checkpoint"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/C9OUhkiZURam5LNwL/builds/aw6WMTJyDXpc7cGxp/openapi.json