One platform for the whole life of an agent.

One governed way to call any model. Agents ask for a class of model (fast, standard, reasoning, code, embed, rerank or vision), and the gateway chooses the deployment.

• One request, response and stream format over the official provider SDKs
• Retries with jitter, a circuit breaker per deployment, and fallback that stays inside the allowed list
• Each routing decision recorded: rules applied, candidates removed, deployment and region chosen
• Azure OpenAI and any OpenAI-compatible server today, including self-hosted open-weight models

curl https://api.sparqhq.ai/v1/admin/model-classes \
  -H "Authorization: Bearer $SPARQ_KEY"

Built for applications that serve many customers. Each of your customers is a client inside your Project, with its own data, memory, traces and budget, isolated by design.

• A compliance profile per client: allowed regions, allowed providers, provider retention and data sensitivity
• Model routing obeys the profile and fails closed with no_compliant_model, never quietly routing elsewhere
• The client comes only from a verified claim in your user's token, never from a request header

curl -X PUT https://api.sparqhq.ai/v1/admin/audience-tenants/$CLIENT_ID/compliance-profile \
  -H "Authorization: Bearer $SPARQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "audience_tenant_id": "'$CLIENT_ID'", "version": 1,
        "data_regions": ["eu"], "allowed_providers": ["azure-openai"] }'

Every model call is one ledger row with every dimension you need to attribute it: workspace, project, client, agent, model class, credential, tokens and cost.

• Budgets reserved before each call, from the run up to the workspace, plus a cap per credential
• A hard limit stops the call before it is sent; delegation cannot multiply spend
• Rate limits per credential and per client, refused when the limiter cannot be reached
• Usage reports grouped by client, agent, model class, project, credential or day

curl "https://api.sparqhq.ai/v1/admin/usage/report?group_by=audience_tenant&group_by=model_class" \
  -H "Authorization: Bearer $SPARQ_KEY"

Every request records the credential that made it. Audit records are append-only, chained by hash per workspace, and written in the same transaction as the action they describe.

• If the audit write fails, the action is undone
• A verifier detects changed, removed and re-hashed records
• Every authorization decision is recorded with its policy version, including refusals

curl "https://api.sparqhq.ai/v1/admin/audit?credential_id=$CREDENTIAL_ID" \
  -H "Authorization: Bearer $SPARQ_KEY"

End-user features such as file uploads, web search or memory are switched on and off at six levels: platform, workspace, project, client, user and conversation.

• A lower level can only narrow what the level above allows
• Admins can lock a setting so nobody below can change it
• Enforced on the server, not only hidden in the interface

curl "https://api.sparqhq.ai/v1/admin/feature-settings/project?scope_id=$PROJECT_ID" \
  -H "Authorization: Bearer $SPARQ_KEY"

Agents are specifications stored as data, not code: job, instructions, model class, tools, skills, limits and the actions that need approval.

• Modes: react, deep, research, workflow and loop
• Loop mode runs Discover, Plan, Execute, Verify, Iterate, and the checker is never the maker
• Skills load only when relevant, and a skill never grants a tool
• Hard limits on model calls, tool calls, delegation depth and run time

curl -X POST https://api.sparqhq.ai/v1/runs \
  -H "Authorization: Bearer $USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "agent": "ticket-triage", "input": { "ticket_id": "T-1042" }, "wait": true }'

SparQ never runs your code. Your services expose tools over MCP, or SparQ imports operations from your OpenAPI document, and every call passes the tool gateway.

• Schema validation, authorization, approval, egress policy and audit on every call
• Tool schemas are pinned; a changed schema is blocked until it is reviewed
• Tools receive a short-lived, single-purpose token (ES256, at most five minutes), never the user's own token
• Tool output is treated as untrusted data and screened for injection

# Public keys for delegated tool tokens
curl https://api.sparqhq.ai/.well-known/jwks.json

Collections of documents that agents search by name: hybrid search over vectors and full text, with citations on every answer.

• An agent searches only the collections it names
• It sees the shared part plus its own client's part, never another client's
• Per-collection settings for result count, minimum score and required citations

curl -X POST https://api.sparqhq.ai/v1/admin/collections/$COLLECTION_ID/search \
  -H "Authorization: Bearer $SPARQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "query": "refund policy for annual plans" }'

Agents stop to ask a question or to request approval, and resume later in any process. Writes and destructive actions always wait for a person.

• Approval is forced for writes, spend past the soft budget and outside destinations
• Approve, reject, or edit the arguments before the tool runs
• Pauses survive restarts: state is checkpointed after every step

curl -X POST https://api.sparqhq.ai/v1/approvals/$APPROVAL_ID \
  -H "Authorization: Bearer $USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "decision": "approve", "comment": "Refund confirmed with the customer" }'

A Release is an immutable bundle of a Project's configuration: models, instructions, agents, tools, guardrails, knowledge and the evaluation baseline. It is promoted and rolled back as a whole.

• Draft, validate, evaluate, review the diff with its quality and cost change, then a second admin approves
• A Release cannot reach an environment unless its evaluation suites pass
• Live within seconds; runs already in progress finish on the version they started with
• One-step rollback

curl -X POST https://api.sparqhq.ai/v1/admin/projects/$PROJECT_ID/rollback \
  -H "Authorization: Bearer $SPARQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "environment": "prod", "to_release_id": "'$PREVIOUS_RELEASE_ID'",
        "reason": "Answer quality dropped after the last Release" }'

OpenTelemetry traces with the GenAI conventions, sent to the tools you already run: Grafana, Langfuse, Datadog, Azure Monitor or any OTLP backend.

• Prompt and response content is off by default
• Content policy per destination: metadata only, redacted, or full with an approver
• A residency check on every destination

curl "https://api.sparqhq.ai/v1/admin/traces?project_id=$PROJECT_ID" \
  -H "Authorization: Bearer $SPARQ_KEY"

A typed TypeScript client with streaming, a React chat kit with approval and question cards, and a Python SDK for specs, drafts and local evaluation runs.

• Types generated from the same contract the API is built from
• The SDK never holds model keys, evaluates policy or stores memory
• Consoles call the API from their own server, so keys never reach a browser

import type { Schema } from "@sparq/client";

function render(event: Schema<"StreamEvent">) {
  if (event.type === "token") append(event.text);
  if (event.type === "approval_required") showApproval(event.approval);
}