Patent pending. Public integration summary only — not legal or patent advice.

Integration guide

Coerentis exposes a FastAPI HTTP API. Your strategy proposes trades; the API returns allow/block decisions and structured reasons. Self-host the API on your infrastructure, or use a managed deployment — substitute your base URL below.

Architecture

Recommended insertion point: after signal generation and before order routing to brokers or internal OMS. In Shadow mode you log decisions without blocking execution; in Audit you persist logs for compliance; in Enforcement blocked intents must not be sent for execution.

Base URL & docs

Prefix: /api/v1
Example base: https://your-host.example/api/v1
Interactive OpenAPI: /docs on your deployment
Further reading: Technical appendix · Methodology brief

Authentication

Production calls use an API key header (see server config and tier tables in the repo):

X-API-Key: <your-key>

Core endpoints (summary)

Method	Path	Role
`POST`	`/filter`	Trade gatekeeper: allow/block + safety rails
`POST`	`/risk`	Risk evaluation for a proposed position
`POST`	`/signal`	Engine signal (MOCK/LIVE per deployment)
`POST`	`/regime`	Regime classification helper
`GET`	`/healthz`	Liveness (typically unauthenticated)

`POST /filter` body (illustrative)

Exact schema matches FilterRequest in the codebase; adjust fields to your deployment version.

{
  "asset": "BTC",
  "action": "BUY",
  "price_history": [50000.0, 50100.0, 50200.0],
  "volume_history": [1200.5, 1150.0, 1300.0]
}

Latency & throughput

Measure on your hardware, region, and network. Document targets in your deployment runbook. Example planning assumptions (not a guarantee):

Same-region HTTP: design reviews often plan for sub-100 ms application time for the filter path before network — validate with your load tests.
Rate limits: tiered by API key; see infra/RATE_LIMIT_PROFILES.md in the repo.
Fail-closed: on timeout or error, your middleware should treat the decision as block unless you explicitly operate in Shadow-only logging mode.

Sample middleware (Python-style)

Illustrative only — error handling, retries, and idempotency are your responsibility.

import requests

BASE = "https://your-host.example/api/v1"
API_KEY = "your-key"

def route_through_shield(asset: str, action: str, prices: list[float], shadow: bool = False) -> dict:
    r = requests.post(
        f"{BASE}/filter",
        headers={"X-API-Key": API_KEY, "Content-Type": "application/json"},
        json={
            "asset": asset,
            "action": action,
            "price_history": prices,
        },
        timeout=5.0,
    )
    r.raise_for_status()
    decision = r.json()
    if shadow:
        return {"shadow_logged": True, "decision": decision}
    if not decision.get("trade_allowed", False):
        return {"execute": False, "reason": decision}
    return {"execute": True, "reason": decision}

Supported environments

Server: Python 3.9+, FastAPI. Clients may use any language with HTTP/JSON. Validate TLS, clock sync, and secret storage (no keys in browsers for production).

Apply for access Performance brief (PDF)