Build on the ActionIntent API.
SigmaX governs what a capital action is allowed to do next — mandate checks, preflight, human approval, and route disposition, recorded as an append-only audit trail. The ActionIntent API is how partners integrate that governed lifecycle. It is a decision-support and draft/paper routing layer: it records decisions and prepares dispositions, and it never transmits an order to a venue, custodies assets, or moves funds.
AI analyzes. Deterministic systems validate. Humans authorize. Capital remains governed.
The ActionIntent API is a commercial plan — from $120,000/year + usage, issued per workspace. See plans and pricing →
One base URL. Scoped, operator-issued keys.
Authentication is a bearer key bound to a workspace. Keys are issued during onboarding rather than self-served, and restricted scopes keep a partner integration confined to exactly the routes it needs.
All ActionIntent routes live under https://api.sigmax.capital. Durable routes are versioned under /v1.
Present an Action Spine principal as an Authorization: Bearer header. The key carries a workspace and an approver role — never capital or execution authority.
Stripe-style restricted keys confine a key to a subset of routes. A read_only key reaches every GET and no write; approval_inbox reaches only the three approval routes. Least privilege by default.
Keys are minted by an operator during onboarding — not self-serve yet. Durable routes are operator-gated and off by default; they answer 404 until the surface is armed for your workspace.
Reference keys by env-var name, never by value. The typed client reads its key from an environment variable and never hardcodes it.
Every response states its own authority.
Every method returns the full governed envelope, not just its data. The authority fields are load-bearing and machine-checkable: a caller can confirm, on every single response, that no capital moved and that live execution stayed off. The safety posture is in the payload — not a footnote.
{
"ok": true,
"data": { /* the step artifact */ },
"status": "paper_ready",
"reason_codes": ["paper_only"],
"next_allowed_actions": ["advisor_task"],
"proof_ref": "intent_…",
"no_capital_moved": true, // always true
"live_execution_enabled": false, // always false
"authority": {
"capital_authority": "none",
"execution_authority": false,
"external_send": false,
"customer_action": false,
"customer_eligibility": "not_customer_eligible",
"broker_submit_path": "none",
"provider_calls": "not_called",
"secrets_policy": "names_only"
}
}- no_capital_moved
Always true. Every success envelope asserts that no capital was moved.
- live_execution_enabled
Always false. Live execution is disabled by design — a compile-time constant in the client.
- status + reason_codes
The governed disposition and its reasons, drawn from a closed set. A blocked call names the gate that refused it.
- authority
The full authority posture of the call: no capital authority, no execution, no external send, no customer action, secrets referenced by name only.
A blocked request returns an error envelope (HTTP 400/401/404) carrying the same authority fields plus an error.code and reason_codes — inspect both to see which governance gate refused the request.
Your first governed call.
With an operator-issued key, send a bearer-authenticated request to a durable route. The reference key is read from an environment variable — the value never appears in code. The reply is the governed envelope.
curl -sS https://api.sigmax.capital/v1/trigger-engine/durable/preflight/run \
-H "Authorization: Bearer $SIGMAX_ACTION_SPINE_KEY" \
-H "Content-Type: application/json" \
-d '{ "action_intent_id": "intent_…" }'{
"ok": true,
"data": { /* preflight result */ },
"status": "preflight_passed",
"reason_codes": ["allowed"],
"no_capital_moved": true,
"live_execution_enabled": false,
"authority": { "capital_authority": "none", "execution_authority": false }
}A read_only key can reach every GET read surface — list ActionIntents, replay an intent, read the append-only audit trail — and no write route. It is a safe first integration.
The four things every integration uses.
The full contract is in the OpenAPI spec. These four patterns cover almost every integration path.
A durable create requires an idempotency key, sent in the Idempotency-Key header or the body field. The same key with the same payload returns the existing record; the same key with a different payload is refused. Keys are workspace-scoped.
List surfaces use opaque, Stripe-style cursors. Pass limit, then pass next_cursor back as cursor while holding filters constant. The cursor is a bytestring — never construct or parse it. A malformed, tampered, or filter-mismatched cursor fails closed with a 400, never a silent restart.
Subscribe an HTTPS endpoint to receive signed, non-authoritative event records from a closed event catalog. Delivery is off by default. Every send is HMAC-signed over timestamp.delivery_id.raw_body; the payload carries only IDs and a payload_hash — never object bodies, secrets, or PII. The signing secret is returned once at creation.
Both reason_codes and error.code come from a closed set. Non-blocking dispositions (allowed, paper_only, handoff_ready, approval_required) advance the lifecycle; every blocked_* code means a governance gate refused the request. There are no open-ended error strings to parse.
The spec, the SDK, and access.
The machine-readable contract is public. The typed SDK and workspace keys come with a paid ActionIntent API plan, issued during onboarding.
The full OpenAPI 3.1 contract for the ActionIntent API. A CI guard asserts it matches the running routes exactly, so the published contract never drifts from the server.
View openapi.json →A typed client that returns the full governed envelope — no_capital_moved and live_execution_enabled are compile-time constants. It is not yet published to a public registry; it is provided to design partners during onboarding.
The ActionIntent API is a commercial plan — from $120,000/year + usage, priced per workspace. Keys are operator-issued once a plan is in place; start an access review to scope an integration and receive a restricted key and the SDK.
One governed API. Three tiers. A boundary that never moves.
SigmaX exposes intelligence, proof, and governed proposals by API — never capital movement, execution, custody, or order routing. Each tier states its own authority, and each availability is labeled exactly: what is live today, what is built but off by default, and what is designed out for good.
Read the intelligence. The entitlement-scoped, GET-only Drift Radar read API and the operator-issued, non-executing ActionIntent GET reads are available to provisioned workspaces. The impact-ledger and append-only audit reads live on the same durable ActionIntent surface — all of it answers 404 until an operator arms it (SIGMAX_TRIGGER_ENGINE_DURABLE_ENABLED) for your workspace. Fiduciary, decisions, and liquidity reads join them under one unified scoped key as that plane rolls out (built, operator-gated). Self-serve key issuance is on the roadmap.
An agent can create at most a draft ActionIntent through the human-gated Agent Gateway — never an order, a transfer, or an approval. Every response asserts no_capital_moved: true and live_execution_enabled: false. The front door is built and stays off until an operator arms it.
There is no live-submit, order, transfer, custody, or customer-capital route anywhere in the API. Route dispositions top out at draft, CSV ticket, or locked. This capability is designed out — the class of breach that moves money has nothing to compromise.
AI analyzes. Deterministic systems validate. Humans authorize. Capital remains governed.
Every response: no_capital_moved: true · live_execution_enabled: false
One key model. Least privilege, per product.
A single unified key plane (the sxk_ prefix) carries an explicit, closed set of per-product scopes. A key reaches exactly the routes its scopes allow — nothing else. It is deny-by-default, stored as a one-way hash, and shown once at creation. It is built today and issued by an operator; self-serve issuance is on the roadmap. It is kept deliberately distinct from the live principal keys above.
Drift Radar surfaces
Fiduciary evidence + decision-assurance
Decisions, divergence, outcomes, audit
Liquidity-radar signals
The Agent Gateway proposal routes only
An empty or malformed scope set authorizes nothing — a tampered key never half-works. The five read families are GET-only, so a read scope can never escalate to a write, and proposals:write reaches only the propose-only gateway — never a trigger-engine write, a connector, or a capital path.
Atlas is your implementation engineer.
Atlas is SigmaX’s own governed AI assistant — the same assistant that answers questions across this site and the platform. During implementation it guides your team through setup and verifies readiness read-only: it reports which environment-variable names are present or missing and what to do next — and it never enters a credential, provisions Stripe, activates a connector, or authorizes an action. A human does all of that. This is the same chain as everywhere in SigmaX: a guide that checks, and a person who acts.
Read-only. Atlas runs one readiness check on the workspace SigmaX stands up for you and reports which environment-variable names are present versus missing, plus the exact next step. It never reads, echoes, or validates a secret value.
Your team places only its own values: your SigmaX API key in your environment, your endpoints, your workspace settings. SigmaX configures its side — provider credentials and all Stripe billing. You never create prices or touch payment infrastructure. Atlas points at the name and its purpose; a person places the value.
Atlas never provisions Stripe, activates a connector, exchanges a token, or moves capital. Every side-effect is a human decision. AI proposes; humans authorize.
Atlas re-runs the read-only readiness check to confirm progress and surface the next gap. Guide, then verify — Atlas never acts on your behalf.
What’s next for the unified API.
These are designed and in build — not live. We label them as such so the boundary between shipped and planned stays honest.
A buyer’s plan mints an sxk_ key carrying exactly its scopes — with no operator in the loop. Keys are operator-issued today.
The published contract covers the Action Spine today. Extending it across every Tier-1 read surface — each path labeled with its tier and authority posture — is next.
Usage metering and monthly quota — built default-off, being wired across every Tier-1 read.
SigmaX provides capital decision intelligence, scenario analysis, and authority workflow software. SigmaX does not provide investment advice. SigmaX does not place trades, move funds, route customer capital, or manage client capital. Shadow/simulated/paper/backtested results are not live trading results. No result is a guarantee of future performance. Human approval is required before any capital-linked action.
Where SigmaX uses AI, it is governed as assistive software: truthful capability claims, human oversight, traceable records, disclosure of AI assistance, and no capital authority. SigmaX designs AI controls with reference to applicable securities obligations, FINRA existing-rule guidance, SEC AI-claims discipline, NIST AI RMF-style risk management, and EU AI Act transparency readiness. This is compliance-readiness design, not a claim that every deployment or jurisdiction-specific use has completed legal review.