Kern logoKern
Enterprise verification infrastructure

Deterministic verification for real-world operations.

Kern turns field evidence into auditable machine decisions.
Teams integrate once, enforce policy consistently, and ship with confidence.

Get API KeyRead Docs

How it works

Task

Define scope, policy, and acceptance criteria through a stable API contract.

Evidence

Capture structured proof linked to task identity and request context.

Decision

AI assessment, validator checks, and human fallback for escalations.

┌──────────┐   ┌─────────────┐   ┌───────────────────────────────────┐
│   Task   │ → │  Evidence    │ → │ Decision: AI → Validator → Human │
└──────────┘   └─────────────┘   └───────────────────────────────────┘

Trust Model

Hash chain

Each event links cryptographically to prior lifecycle steps for integrity checks.

Deterministic checks

Policy rules execute predictably for consistent pass/fail outcomes across retries.

Audit trail / events

Structured events preserve decision history for support, controls, and governance review.

Use cases

AI agent verification

Require physical-world proof before an agent confirms task completion.

Field ops proof

Standardize evidence collection for distributed operations teams.

Fraud-resistant confirmations

Reduce spoofed completion claims through deterministic validation stages.

Compliance workflows

Provide auditable evidence and event history for regulated processes.

Developer Quickstart

import { KernClient } from "@kernprotocol/sdk";

const kern = new KernClient({
  apiKey: process.env.KERN_API_KEY!,
  baseUrl: process.env.KERN_API_BASE_URL,
});

const task = await kern.tasks.create({
  title: "Store verification",
  instructions: "Capture storefront state with timestamp",
  location: { lat: -12.0464, lng: -77.0428 },
}, { idempotencyKey: crypto.randomUUID() });

const upload = await kern.evidence.getUploadUrl(task.id, { fileName: "proof.jpg" });
await upload.file(fileBlob);

await kern.evidence.submit(task.id, {
  fileKey: upload.fileKey,
  type: "photo",
});

const result = await kern.tasks.poll(task.id, {
  intervalMs: 2500,
  timeoutMs: 120000,
});

console.log(result.status, result.decision);

Built for teams that ship

“Kern gives engineering and operations one shared verification contract: deterministic checks, auditable evidence, and clear fallback paths.”

Integrate once. Verify with confidence.

Move from manual validation to deterministic infrastructure with auditable outcomes.

Get API KeyRead Docs