Developers · Proof protocol

Build against the evidence plane

Start without an account: create a portable routing receipt, verify its Ed25519 integrity, then change one signed field and watch verification fail. Governed inference is an authenticated next step—not a prerequisite for proving the control path.

Run the proof quickstartInspect the release gate

5 min

Create, verify, and tamper with a real proof

0

Dependencies in the offline Node verifier

Ed25519

Canonical receipt integrity

Fail closed

Unavailable serving never becomes fallback

Proof before integration

Make the trust boundary visible

Run the complete public path here. Signature validity proves the body is unchanged; authority matching proves which configured signer produced it. Those are deliberately different claims.

Five-minute proof path

Create it. Verify it. Break it on purpose.

This calls the public decision endpoint, not an inference model. The returned receipt commits to the task, candidates, choice, and rationale. No account or serving backend is required.

LIVE API · NO INFERENCE
01

Create a decision proof

02

Verify integrity and authority

Recompute the body digest, check Ed25519 integrity, then compare the embedded signer with this deployment's configured authority.

03

Prove mutation is detected

Alter one signed rationale field and submit it with the original signature. A trustworthy verifier must refuse it.

Integration surface

Four real endpoints, one governed path

Create and verify evidence first. Then preview the request-time gate and, only in a configured environment, request a completion through an authorized release.

Create a portable decision receipt

Public · no account

Classify a task, inspect every candidate and rationale, and receive a governed-receipt/v1 envelope. The task is committed to the receipt, so do not submit secrets.

1curl --silent --request POST https://leanlogix.ai/api/router/select \
2  --header 'Content-Type: application/json' \
3  --data '{"task":"Plan a zero-downtime schema migration."}' \
4  | tee decision.json

Re-verify the selection receipt

Public integrity check

Recompute the canonical body hash and Ed25519 signature. Integrity against the embedded key and trust in the configured LeanLogix authority remain separate results.

1jq '.receipt' decision.json \
2  | curl --silent --request POST https://leanlogix.ai/api/verify-selection \
3  --header 'Content-Type: application/json' \
4  --data-binary @-

Preview the request-time release gate

Public decision preview

Inspect classification, capability, cost and latency proxies, endpoint-configuration readiness, and the current passport-gate verdict before any inference is attempted.

1curl --request POST https://leanlogix.ai/api/router/plan \
2  --header 'Content-Type: application/json' \
3  --data '{
4    "prompt": "Write a token-bucket rate limiter in TypeScript with tests.",
5    "prefer": "balanced"
6  }'

Request a governed completion

Authenticated · backend required

Use the OpenAI-compatible route only after a release and serving backend are configured. It refuses an unverified, unauthorized, or unreachable path instead of silently falling back.

1curl --request POST https://leanlogix.ai/api/router/v1/chat/completions \
2  --header 'Content-Type: application/json' \
3  --header "Authorization: Bearer $LEANLOGIX_SUPABASE_ACCESS_TOKEN" \
4  --data '{
5    "model": "auto",
6    "stream": false,
7    "messages": [{"role": "user", "content": "Plan a safe migration."}]
8  }'

Availability boundary

Public proof first. Operator controls second.

Decision receipts, selection verification, route preview, and privacy-safe passport summaries are public. Raw passport exports, promotion controls, and governed inference require authenticated authority and configured infrastructure. The Studio remains an operator beta.

Inspect the route decision before inference.
Only a re-verifying, reachable model can serve.
Export raw proof only through an authenticated member workflow.
leanlogix.ai — integration path

Verify locally without trusting our endpoint.

Save the receipt and run the zero-dependency Node 22 verifier from a source checkout. Pin the expected key fingerprint when signer identity matters.

npm run proof:conformance