Calseda
The live calculation server
Exposure per counterparty or collateral per account: Calseda keeps each one current the moment its data changes, and can show exactly which inputs produced it. You write the formula in Java or Python. Calseda finds the data and recalculates only what changed.
Each counterparty or customer gets its own long-lived worker. In the scene, the workers value portfolios and check their risk.
A portfolio first, then the prices of what it holds. Each answer decides the next question.
Feeds open when the first worker needs one, and close when none does. Nothing streams that nobody uses.
Only the answers that depend on the change, on the latest values.
An exposure feeds a limit check. A result is just more data.
A web page submits a private task. A worker spins up for it and streams results back to that page alone, until the page closes. A trader's pre-trade check or an underwriter's quote needs no new service.
One demo is a small trading desk. It values six client portfolios, each in its client's own currency, from eleven sources including Alpaca, Coinbase, Deribit, the European Central Bank and the SEC. About a hundred workers run at once, for valuations, value at risk, option risk, volatility smiles and an AI reader of company filings. Open any figure to see the exact prices and rates behind it, or build a what-if portfolio of your own.
Other demos run on the same server software, each for a different industry: Pick the demo closest to your work. For heads of desk, the trading desk has a page of its own: Calseda for trading desks.
Why live
Most firms already have these numbers. They are just late, or hard to explain.
| Today | With Calseda | |
|---|---|---|
| Overnight batch | Figures are right at 7am and drift all day. | Each figure recalculates when one of its inputs changes, and only then. |
| Spreadsheet copies | Traders paste figures into Excel and adjust them by hand. | Excel reads live figures and sends overrides back, checked and traceable. |
| A service per question | Every "what if?" becomes a project. | A private "what if?" runs on the live data from a browser or Excel, and disappears when done. |
| Glue code | Feeds, caches, retries and threads written again for every calculation. | Written once in the framework. A calculation is a few lines of business logic. |
Under load
Systems fall behind exactly when it matters most: when markets move fastest or payments pile up. A system that queues every update ends up showing prices from half a minute ago, in the middle of a sell-off.
Calseda never builds a queue of old values. When updates arrive faster than a calculation or a screen can use them, it skips the ones in between and passes on the newest. Everything that reads from it stays current, at the busiest moment as at the quietest.
Why trust it
When a number drives a decision, someone will ask why it is what it is, and whether it is current. Calseda keeps the answer with the number.
Open any result and see the exact input values its latest run used, each with when its data is from and when it arrived, and the calculation or source feed that produced it. Nothing is pieced together afterwards.
Each source says how fresh its data should be, trading hours included. Calseda flags results that rest on data gone stale, and measures how long each change takes to reach the results, end to end and across servers. A built-in console shows what every calculation is doing and each failure as it happens. Prometheus metrics are built in. The last 10 runs of each task can be downloaded as recordings, inputs and results, to debug and test with.
Where it fits
Calseda started where figures move every second and every one may have to be explained: banking and trading.
Banking
Each counterparty's collateral and each account's intraday liquidity, recomputed as payments settle and prices move, each figure showing the payments and prices it was calculated from.
Banking
Each counterparty's exposure and limit, recomputed as trades and prices change, so a deal is checked against the current figure rather than last night's.
Financial crime
Each customer screened again the moment a sanctions list or an ownership record changes, with the reason for every hit.
Controls
Each limit compared with its live figure, and a breach sent once to the team that owns it, with its causes attached.
Large institutions are moving the same way for themselves. Citi describes its in-house XiNG platform as giving "a live, precise assessment of risk and P&L"1, and the Options Clearing Corporation has turned an overnight margin batch of more than eight hours into a five-minute intraday run2. Calseda offers live, explainable calculation as a product, ready to run on your own data.
Anywhere many things each need their own live answer from their own slice of changing data.
Insurance
Each portfolio follows just the policies in a storm's path.
Energy
Each wind farm or battery, as prices and meters move. Live demo ↗
Supply chain
Rewired when a vessel changes route or a port closes.
Airlines
Crew limits and connections, as delays happen.
Retail
Each product following its own competitors and stock.
Sports betting
Each accumulator following every match it includes. Live demo ↗
See it for your industry: a bank's risk and compliance, trading desks, power trading and sports betting.
Excel
The risk is in what Excel holds today: pasted figures that go stale, and adjustments nobody can trace.
A value or a "what if?" answer updates in the sheet as its inputs change.
A range of override prices is published to the server. The app's own rules check each row, and the result has a source and a time like any other data.
One add-in works with every server, signed in with the firm's own identity provider, so there is no Excel code to write. The calculations themselves stay on the server, where they are tested and traceable.
AI
An agent left to search will quote whatever figure it finds, however old, and may change something it shouldn't. Through Calseda it reads live figures with their sources, and changes only what its sign-in allows.
An agent reads live results and can ask which inputs each one was calculated from, and when.
An agent signs in like a person and gets that sign-in's actions only. It runs private "what if?" calculations and posts only to the types an app accepts. It cannot overwrite incoming data or results.
Every Calseda server is an MCP server. Claude, Copilot, Cursor, Gemini or Codex can use it, with tools generated from the server's own configuration.
An agent receives at most the latest value per figure. It can't flood the server or build a backlog.
A worker can call a language model, for example to read a filing or a report. Its answer must fill in a fixed form, and is checked again before anything uses it. Ordinary workers turn it into numbers that move with live data; the model never does the arithmetic.
Each document is analysed once. The result is stored, even across restarts, and shared by every calculation and user that needs it, so model cost grows with documents, not with users. The prompt is data too, so analysts can improve it without a release.
AI-written code
Coding assistants write a lot of code quickly. Asked for a live calculation, they also write connections, caches, retries, threads and a private store of state, slightly differently every time. The result is a lot of code, and nobody fully understands it.
The formula, and the data it needs. It is quick to read and quick to review.
Data, timing, retries, sign-in and lineage are written once, in the framework.
A calculation tried from a laptop can't touch production data. Moving it into production is a deliberate step.
The console shows each calculation's inputs and how long it takes, so slow or wrong code is easy to find.
Calseda can't make a formula right. It keeps the formula small and easy to check.
What's different
Stream processors push every record through one pipeline. Many real calculations are different. There are many portfolios, shipments, policies or machines, each needing its own slice of the data, and that data changes through the day.
| Typical stream processor | Calseda | |
|---|---|---|
| Dependencies | One topology for every record, fixed when it is deployed. | Each calculation discovers its own inputs from the data, and rewires when that data changes. |
| Market data | Consume whole topics or feeds. | Subscribe per instrument, only while some calculation needs it. |
| Units of work | Pipelines, changed by redeploying. | Tasks are data: a calculation lives as long as its task and follows every change to it. Calculations can raise tasks for others. |
| Explainability | Results carry no record of the inputs behind them. | Every result shows the exact input values it was computed from, and the calculation or feed each came from. |
| Freshness | Lag is watched per pipeline, not per result. | Every result knows the age of the data behind it, end to end, and is flagged when that data is older than its source should allow. |
| Identity | Join on a single key; mapping is application code. | Entities carry several identifiers (ticker, FIGI, LEI, legal name) and can be requested by any of them. |
| Ad hoc questions | A separate service per question. | A browser submits a private what-if calculation; results stream back to it alone until the page closes. |
| AI models | Model calls added to a pipeline, repeated for every record and every consumer. | A worker can call an LLM to read documents. Its answer is checked against a fixed form and shared by every calculation that needs it; the model is asked again only when the document or the prompt changes. |
| AI agents | A separate API, and integration work for each agent. | Every Calseda server is an MCP server. Agents explain live results and run private what-if calculations under their own sign-in, with tools generated from the server's own configuration. |
Calseda sits alongside a stream processor rather than replacing one. Use the stream processor for windowed aggregation over event streams, and Calseda for long-lived calculations over reference data and live prices.
Not a ledger. Where every single event must be processed exactly once, as in payments or accounting, use a message system and a stream processor. Calseda deliberately keeps the latest value.
Not a replacement for Kafka or Redis. It runs on top of the systems you have.
See it work
One of our demos is a small trading desk, on real public market data. The same kinds of workers would follow a bank's collateral or screen its customers.
BTC, 17 days to expiry. At the forward (US$) the market expects swings of a year; protection against a sizeable fall costs points more than a bet on a rise.
Value a portfolio that doesn't exist, check a trade before making it, watch an LLM read a company filing, or connect your own AI agent.
Build with it
Calseda runs the rest: it fetches the data each calculation needs, and runs it when everything has arrived and again whenever anything moves.
Most workers run inside the server, in Java or Kotlin: the fastest way, since nothing sits between a worker and its data.
// Discovery: what each step finds decides the next request public EntitiesRequest needs() { return new EntitiesRequest() .add("Portfolio", portfolioId) .handler(this::onPortfolio); } private EntitiesRequest onPortfolio(Entities found) { portfolio = (Portfolio) found.get("Portfolio", portfolioId).getData(); EntitiesRequest live = new EntitiesRequest(); portfolio.positions().forEach(p -> live.add("EquityQuote", p.symbol())); live.add("FxRate", "EURGBP"); return live; // no handler: these are the live inputs } // Runs again whenever a live input changes public Result compute(Entities live) { double value = valueInGbp(portfolio, live); return new Result(List.of(new Entity( new EntityKey("PortfolioValuation", portfolioId), value))); }
calseda: ingress: - name: Portfolio adapter: kafka config: { topic: desk.portfolios } - name: EquityQuote adapter: alpaca # per symbol, while needed - name: FxRate adapter: redis # the latest rate per pair config: { keyPrefix: "desk:fx-rate:" } egress: - name: PortfolioValuation adapters: [kafka, console]
class OptionRisk(Worker): """One portfolio's greeks.""" task_type = "OptionRiskTask" needs_types = [Portfolio, OptionQuote] def needs(self): # the portfolio first: its positions say which quotes return self.request(Portfolio, self.pid, then=self.quotes_for) def quotes_for(self, found): positions = found[Portfolio, self.pid].data["positions"] return self.request_many(OptionQuote, [p["instrument"] for p in positions]) def compute(self, inputs): greeks = ... # numpy, scipy, anything return Result(Entity("PortfolioGreeks", self.pid, greeks))
pip install calseda calseda login uat calseda types pull # the server's types, as Python pytest # offline, in milliseconds calseda run option_risk.py
Built in
Connected in a live demo
Anything else, such as a feed, a database, an API or files, connects through an adapter you write.
A guided tutorial builds a live calculation step by step on your own machine, from its first lookup to a result that moves with the market.
We connect your first real source with you, whether Kafka topics, an exchange feed, a REST API or files, and model the calculations that use it.
Reference documentation for every setting and interface, with guidance on running and scaling your servers.
People sign in with your own identity provider, and its roles decide who may do what, so joiners and leavers need no change in Calseda. Run several copies of a server, and if one fails, its calculations move to another within seconds.
Where to start
Running a trading desk? See a deal checked against the live figure: Pre-trade check ↗, or the page for trading desks
A quant or analyst? Python notebooks and Excel, on live data: Build with it
An architect? It runs in your own Kubernetes, beside your Kafka and Redis, and the code stays yours: What's different
In risk or compliance? Every figure's inputs and freshness: Why trust it, or a bank's limits in a demo: Every limit, watched all day ↗
Bring one calculation that runs overnight or lives in a spreadsheet today. Together, we connect it to your data and run it live, with every figure traceable to its inputs.