Permissions are not verification
Access controls and approval rules decide authority over data. They never ask whether the model's inference is coherent, grounded, or free of overgeneralization.
FineSchema is a deterministic verification gate for agentic AI. When an agent proposes an action, FineSchema checks whether the reasoning is sound — before anything is written back to your systems of record.
help an agent see more — connect the data, map the ontology, widen what it can reach.
decides whether the agent should act — a deterministic verdict on the reasoning, in the instant before the write-back.
We don't ingest your data or run your operations. We sit at the one moment that matters — the action — and return VERIFIED · UNCERTAIN · BLOCKED, with a trace you can replay.
Give an agent an action and a rationale. FineSchema returns a deterministic verdict — VERIFIED, UNCERTAIN, or BLOCKED — before the action could ever execute. A prototype deterministic gate runs in your browser. It demonstrates the inspection pattern, not the full production engine.
No blocked keyword in the string. "chargeback" and "freeze" are both allow-listed terms, so it lets the action through.
Plausible-sounding and on-topic, so the model rates it fine — non-deterministically, and with no reproducible reason it can defend to an auditor.
Reason: overgeneralization. Trace: chargeback is a risk signal, not sufficient evidence of fraud. A blanket "every" cannot be justified from a single condition.
pip install fineschema import fineschema v = fineschema.verify( "freeze_account", "freeze every account with a chargeback") v.verdict # BLOCKED v.block_reason # OVERGENERALIZATION
curl -X POST https://fineschema-api.vercel.app\
/api/verify-action -d '{
"action_type": "approve_loan",
"rationale": "approve it",
"context": {"situation_tags":
["NO_INCOME_VERIFICATION"]}}'
# {"verdict":"BLOCKED",
# "block_reason":"POLICY_VIOLATION"}
Modern AI platforms govern who can act, on what data, with which permissions — and they log data lineage. But the reasoning itself — the inference from data to recommendation — stays probabilistic, non-reproducible, and unchecked at runtime.
Access controls and approval rules decide authority over data. They never ask whether the model's inference is coherent, grounded, or free of overgeneralization.
You can trace where a number came from. You cannot reproduce why the agent recommended an irreversible action — the rationale is a black-box, run-to-run variable.
Language models are built to be helpful. Under ambiguity they still produce a confident output — and an agent will act on it.
When an agent freezes an account, deletes a record, or administers a dose, "review it later" is not a control. The check has to happen before the write-back.
FineSchema does not generate answers. It verifies whether a judgment is formally legitimate, checking it against a deterministic schema of valid inference built on Kant's twelve categories. CPU-only. No model weights. Same input, same output, every time. When reasoning is incoherent, overgeneralized, or ungrounded, it fails closed.
The reasoning is sound and within policy. The action proceeds.
Borderline or unsupported. The action is staged for a mandatory human checkpoint.
A formal defect or policy violation. The write-back is refused and the reason is recorded.
The twelve categories aren't a metaphor. Each one compiles into a concrete, deterministic gate on the agent's rationale. Four of the load-bearing ones, each with a real example failure:
The remaining categories (totality, plurality, substance, community, possibility, existence, necessity, limitation) compile into the same kind of fixed checks — together they form the schema of valid inference the gate runs, identically, every time.
FineSchema sits in the action path. The agent proposes; FineSchema returns a deterministic verdict and a replayable audit trace; only verified actions execute.
Local deterministic verification, measured on a developer machine. Every number below comes from one reproducible script — the method is published in full, so you can re-run it yourself.
mean 0.191ms · p50 0.186ms · p95 0.214ms · p99 0.281ms ~5,241 verify/s · single core · no batching replay 1000/1000 deterministic — trace_id → identical verdict + meanings ✅Raw results (JSON) →
Local prototype benchmark on Apple M4 Pro. Results vary by hardware, cartridge complexity, and action family. These are single-machine figures for the deterministic gate itself, not an end-to-end SLA. A reproducible public case-set with broader hardware coverage is in progress.
Non-deterministic models cannot be formally verified or certified. A deterministic gate can be specified, tested, and accredited — the same component, byte-for-byte, in the cloud or inside a classified enclave.
Not a model and not a data platform — a small, inspectable kernel and the pieces around it. Every part is built to be specified, tested, and certified.
Kant's twelve categories as a fixed schema of valid inference. It never generates — it only verifies. Same input → same verdict → same trace, every time.
Your rules, encoded once — finance, healthcare, insurance, HR. The same gate verifies every proposed action against the cartridge for its domain.
Every verdict carries an ID. Hand it to an auditor or a regulator and the exact reasoning replays — byte-for-byte. The "why," not just the "what."
No model, no GPU, no network. The whole engine runs offline in a classified enclave — and because it's deterministic, it can actually be accredited.
FineSchema verifies the reasoning behind every autonomous decision — in finance, healthcare, insurance, and HR — before the action is ever taken.
One engine, a cartridge per industry. Below: the action an agent proposes, the verdict FineSchema returns before it commits, and the Action Family Library — the concrete actions we gate in each domain.
Account freezes, loan decisions, wires, refunds. A wrongly frozen account or a non-compliant loan is immediate, measurable damage — and a regulator's question.
Medication orders, discharges, dosing. Block a contraindicated dose or an unstable-vitals discharge before it executes; route the borderline to a clinician — with a record of why.
Claims, underwriting, premiums. "Deny every claim from this postal code" is both overgeneralized and a fair-practice risk — blocked deterministically, with the reason on record.
Screening, terminations, accommodation. "Reject all candidates over fifty" or a retaliatory termination is caught and blocked — protecting candidates and the company alike.
Also live: government & defense (air-gapped, certifiable), trust & safety, data governance. Any domain where a wrong autonomous action is irreversible.
For each: the proposed action, the AI rationale, what a naive guardrail misses, the FineSchema verdict, the trace, the missing evidence, the safer action — and why it matters.
FineSchema runs between your agent — Palantir AIP, a custom orchestrator, or any agentic platform — and your systems of record. Compile your action policy from your ontology; the engine verifies every proposal before it commits.
A stateless HTTP service. One call — /verify-action — returns the verdict and an audit trace.
Packaged as a function inside your platform, invoked in the action submission path.
CPU-only, no network, no model weights — for classified and offline environments.
FineSchema is designed as a deterministic pre-action verification layer. It should be inspectable, replayable, and deployable with minimal data exposure. A full overview lives on the security page.
For hosted pilots, retention and logging are configured per customer agreement. Self-hosted and air-gapped deployments can be configured for customer-controlled data retention.
The browser prototype demonstrates the inspection pattern. It is not the full production engine.
Sub-processors are determined by deployment mode. Self-hosted and air-gapped deployments can minimize or eliminate third-party processing. Hosted pilots may use infrastructure providers such as Vercel or email delivery providers if configured.
FineSchema is not currently claiming SOC 2, HIPAA, ISO, or GDPR certification. Compliance posture depends on deployment mode, customer requirements, and validation scope.
A pilot is scoped to a single action family in your environment — your policy, your data, your verdict log. No rip-and-replace, no model retraining.
Metered API pricing arrives when the paid, public API does. Today every engagement starts as a scoped pilot on one action family — so we can prove the catch rate on your traffic before anyone talks dollars per call.
Estimate only — it sizes the exposure a verification gate sits in front of, not a quote. Actual catch rate depends on your policy cartridge coverage, validated in the pilot.
Tell us your stack and the first action you need to govern. We'll scope a pilot on one action family in your environment — your policy, your data, your verdict log.
FineSchema is not a universal safety guarantee. It is a deterministic verification layer for inspecting action reasoning before execution.
Browser demos are illustrative prototypes. Production deployments require domain validation, policy cartridges, and customer-specific review.
Healthcare and other regulated domains require regulated validation before clinical or operational deployment.
Agent Verification is the enterprise product. The Cognitive Truth Engine is the broader epistemic research vision — evaluating truth, emotion, and judgment by evidence, context, and contradiction.