Sovereign AI execution gateway · private beta

TaskQ places every AI request onto compliant capacity, uses the customer's own credentials, signs every decision, and returns proof you can verify later.

Request access → Verify the chain
BYOK customer-owned credentials BYOW verified worker capacity HashIQ signed audit trail
TASKQ PROOF● LIVE
request_idreq_01HX4V
routeverified
workerca-ab-yeg-01
credentialsha256:8fd0
fallback_reasonnone
chain_keyhshq_184467
✓ verified — what ran is what is written
The control-plane loop

The same discipline on every request.

The Gateway owns auth, balance, policy, placement, lease, proof, usage, settlement, and customer-facing response headers. The execution plane can change. The proof sequence cannot.

01Authenticate

Customer bearer + entitlement checked before work exists.

02Resolve policy

Defaults + request constraints merge without loosening hard limits.

03Select worker

Cheapest compliant capacity. Non-compliant workers never compete.

04Open proof

HashIQ entry begins: request hash, policy hash, registry snapshot, lease.

05Execute

Relay handles sync API shape. Queue handles jobs and artifacts.

06Close proof

Usage, hashes, and terminal status seal the chain entry.

07Settle

Every dollar movement journals back to a chain sequence.

gateway — request lifecycle
TaskQ gateway request lifecycle
Product modules

Not another wrapper. A control plane buyers can defend.

The API response is visible. The proof trail is the product. The worker network is the supply moat.

Placement engine
Placement

Cheapest compliant worker

Hard constraints never relax. If no worker qualifies, TaskQ refuses with proof.

Try the solver below →
HashIQ receipt
HashIQ

Receipt-as-ledger

Every request becomes signed evidence: route, worker, credential, usage, settlement.

Inspect the chain →
BYOK customer-owned credentials
BYOK

Customer-owned credentials

Provider spend stays customer-owned. TaskQ proves when and where keys were used.

Custody model →
BYOW verified worker market
BYOW

Verified worker market

Operators contribute capacity under jurisdiction, custody, health, price, and attestations.

Operator network →
Architecture · two planes

Do not force chat and agentic jobs through the same pipe.

Relay handles synchronous API-shaped work — chat, completions, streaming SSE. Queue handles long-running agentic jobs, reports, patches, files, and artifacts. Both share policy, placement, billing, and HashIQ proof. A chat completion routed through a queue feels broken. A multi-minute build routed through a sync proxy cannot produce deliverables.

One gateway, two planes →
Relay versus Queue execution planes
Placement engine · live demo

Routing is easy. Proving the route was compliant is the moat.

Set the policy. Watch the solver exclude every worker that would make the request cheaper, faster, or easier — if it violates policy, it is not a candidate. Empty the pool and TaskQ refuses with proof.

Jurisdiction

must_run_in: CA
must_not_run_in: US

Trust & custody

trust_floor: audited
key_custody: pinned/enclave

Economics

max_price_usd_per_mtok 0.75
✓ PLACED — ca-ab-yeg-01 · lowest_price_within_hard_constraints
chain entry written · placement proof exportable · auditor replay enabled
Verify the chain

The receipt is not decoration. It is the evidence surface.

TaskQ answers the questions normal AI platforms avoid: where did this run, which worker handled it, which credential was used, was a cheaper compliant option skipped, and can an auditor replay it?

No raw secrets in chain

Only fingerprints, handles, and HMAC-peppered references. Provider keys, OAuth tokens, PHI, and privileged matter names are excluded by default.

History cannot quietly move

Chain heads are published to witnesses so TaskQ cannot silently rewrite yesterday's proof without detection.

Export is first-class

Customers can leave with their signed evidence. A competitor cannot retroactively witness history they were not present to sign.

0
closed requests
0
blocked by policy
<5m
anchor delay
100%
settlement parity
BYOK custody

Your provider relationship. Your credentials. Our proof trail.

  • Not a house account. Credentials are envelope-encrypted, unwrapped under policy, and every access becomes a customer-visible event.
  • No raw secrets in chain. Only fingerprints, handles, and HMAC-peppered references.
  • Key-domain aware. Constrain unwrap to Canada, EU, customer-owned, or future HSM domains.
credential.access — customer-visible
BYOK credential custody
refusal proof — NO_COMPLIANT_CAPACITY
No silent fallback refusal proof
No silent fallback

The system refuses before it violates.

  • Wrong answer: "We routed it somewhere else." That is a policy failure disguised as resilience.
  • TaskQ answer: "No compliant capacity." Blocked, signed, exportable, and replayable.
  • Refusal is a feature. For regulated buyers, the strongest evidence is sometimes proof that the system refused to execute outside the approved policy envelope.
Developer API

Fast enough for builders. Serious enough for auditors.

  • Two env vars. One gateway. Drop in the gateway, keep the wire shape.
  • Proof headers on every call. Receive proof headers and fetch the chain entry later.
  • Anthropic-shaped, OpenAI-shaped, TaskQ-native. Adopt proof without rewriting every workflow.
Request developer access →
terminal — setup.sh
taskq console — production · ● chain verified
TaskQ dashboard console
Product shell

The dashboard is a verifier, not a vanity chart.

  • Requests → headers → traceability.
  • Credentials → access log → custody.
  • Reports → export → diligence.
  • Requests, jobs, credentials, workers, policies, chain, reports, and billing all point back to signed chain events.
Sovereign AI · private workers

Where did the work execute?

  • Provider logs explain their platform. TaskQ proves customer-defined placement across customer keys, operator workers, colos, local inference, and sovereign regions.
  • Customer-owned capacity joins the same proof market. Run on your GPUs, your colo, your HSM domain, or verified operators.
  • TaskQ still handles policy, placement, proof, and export.
private workers — customer boundary
Private workers customer-owned capacity
Trust strip · release-gate invariants

The sentence buyers remember.

Your AI work executed under your policy, using your credential, on compliant capacity, with proof.

I3 · HARD GATE

Hard constraints never relax

No silent fallback to non-compliant workers. A cheaper US worker cannot silently win a Canada-only request.

I7 · REPLAY

Every placement is replayable

Auditors can reconstruct why the worker won from the policy hash, registry snapshot, and deterministic tie-breakers.

I10 · ANCHOR

Export is first-class

Customers can leave with their signed evidence. Chain heads are externally anchored so history cannot quietly move.

I12 · PARITY

Every dollar maps to the chain

Settlement reconciles to request history. Closed billable chain entries require settlement journals.

Private beta

Do not just call the model.
Prove how the answer was handled.

TaskQ is for regulated buyers, infrastructure operators, and serious AI builders who need execution, custody, placement, and evidence in one gateway.

Request access → Become an operator