Ship AI safely or don't ship it at all.

Zorelan runs after model generation and before execution. It takes model outputs, evaluates agreement, risk, and context, and returns a deterministic decision your system can act on.

Use it as the final checkpoint before your system acts on AI output.

Why not just use one model?

A single model can generate an answer, but it does not tell you whether that answer deserves confidence. Zorelan compares multiple model outputs and returns a structured verification signal you can use to show, warn, block, or escalate responses in production.

import { Zorelan } from "@zorelan/sdk";

const zorelan = new Zorelan(process.env.ZORELAN_API_KEY!);

const result = await zorelan.verify(userInput);

// Gate execution on result.decision — the authoritative field
if (result.decision === "allow") {
  showAnswer(result.verified_answer);
} else if (result.decision === "review") {
  showWithWarning(result.verified_answer, result.decision_reason);
} else {
  // "block" — high risk, material conflict, or unresolved conditions
  requireHumanReview(result.decision_reason);
}

Make your first call

The fastest path is a single HTTP call. Send one prompt, get back a verified answer plus the confidence signals needed to decide how your product should use it.

curl -X POST https://zorelan.com/v1/decision \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Should I use HTTPS for my web application?"}'

curl -X POST https://zorelan.com/v1/decision \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Determine whether HTTPS should be used for a production web application. Include security, SEO, and compliance considerations.",
    "raw_prompt": "Should I use HTTPS for my web application?",
    "cache_bypass": true
  }'

npm install @zorelan/sdk

import { Zorelan } from "@zorelan/sdk";

const zorelan = new Zorelan(process.env.ZORELAN_API_KEY!);

const result = await zorelan.verify(
  "Should I use HTTPS for my web application?"
);

console.log(result.verified_answer);
console.log(result.trust_score.score);
console.log(result.risk_level);
console.log(result.recommended_action);

import requests
import os

response = requests.post(
    "https://zorelan.com/v1/decision",
    headers={
        "Authorization": f"Bearer {os.environ['ZORELAN_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "prompt": "Should I use HTTPS for my web application?",
    }
)

data = response.json()
print(data["verified_answer"])
print(data["trust_score"]["score"])
print(data["consensus"]["level"])
print(data["cached"])  # True if result was cached

What you get back

The core fields most apps use

Most products do not need the full payload to get started. In many cases, these fields are enough to drive UI and routing decisions.

{
  "ok": true,
  "verified_answer": "Yes — you should use HTTPS for your web application.",
  "decision": "allow",
  "decision_reason": "Low risk, high trust score, and consistent model agreement. Output is safe to act on.",
  "trust_score": {
    "score": 94,
    "label": "high",
    "reason": "The providers strongly agree on a low-risk best-practice conclusion."
  },
  "risk_level": "low",
  "consensus": {
    "level": "high",
    "models_aligned": 2
  },
  "recommended_action": "Use the shared conclusion as the answer."
}

Where to use Zorelan

Authentication

All API requests must include your API key as a Bearer token in the Authorization header.

Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

POST /v1/decision

Submit a prompt for multi-model verification. Zorelan queries multiple AI providers, compares their responses, and returns a trust-calibrated result your application can act on.

Simple mode and advanced mode

Most developers should start with simple mode. Advanced mode is useful when you want to optimize the provider-facing prompt without distorting trust calibration.

Request body

{
  "prompt": "Should I use HTTPS for my web application?"
}

{
  "prompt": "Determine whether HTTPS should be used for a production web application. Include security, SEO, and compliance considerations.",
  "raw_prompt": "Should I use HTTPS for my web application?",
  "cache_bypass": true
}

Full response

All responses are JSON. A successful call returns ok: true with the full verification payload.

{
  "ok": true,
  "decision": "allow",
  "decision_reason": "Low risk, high trust score, and consistent model agreement. Output is safe to act on.",
  "verified_answer": "Yes — you should use HTTPS for your web application. The providers agree that HTTPS is standard practice for protecting user data, securing sessions, and establishing trust.",
  "verdict": "Models are aligned on the main conclusion",
  "consensus": {
    "level": "high",
    "models_aligned": 2
  },
  "trust_score": {
    "score": 94,
    "label": "high",
    "reason": "The original answers support the same main conclusion, Models strongly agree on the core conclusion, provider output quality is strong, with no meaningful disagreement; overall risk is low."
  },
  "risk_level": "low",
  "confidence": "high",
  "confidence_reason": "Both models reached the same core conclusion with no meaningful disagreement.",
  "key_disagreement": "No meaningful disagreement",
  "recommended_action": "Use the shared conclusion as the answer.",
  "cached": false,
  "providers_used": ["anthropic", "perplexity"],
  "verification": {
    "final_conclusion_aligned": true,
    "disagreement_type": "none",
    "semantic_label": "HIGH_AGREEMENT",
    "semantic_rationale": "Both answers strongly recommend HTTPS as standard practice for security and trust.",
    "semantic_judge_model": "openai/gpt-4o-mini",
    "semantic_used_fallback": false
  },
  "arbitration": {
    "used": false,
    "provider": null,
    "winning_pair": ["anthropic", "perplexity"],
    "pair_strengths": null
  },
  "model_diagnostics": {
    "anthropic": { "quality_score": 9, "duration_ms": 4571, "timed_out": false, "used_fallback": false },
    "perplexity": { "quality_score": 8, "duration_ms": 5158, "timed_out": false, "used_fallback": false }
  },
  "meta": {
    "task_type": "general",
    "overlap_ratio": 0.42,
    "agreement_summary": "The two model outputs support the same main conclusion.",
    "prompt_chars": 42,
    "execution_prompt_chars": 118,
    "likely_conflict": false,
    "disagreement_type": "none",
    "initial_pair": ["anthropic", "perplexity"]
  },
  "usage": {
    "plan": "pro",
    "callsLimit": 1000,
    "callsUsed": 42,
    "callsRemaining": 958,
    "status": "active"
  }
}

Response fields

Gate execution on result.decision

Every response includes a decision field that encodes the execution gate. Zorelan derives it from risk level, disagreement type, model alignment, and trust score — you do not need to re-implement this logic yourself. Branch on decision directly.

How trust scoring works

Zorelan does not just measure whether models agree. It measures whether that agreement deserves confidence.

Disagreement types

Zorelan classifies the relationship between model responses into five types. This gives structured signal beyond a simple agree/disagree binary.

Arbitration

When the initial two models disagree, Zorelan automatically invokes a third model to find the strongest pair. The arbitration field in the response tells you whether it was used, which provider was the tiebreaker, and the pair strength scores.

Initial pair: Claude + Perplexity → LOW agreement
    ↓
Arbitration triggered
    ↓
Third model (GPT) queried
    ↓
Three pairs evaluated:
  Claude + Perplexity  → strength: 0
  Claude + GPT         → strength: 3  ← winner
  Perplexity + GPT     → strength: 2
    ↓
Active pair: Claude + GPT
Trust score recalculated on winning pair

How it works

Zorelan sits between your application and AI providers. When you call the API, Zorelan routes your prompt to multiple models simultaneously, compares their outputs using a semantic agreement engine, and returns a verified answer alongside a structured analysis of how the models agreed or disagreed.

Your prompt
    ↓
Adaptive provider selection
    ↓
Parallel model queries (Claude · Perplexity · GPT)
    ↓
Semantic agreement judge (neutral cross-model)
    ↓
Arbitration if disagreement detected
    ↓
Trust score + verified answer

The semantic judge is always a different model family from the providers being compared — Claude judges OpenAI outputs, OpenAI judges Claude outputs. This eliminates self-scoring bias from the verification layer.

Prompt optimization without distorting trust

Zorelan supports both a provider-facing execution prompt and an original raw prompt for calibration. This allows you to optimize model performance without inflating confidence on inherently uncertain questions.

raw_prompt
    ↓
Task detection + risk classification + trust calibration

prompt
    ↓
Provider execution + synthesis

Result
    ↓
Better answers, honest trust scoring

Verified result caching

Zorelan caches verified results for 6 hours. The first request for a given calibrated prompt path runs the full verification pipeline — querying multiple AI providers, running the semantic agreement judge, and producing a trust score. Subsequent identical requests within the cache window return the stored verified result instantly.

Every response includes a cached field so your application always knows whether it received a fresh live verification or a recently verified cached result. Cache keys are scoped to the calibrated prompt path and provider pair. When raw_prompt is provided, caching is anchored to that trust-calibration input.

Bypassing the cache

To force a fresh live verification regardless of cache state, pass cache_bypass: true in the request body. This is useful when you need the most current provider outputs — for example, on time-sensitive prompts or after a known change in underlying facts.

{
  "prompt": "Should I use HTTPS for my web application?",
  "cache_bypass": true
}

Error codes

Zorelan uses standard HTTP status codes. All error responses include ok: false and an error code string.

{
  "ok": false,
  "error": "rate_limit_exceeded",
  "plan": "starter",
  "calls_limit": 200,
  "calls_used": 200,
  "calls_remaining": 0
}

Rate limits

When rate limited, the API returns HTTP 429 with a retry_after field indicating seconds to wait before retrying.

Submit feedback

If Zorelan returns an incorrect verdict, you can submit feedback programmatically. Feedback is stored and reviewed to improve the verification engine.

Accepts any valid API key or master key. Requires the original prompt, the verdict Zorelan returned, the issue type, and your correct answer.

Request body

curl -X POST https://zorelan.com/api/feedback \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Should I use HTTPS for my web application?",
    "verdict": "Models are aligned on the main conclusion",
    "issue": "incorrect_verdict",
    "correct_answer": "HTTPS should be used by default for production web applications.",
    "request_id": "req_abc123",
    "notes": "This should be treated as a low-risk best-practice question."
  }'

{
  "ok": true,
  "id": "42d9ba4d-cab3-4721-83cb-06ae40c74562",
  "message": "Feedback received. Thank you."
}

Retrieve feedback

Returns all feedback records. Requires the master key — not available to regular API keys.

curl https://zorelan.com/api/feedback \
  -H "Authorization: Bearer YOUR_MASTER_KEY"

Get your API key

Subscribe below to receive your API key instantly. All plans include full API access with the same response schema, trust scoring, and arbitration.