Analytics: eContext
Real-time trade context
at point of RFQ.
When an RFQ arrives, eContext delivers the market picture in real time: where the bond has traded recently, what other venues are quoting, historical liquidity, and fair-value reference. Embedded into trader workflow.
What is eContext
Context on the print,
at the speed of the RFQ.
The hardest problem on a fixed-income desk is not executing the trade; it is knowing whether the quote in front of you is a good one. The trader sees a price; they need to know, in seconds, where else that bond has traded, what other venues are showing, how the price compares to fairMid, and what the recent history looks like. Without a dedicated tool, that picture has to be assembled manually across multiple screens and data sources. eContext collapses that into a single context bundle delivered at the moment an RFQ arrives, the market picture, pre-assembled, in real time.
The context,
assembled for you.
Four dimensions that determine the shape of eContext, latency, data depth, integration pattern, and output form.
Real-time response
Full context bundle returned in the time it takes a human to read the RFQ notification. Pre-aggregated lookups and in-memory indexes keep the response budget inside the window a trader can act on.
REAL-TIME · STREAMING
Rich market history
Print history, quote history, and streaming state from multiple venues. Consolidated data back through the relevant decision horizon for the instrument.
PRINTS · QUOTES · HISTORY
API or widget
Consume as an API call from your OMS or EMS, embed as a UI widget on the trader blotter, or subscribe to a streaming feed. The output shape adapts to where the desk already works.
API · UI · STREAMING
Structured bundle
Every response returns a structured context object, fair-value reference, last N prints, current quote stack, liquidity score, and expected cost. Consumable by both humans and downstream logic.
STRUCTURED · MACHINE-READABLE
The bundle
Everything the trader needs, in one payload.
When an RFQ lands, eContext returns a single structured object: the fairMid reference, the recent print history, the current quote stack across venues, the liquidity score, and an expected-cost estimate at the requested size.
The same payload feeds the trader's blotter widget and the auto-quote model. One surface, two consumers, and the post-trade TCA replays the exact context that informed the decision.
How it lands
Embedded in the blotter,
visible the moment
the RFQ arrives.
The most common deployment is a widget in the trader workflow. When an RFQ lands on the blotter, the eContext bundle arrives alongside, a compact panel with the fair-value line, a micro-chart of recent prints, the current quote stack across venues, and the liquidity score for the ISIN. The trader accepts, counters, or rejects with the context visible. For automated flow, the same bundle feeds the decision model directly, the context that the human trader reads is the context the model consumes. One surface, two consumers.
Sell-side variant
At point of RFQ, with client context.
When a sell-side desk receives an RFQ, eContext delivers the full client picture alongside the market picture: who is asking, similar clients' recent activity, the instrument's own trade history, and a fair-value reference. The context lands at the moment the RFQ arrives, before the quote is formed.
The result is a decision-ready view: the market, the client, and the instrument, assembled in one panel. The quote rests on objective reference data the desk can point to.
Buy-side variant
At the trade decision and the RFQ response.
For buy-side desks, the context window opens around the trade itself, both when forming the decision and when responding to an RFQ. The bundle carries what matters for the buy side: market timing signals, similar instruments trading now, recent prints across venues, the institution's own historical trades in the instrument, and pre- and post-trade risk metrics.
The buy-side trader sees whether the market is favourable for the intended size, how comparable instruments are behaving, and how the contemplated trade sits against the desk's own position history, all before committing.
What is the latency budget end-to-end? +
The response is returned in real time, within the window a trader can act on. The full bundle is built from pre-aggregated indexes; nothing is computed at request time except the size-conditional expected cost. Network latency adds whatever your colocation profile dictates.
Can the bundle drive an auto-quoter? +
Yes. The same response that renders the trader widget feeds the auto-quote model. Every field is structured for downstream logic, with a human-readable narrative alongside the machine-readable signal.
How does the post-trade record line up with what the trader saw? +
Every eContext response carries a context_id. TCA pulls the bundle by ID at attribution time, replaying the exact fair-value, quote-stack, and liquidity-score snapshot that informed the decision. Pre-trade and post-trade reference the same record.
For technologists
Built for the desk that owns its stack.
eContext is an open, versioned service. The API contract is stable; every response carries a context_id for post-trade replay; the integration surface is designed for the team that owns its own stack.
The four answers on the left are the questions the integrating team asks first. The full developer reference covers the rest.