Drop one authenticated POST after your model call. Get back pass / fail / needs-review, a confidence score, and a unique proof ID with SHA-256 chain hash metadata — the retrievable verification record Guardrails AI and AWS Bedrock Guardrails don't produce.
AI products can produce confident-looking answers that still contain errors. If customers rely on those outputs, the product needs a way to check them — before trust, payment, or downstream action.
A model returns an answer with an internal probability. Users don't see it. Your support team can't act on it. And it doesn't tell you why the answer might be wrong.
Passed, failed, or needs review — with the issues found and a proof ID they can quote back to you. One call, one answer, evidence behind it.
Plug it into your generate step. SwarmSync checks the output against rules or evidence, returns a proof-backed result, and stores the trail for dispute or audit.
Drop VerifyAPI in after your generate step. Five steps from output to proof — and your app keeps the user-facing surface it already has.
Extraction, summary, recommendation, action — whatever your model already produces today.
your.app → output {…}One authenticated POST with the output, the evidence, and the ruleset you want to check it against. Use /api/verify/demo for no-key sandbox tests.
Policy rules, prior runs, supporting documents, expected schemas — whichever you've configured.
conduit.verify(output)Plus a confidence score, the issues found, and a recommended action your code can switch on.
status: passed | failed | needs_reviewEvery result gets a proof_id. Fetch it later for audit, regulator response, or a user dispute.
VerifyAPI is built for the gap between "the model returned something" and "we're confident enough to act on it."
Totals reconcile, vendor matches, and terms compare when supporting evidence is supplied.
Required clauses present, prohibited clauses absent, redlines tracked.
KYB matches, sanction lists clear, entity details unchanged.
Row counts, schema mapping, type integrity across source and target.
Citations resolve, claims trace to source, no hallucinated references.
Output meets policy, controls fired, approval path followed.
The agent really clicked, the form really submitted, the result really landed.
The answer cites policy, addresses the question, and matches the ticket state.
Required fields present, types valid, totals consistent across the doc.
Spot-check the agent runs your internal team can't manually review at scale.
The whole product is one POST. The response gives you a status your code can switch on, the issues found, a confidence score, and the proof ID to log.
curl -X POST https://api.swarmsync.ai/api/verify \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_API_KEY" \
-d '{
"source_type": "api_output",
"task": "invoice_extraction",
"output": {
"vendor_name": "Acme Cloud Services",
"amount_total": 8450.00,
"invoice_number": "INV-10492",
"due_date": "2026-06-01"
},
"rules": [
"vendor_name_present",
"amount_total_present",
"invoice_number_present",
"due_date_present",
"missing_po_check"
]
}'{
"verification_status": "needs_review",
"confidence": 0.82,
"issues_found": [
"Extracted invoice total does not match line item total",
"Vendor payment terms differ from historical record"
],
"recommended_action": "human_review",
"proof_id": "proof_12345"
}The output meets the ruleset. confidence ≥ 0.95, no issues found. Safe to release downstream — payment, customer reply, workflow step, all clear.
The output partially clears, but at least one check flagged. Recommended action: human_review. Your app holds the result and queues a reviewer.
A hard rule was violated or the evidence contradicts the output. Recommended action: reject. Your app blocks the result and logs the proof for dispute.
VerifyAPI ships with a narrow, stable surface. Production calls use API-key auth; the sandbox keeps no-key demos separate from production records.
Submit an AI output with optional evidence and a ruleset. Requires Authorization: Bearer YOUR_API_KEY. Returns verification_status, confidence, issues_found, recommended_action, and a proof_id.
source_type — string, optional. Classifies the AI output type. Accepted values: api_output · agent_activity · document · workflow_event
No-key sandbox endpoint for the live demo and product trials. Same request shape, isolated anonymous demo records, not for production traffic.
Retrieve a past verification by its ID. Authenticated records are account scoped; demo records are anonymous sandbox records.
Fetch the full proof record: inputs, output summary, rules fired, evidence checked, timestamps. Exportable as PDF or JSON.
Verification runs used and remaining on your plan for the current period, with plan metadata for app-side billing and rate-limit dashboards.
Subscribe to verification.completed, verification.flagged, and proof.exported events.
Reliability score for a workflow: pass rate, fail rate, needs-review rate over a window.
Rendered report for a verification — useful for legal hold, internal audit, or board-pack export.
No marketplace take-rate. No per-seat fees. Pick the tier that fits your monthly verification volume — and only pay for what you use past it.
SwarmSync was built to verify AI agent work before money or trust depends on it. VerifyAPI turns that verification infrastructure into a simple API that AI builders can use inside their own products.
Outputs are checked against policy, prior runs, and supporting evidence.
Every result gets a hash-chained proof record — queryable, exportable, and optionally signed when signing keys are configured.
Three statuses your code can switch on. No probability soup, no "kind of."
Counters per workflow, per key, per period — wired straight to your bill.
Per-workflow pass rates and trend lines — surface bad runs before users do.
One POST, four endpoints, every common stack. Swap in next to your generate step.
Paste any AI output and run a single-record verification against the same engine that powers production. No API key required for /api/verify/demo.
Free up to 50 runs a month. One POST to integrate. Every verified output ships with a unique proof ID and SHA-256 chain hash — the retrievable verification record Guardrails AI and Bedrock can't produce.