The practical guide to achieving Live Risk with kernel-oriented design. Learn how MatLogica kernels support daily trading—from generation to workflows—enabling real-time risk and portfolio management.
Real-time risk calculation has become the holy grail of modern trading operations. Traders want instant Greeks, risk managers need continuous portfolio monitoring, and regulators expect timely reporting. But achieving true Live Risk requires more than just fast computations—it demands a fundamentally different architecture.
Traditional approaches recompute everything from scratch on each update—impossibly slow for real-time use.
Kernel-oriented design with modular, reusable computational graphs that update incrementally.
This page explains how to achieve Live Risk using MatLogica's kernel lifecycle approach—the practical architecture that makes real-time risk a reality, not just an aspiration.
At the heart of MatLogica's approach is the creation of reusable kernels—pre-recorded computational graphs that capture the essence of your quant workflows. These kernels are designed for repeated execution, enabling ultra-fast calculations by avoiding redundant recomputations each time market data or parameters change. To achieve optimal performance, kernel reuse must be maximized: a one-time recording phase (which incurs a modest upfront time cost) pays off exponentially through thousands of subsequent runs.
Strategic planning is key when dividing your quant library into kernels. Consider granularity—such as separate kernels for curve calibration, portfolio pricing, and risk sensitivities—to balance creation overhead with execution efficiency. This modular design allows targeted updates (e.g., recalibrating only affected kernels during trade amendments), ensuring smooth integration into daily trading activities while minimizing overall compute demands.
Kernels support a typical trading day by handling model calibration, portfolio pricing, risk calculations, and RFQ responses. The process begins with intraday updates and extends to custom trade executions.
Kernels are organized in a modular structure to allow flexibility. For example, separate kernels for curve engines, pricing, and risk ensure targeted updates without full recomputation.
Generated once per day or on market changes, this kernel handles curve-building functionality for various instruments.
Records the pricing workflow for the entire portfolio, enabling repeated executions with updated market data.
Computes sensitivities via the adjoint pass, integrated with pricing.
Uses pre-recorded kernels for quick responses to standard requests.
Allows on-the-fly generation for bespoke trades, balancing speed and customization.
This approach ensures kernels are generated efficiently and reused throughout the day.
Append new trades to existing kernels without full regeneration, updating the portfolio structure dynamically.
Remove specific trades from the kernel setup, by scaling factor to zero (for complete removal) or to a proportion (for partial removal).
Adjust parameters in-place, triggering minimal kernel updates for efficiency.
Each trade has a scaling factor (0 to 1) for efficient amendments without kernel recreation
Run hypothetical market scenarios by applying changes to kernel inputs, enabling quick evaluation of potential impacts.
Combine trade modifications with scenarios to assess amended portfolios under various conditions.
Sub-millisecond pricing for standard trades
Scaling factors avoid kernel rebuilds
Direct computation of all Greeks
Hierarchical portfolio organization
Quick recalibration on market changes
Real-time risk calculation enabled
This ensures agile risk management without operational disruptions.
Learn how MatLogica's kernel lifecycle approach can transform your trading operations with real-time risk capabilities