taskq.xyz / architecture
architecture / control-plane boundaries

The public surface is small. The proof system is not.

TaskQ is built around one hard boundary: customers reach the Gateway. Everything that executes work lives behind private planes, signed worker identity, key custody rules, and HashIQ evidence.

internal mesh — surfaces · private only
gateway.public      : 443/customer-api
relay.local         : loopback or mesh
queue.local         : loopback or mesh
registry.store      : internal
key-custody.service : policy-gated
hashiq.writer       : append-only
settlement.writer   : journal-only
worker.heartbeat    : signed
worker.lease        : signed + ttl
System map

One Gateway. Private execution. Chain-backed evidence.

This is the difference between a gateway wrapper and a control plane: TaskQ separates public ingress, execution mechanics, custody, placement, proofs, and settlement.

Public surface

Customer API · auth + entitlement · policy resolution · proof headers. The only door.

Gateway core

Placement solver · worker lease · BYOK handle resolution · HashIQ open/close · usage normalization · settlement journal.

Private planes

Relay plane · Queue plane · registry store · key custody service · HashIQ writer · settlement writer.

Public boundary

Gateway is the only door.

Relay and Queue do not decide commercial policy. They do not accept public customer traffic. They execute only after the Gateway has authenticated, funded, placed, leased, and opened proof.

gateway — invariant · release gate
I1  : Gateway is the only public surface
I2  : no request executes without customer auth
I3  : hard constraints never relax
I7  : every placement is replayable
I10 : chain heads are externally anchored
Internal services

The architecture has jobs. Each service owns one.

Provider adapters execute requests. The registry owns worker state. Key custody owns decrypt policy. HashIQ owns signed evidence. Settlement owns chain-linked money movement.

ServiceOwnsDoes not own
Gatewayauth / policy / placementDoes not execute model work directly.
Registryworkers / health / attestationsDoes not fake compliance with dashboard labels.
Key custodycredential unwrapDoes not write plaintext secrets to chain or logs.
HashIQ writerappend-only proofDoes not store raw prompts or PHI by default.
Settlement writerjournal entriesDoes not silently drop deferred settlement.
Custody architecture

Credential access is an event, not a hidden side effect.

  • Envelope-encrypted. BYOK material is encrypted under a customer data key.
  • Policy-scoped plaintext. Plaintext exists only under policy, only in memory.
  • Customer-visible. Every unwrap produces an access record bound to the request and chain entry.
credential.accessVERIFIED
credential_fprsha256:91c…8fa
key_domainkd:CA
worker_idca-ab-yeg-01
custody_classpinned
request_idreq_01HX…
secret_loggedfalse
✓ access recorded — customer-visible
Failure semantics

Refusal is part of the product.

When no compliant capacity exists, the correct output is not silent fallback. It is a signed refusal proof that shows the system protected the customer policy.

409
NO_COMPLIANT_CAPACITY

Empty eligible set, recorded with policy hash and registry snapshot.

402
OVER_CEILING

Cheapest compliant worker exists, but exceeds the customer cost ceiling.

422
POLICY_INVALID

Request attempts to loosen hard defaults or create conflicting constraints.

✓
REFUSAL PROOF

Blocked, signed, exportable, replayable — a chain entry is still written.

Proof architecture

The chain is the architecture’s memory.

The Gateway makes decisions. HashIQ makes those decisions replayable. External anchors make silent rewrites detectable. Export makes the evidence portable.

Anyone can draw a router. TaskQ proves the route.

The control plane, verified worker registry, key custody model, HashIQ proof chain, and settlement ledger make every AI execution decision defensible.