Model-Agnostic · EU AI Act-Aligned · Target <10ms Latency

An independent governance layer
for regulated AI

ALEX evaluates the governance context of every request before your LLM generates a single token — deciding whether to speak, constrain, or stay silent. Works with Claude, GPT, Gemini, Mistral, and any internal model.

Get API Key → View Schema

🏦

Your Institution

Bank · Broker · Insurer
Asset Manager · Fintech

request

⚖️

ALEX Governance API

SPEAK · CONSTRAIN · SILENT
+ audit trace per decision

governed

🤖

Any LLM

Claude · GPT · Gemini
Mistral · Internal model

Why institutions use it

Your model isn't the problem. Controlling it is.

A bank may already have Claude or GPT. The hard problem is: how do you let that model communicate with clients, advisors, and portfolio managers without losing control?

Compliance control

Every response follows your pre-defined governance policy. No ad-hoc disclaimers, no model improvising on regulated topics.

Decision-level traceability

Every decision carries a trace_id, version, triggered rules, and signal values. Reviewable by compliance, auditors, and regulators.

Model independence

Switch your underlying model without changing your governance policy. ALEX governs the layer above any LLM.

Risk reduction

High-risk contexts are constrained or blocked before generation. Requests classified as REMAIN_SILENT are not forwarded to the downstream LLM.

Policy consistency

Same rules across chat, email, call center, portfolio assistant, and internal tools. One governance layer, all channels.

Regulatory evidence

Show how AI behaviour was managed — not just what the model said. Produces decision-level evidence that can support Article 9 risk-management documentation.

Quickstart

Three lines before your LLM call

Call ALEX first. If the decision is REMAIN_SILENT, don't call your LLM. If it's SPEAK_WITH_CONSTRAINTS, inject the constraint_preamble into your system prompt.

# 1. Evaluate the governance context BEFORE calling your LLM
curl -X POST https://alex-finance.onrender.com/v1/govern \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "context_type": "investment_guidance",
    "domain_signals": {
      "vix": 22.4,
      "regime_conf": 0.68,
      "stakes": 0.82,
      "information_reliability": 0.61
    },
    "session_id": "hashed-session-ref"
  }'

# 2. Route on the decision:
#    SPEAK                → call LLM normally
#    SPEAK_WITH_CONSTRAINTS → prepend constraint_preamble to system prompt
#    REMAIN_SILENT        → do NOT forward to LLM
#
# v2 will add: jurisdiction, channel, user_class, policy_profile

import httpx

# 1. Evaluate governance context BEFORE calling your LLM
gov = httpx.post(
    "https://alex-finance.onrender.com/v1/govern",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "context_type": "investment_guidance",
        "domain_signals": {
            "vix": 22.4,
            "regime_conf": 0.68,
            "stakes": 0.82,
            "information_reliability": 0.61,
        },
        "session_id": "hashed-session-ref",
    }
).json()

# 2. Route on the governance decision
if gov["decision"] == "REMAIN_SILENT":
    return "This request has been blocked by your governance policy."

system_prompt = your_base_system
if gov["decision"] == "SPEAK_WITH_CONSTRAINTS":
    system_prompt = gov["constraint_preamble"] + "\n\n" + system_prompt

# 3. Call your LLM — store gov["trace_id"] for audit log
response = your_llm.complete(system=system_prompt, user=user_query)

// 1. Evaluate governance context BEFORE calling your LLM
const gov = await fetch('https://alex-finance.onrender.com/v1/govern', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    context_type: 'investment_guidance',
    domain_signals: {
      vix: 22.4, regime_conf: 0.68,
      stakes: 0.82, information_reliability: 0.61,
    },
    session_id: 'hashed-session-ref',
  })
}).then(r => r.json());

// 2. Route on the governance decision
if (gov.decision === 'REMAIN_SILENT') {
  return 'Blocked by governance policy.';
}

let systemPrompt = yourBaseSystem;
if (gov.decision === 'SPEAK_WITH_CONSTRAINTS') {
  systemPrompt = gov.constraint_preamble + '\n\n' + systemPrompt;
}

// 3. Call your LLM — store gov.trace_id in your audit log

Response

Every decision is structurally traced

{
  "trace_id": "3f7a9b2c-e841-...",
  "decision": "SPEAK_WITH_CONSTRAINTS",
  "signals": {
    "crf": 0.61,
    "ir":  0.82,
    "cs":  0.75,
    "ob":  0.45
  },
  "triggered_rules": [
    "crf_elevated",
    "high_irreversibility"
  ],
  "constraint_preamble": "⚠ Governance note:
Market volatility elevated (CRF 0.61);
high real-world consequences.
Treat as one perspective, not a directive.",
  "decision_reason": "CRF 0.61 above threshold;
high irreversibility",
  "latency_ms": 8,
  "runtime_version": "V5.0",
  "policy_version":  "v2.6"
}

trace_id

UUID per decision. Store in your audit log to inspect the governance state and policy path behind any recorded decision.

decision

SPEAK — proceed normally. SPEAK_WITH_CONSTRAINTS — inject preamble. REMAIN_SILENT — do not call LLM.

constraint_preamble

Ready-to-inject warning text. Prepend to your LLM system prompt when decision is SPEAK_WITH_CONSTRAINTS.

triggered_rules

Which governance rules activated. Auditable reason chain for every constrained or blocked response.

latency_ms

Bridge computation time. Typically 5–15ms — negligible overhead before your LLM call.

Integration

Four steps to governed AI

Get an API key

Request below. We review each request and issue keys within 24 hours.

Add one call before your LLM

POST to /v1/govern with your context_type and optional market signals. Takes 5–15ms.

POST /v1/govern Authorization: Bearer ak_your_key {"context_type": "financial_advice", "domain_signals": {"vix": 22.4}}

Route on the decision

SPEAK → call LLM normally. SPEAK_WITH_CONSTRAINTS → prepend the preamble. REMAIN_SILENT → skip the LLM entirely, return your fallback message.

Store the trace_id

Attach the governance trace_id to every LLM response in your system. This creates a complete, auditable chain: request → governance decision → LLM output.

API Reference

Endpoints

POST /v1/govern Auth required

Evaluate a context → participation decision. Core endpoint. Place before every LLM call.

GET /v1/govern/health No auth

Service status, runtime version, supported context types.

GET /v1/govern/schema No auth

Full JSON schema for request + response, thresholds, and context defaults.

Compliance

Built for regulated environments

🇪🇺

EU AI Act-aligned infrastructure

Produces decision-level evidence that can support Article 9 risk-management workflows. Every governance event includes auditable signal values, triggered rules, and policy version.

🔍

Decision-level traceability

trace_id links every LLM response back to its governance decision. Inspect any event: what signals were present, what rules fired, what was decided — and which policy version was active.

🔒

No prompt content stored

ALEX evaluates signals, not text. We store CRF, IR, CS, OB, and the decision — never the query content. Zero PII risk from the governance layer.

📋

Policy versioning

Every decision records runtime_version, policy_version, and threshold_version. Your governance behaviour is reproducible and comparable across time.

🌍

Model independence

The governance layer is separate from the LLM. Switch providers without changing your compliance posture. Works with any model that accepts a system prompt.

📊

Research-informed

Developed through the TACA research framework (Zenodo DOI 10.5281/zenodo.20800461). Currently undergoing empirical evaluation via the ALEX Research Lab public observatory.

Get Started

Request an API key

We review each request and issue keys within 24 hours. Early access is by invitation — describe your use case below.

✓ Request received

We'll review your request and send your API key to the email provided within 24 hours. Questions? minchevteodor@gmail.com