Financial risk intelligence platform.

Graph-native · Memory-native · Regulator-ready

Unified risk intelligence across TradFi and DeFi.

TradFi derivatives and DeFi positions share the same probability-of-default curve, the same CVA engine, and the same regulator-citable explanation.

Every number is traceable. Every decision is explainable. Every assessment makes the next one smarter.

The single most important architectural decision. Three PD sources — CDS bootstrap (market-implied), WOE/XGBoost scorecard (statistical/ML), and on-chain liquidation bootstrap (DeFi) — produce the same PDCurve object that feeds the same CVA engine and the same ECL computation.

# Same interface, three sources
pd_curve = CDSCurve.from_spread(85, lgd=0.45)              # TradFi: market-implied
pd_curve = WOEScorecard.predict(features).to_pd_curve()      # Credit: statistical
pd_curve = LiquidationBootstrap.fit(snapshot).pd_curve        # DeFi: on-chain
# All three feed:
cva = compute_cva(exposure_profile, pd_curve, ois_curve)     # same CVA engine
ecl = compute_ecl(ead, pd_curve, lgd, stage)                  # same ECL engine

First-class Portfolio entity: structured collection of trades flowing through all 18 layers. TradeDefinition captures the full instrument structure — product type, economic terms, counterparty, CSA, DeFi terms. NettingSet groups trades for CVA/SA-CCR. Ingestion pipeline: upload → parse → validate → normalise → enrich → store → construct. Product types are CalibrationRegistry strings — new instruments without code change.

portfolio = Portfolio(trades=[
    TradeDefinition(trade_id="T1", product_type="ir_swap", notional=10_000_000, ...),
    TradeDefinition(trade_id="T2", product_type="swaption", notional=5_000_000, ...),
    TradeDefinition(trade_id="T3", product_type="defi_lending", protocol="aave_v3", ...),
])
# Same portfolio feeds: pricing → Greeks → CVA → ECL → stress → FRTB → ICAAP → reporting

The graph is not a visualization — it is the primary data structure the system reasons from. Every assessment enriches a graph node. Every dependency is a weighted edge. DebtRank propagates distress. The agent reads graph neighbours during classification, not after.

Layer 1 (built):    Foundation — 6 memory layers, GraphStore, DeXposure-FM, 7 Docker services
Layer 2 (active):   Continuous learning — every assessment enriches memory + graph + patterns
Layer 3 (emerging): Graph RAG — traverse edges, compute via weights, answer with systemic context
Layer 4 (emerging): Autonomous agents — Graph Agent, Risk Agent, Compliance Agent, Alert Agent

• GraphStore — NetworkX DiGraph. Node = entity. Edge = financial relationship.
• DeXposure-FM — 4,300 protocol dependency edges across 602 chains.
• GNN Contagion — GAT attention mechanism. Contagion multiplier per entity.
• DebtRank — iterative distress propagation for systemic importance.
• Anomaly detection — ECL spike, rating drift, pattern deviation, neighbour contagion, sector outlier.

Memory is not conversation history replayed into a prompt. Memory is structured, searchable, and accumulative. The classify node reads entity memory, graph neighbours, similar cases, and org patterns before the LLM is called.

The Workspace tab is not a chatbot — it is a risk intelligence copilot that answers from computed data, not from training knowledge. When a user asks "what is my DV01?", the copilot reads the portfolio, calls the Greeks engine, runs attribution through crediqs-explain, and responds with the user's actual numbers.

Question arrives
  → classify reads entity_memory (structured, not replayed)
  → classify reads graph_node (neighbours, weights, DebtRank)
  → classify reads similar_cases (semantic vector search)
  → classify reads org_patterns (accumulated decision history)
  → LLM classifies WITH all of this as structured context
  
Assessment completes
  → persist writes to memory_entities (entity knowledge grows)
  → persist writes to graph node (graph knowledge grows)
  → persist writes embedding (semantic search improves)
  → next question about same entity is richer than the last

The agent discovers capabilities from the node catalogue — no hardcoded routing. Adding a new engine = inserting a catalogue node. The agent finds it on the next query.

Full stress testing lifecycle: regulatory scenarios (EBA 2025, Fed CCAR, PRA, OSFI), historical replay (GFC, COVID, crypto winter, USDC depeg), sensitivity analysis (single-factor, multi-factor, KRD, 2D surface), model validation (traffic light backtest, Kupiec, Christoffersen, PSI drift), reverse stress testing, FRTB capital under stress (SBM + DRC + RRAO), ICAAP aggregation (Pillar 1 + 2A + 2B), and climate stress (NGFS v5).

Every number shown on the platform must be traceable to a successful real-time market data pull, tool result, model output, database record, or user input. No hardcoded numeric fallbacks. No fabricated pd_1y: 0.02 in seed data. No entity: "SAMPLE". If a required value is missing, the module raises ValueError — it does not silently produce a number.

Every engine output has a registered explain adapter. Every number carries its attribution.

Zero hardcoded profiles, templates, or dashboard mappings. Everything from the database:

• Node Catalogue — 32+ nodes in catalogue_nodes table. Each declares requires[], produces[], input_schema, output_schema, governance fields.
• DashboardLoader — reads workflow nodes → matches produces[] to WIDGETS registry → lazy-loads the right dashboard. No if (type === "tradfi").
• Model Registry — Settings → Models with governance lifecycle: draft → validated → production → deprecated. Test Contract validation before promotion.
• Agent Discovery — classify.py fetches effective-nodes from API. collect.py carries explain_adapter from catalogue. No hardcoded routing in agent-service.

Every model cites its academic source. Every regulatory computation cites the specific article.

Website · Contact

Graph-native risk intelligence. Every assessment makes the next one smarter.