calseda

Every figure its own live calculation, rerun only when its inputs change.

Exposure per counterparty or collateral per account: Calseda keeps each one current the moment its data changes, and opens each to its full lineage, down to the raw data. Your quants or developers write the formula in Java or Kotlin, or Calseda calls the engine you already have. Calseda finds the data and recalculates only what changed.

Each portfolio or counterparty gets its own worker

A worker is one long-lived calculation. In the scene, workers value portfolios and check their risk.

sources workers results

Each worker works out what it needs from the data

A portfolio first, then the prices of what it holds. Each answer decides the next question.

Each worker subscribes only to the data it needs

Feeds open when the first worker needs one, and close when none does.

A worker recalculates when one of its inputs moves

Only the answers that depend on the change, on the latest values.

Results feed other calculations

An exposure feeds a limit check. A result is just more data.

Ask "what if?" from a browser

A page submits a personal what-if. A worker starts for it and streams results to that page alone until it closes, so a pre-trade check needs no new service.

The desk demo runs one worker per portfolio

It values client portfolios, each in its client's currency. Open any figure to see the exact prices and rates behind it, or build a what-if portfolio of your own.

Which part of this page is for you?

A quant or analyst? You write the calculation, and the framework keeps it small: who writes the calculation

An architect? It runs in your own Kubernetes, on your Kafka, and the code stays yours: where it runs

In risk or compliance? Every figure's inputs and freshness: where each figure came from

Running a trading desk? A deal checked against the live figure: Trading desks: pre-trade checks

No new service per question, and no glue code per calculation

TodayWith Calseda
A new question Every "what if?" becomes a project. A personal 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. Built into Calseda. A calculation is a few lines of business logic.

No backlog on the busiest minute of the day

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.

Every figure Calseda calculates shows where it came from

Calseda keeps the answer to "why is it this, and is it current?" with the figure.

Open a figure down to its raw data

Open any figure and see its full lineage, down to the raw data, with when each input's data is from and when it arrived. Export it as a report (PDF), or as data (JSON, or CSV for Excel). A figure can carry a written explanation of how it is calculated, shown beside it and printed in the report.

Results resting on stale data are flagged

Each source says how fresh its data should be, trading hours included, and Calseda flags results that rest on data gone stale.

A change reaches the results in milliseconds, plus your engine's own time when Calseda calls one, and Calseda measures that time for every change, across servers. You can also set a pace per figure: the risk demo recalculates its exposure at most once a second.

The console shows each failure as it happens, and Prometheus metrics are built in. The last 10 runs of each task download as recordings to test with.

Built first for banking, and fits wherever many figures each follow their own data

Calseda started where figures move every second and each may have to be explained. The same pattern fits wherever many things each need their own live answer from their own slice of the data: credit risk, trading desks, energy trading and sports betting.

Your traders keep Excel. The figures stop being copies.

Live figures in a cell

A value or a what-if answer updates in the sheet as its inputs change.

Overrides sent back with checks

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 through your identity provider, so there is no Excel code to write. The calculations stay on the server, where they are tested and traceable.

AI agents read your live figures with their sources, and change only what their sign-in allows

An agent signs in as the person it works for, and anything it enters is marked as entered by an AI agent for that person. It cannot overwrite incoming data or results.

Agents connect over MCP without integration code

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, so it can't flood the server.

A language model reads each document once

A worker can call a language model to read a filing or a report. The answer fills in a fixed form, checked before anything uses it, then stored and shared by every calculation that needs it, so model cost grows with documents, not users. Ordinary workers do the arithmetic.

Your quants write the calculation, and the framework keeps each one small

Quants and analysts who work in Java or Kotlin write production calculations themselves. Those who work in Python try theirs on the live data, then hand it to your developers to make it production code.

Left to build a live system alone, an AI coding assistant writes connections, caches, retries and threads as well as the formula, a little differently each time, and its assumptions end up buried in that code. On Calseda it fills in the same small shape a person would: the formula and the data it needs. Calseda already handles the data, timing, retries, sign-in and lineage.

Experiments can't touch production figures

A model tried from a notebook on the live data stays a draft. Moving it into production is a deliberate step, through your own change controls.

Slow or wrong code shows up in the console

The console shows each calculation's inputs and how long it takes.

Every project the same shape, so the tenth is as clear as the first.

In bespoke systems each project grows its own way of connecting and retrying, and your IT team carries every one. On Calseda your IT team runs one framework, and a new figure is a new calculation, not new infrastructure.

Connections are adapters, written once

An adapter only moves data. Kafka and Redis come built in, and a web API needs only configuration. Write any other adapter once, and every project names it in its configuration.

Each new calculation has a working example beside it

A developer or an AI assistant follows a pattern instead of inventing one. Whoever knows one project, a newcomer or the person on call, can find their way around all of them.

Use a stream processor for event windows, and Calseda for long-lived calculations

A stream processor pushes every record through one pipeline, fixed when it is deployed. Calseda gives each portfolio or counterparty its own calculation, which finds its inputs from the data and rewires when that data changes. What a stream processor writes to Kafka can be one of Calseda's inputs. For the other alternatives, and when each is the better choice, see how Calseda compares.

Ledgers belong on exactly-once systems

Calseda keeps the latest value, so it is 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.

You write the lookups and the formula

Calseda fetches the data each calculation needs, and runs it again whenever an input moves. Or keep your engine and call it from compute(): per task type you set how long a run may take and how many run at once, and a failed run is retried while the last good result stays published.

Most workers run inside the server, in Java or Kotlin: the fastest way, since nothing sits between a worker and its data.

ValuationWorker.javasimplified from the trading desk example
// 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)));
}
application.yamlwiring, not code
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]

Kafka, Redis, REST and MCP are built in, and a dozen public sources run in the demos

Built in and supported

  • Apache Kafka
  • Redis
  • REST
  • MCP
  • Prometheus
  • Kubernetes

Connected in a live demo

  • Alpaca
  • Coinbase
  • Kraken
  • Bitstamp
  • Deribit
  • ECB
  • New York Fed
  • US Treasury
  • SEC EDGAR
  • GLEIF
  • OpenFIGI
  • FDIC

From a first worker to production, with our support

1. Build a first live worker with the tutorial

A guided tutorial builds a live calculation on your own machine, from its first lookup to a result that moves with the market.

2. Connect your own data

Your team connects your first real source, such as Kafka topics, a REST API, a database or files, and writes the calculations that use it. We support them where needed.

3. Take it into production

Guides and reference documentation for running your servers, on Kubernetes and with high availability.

4. Run it in daily use

People sign in with your identity provider, and its roles decide who may do what, so joiners and leavers need no change in Calseda.

Everything runs inside your environment

Calseda apps run as containers on your own platform, beside the systems they read from. In production they run on Kafka, which shares the work between them and moves a failed machine's work to the others in seconds; a first figure on one instance doesn't need it. Everyone who reads a figure signs in through your identity provider. Nothing calls back to Calseda, and no data is sent to us.

Where Calseda runs: everything inside your own environmentYour environmentYour identity providerEntra ID, Okta, Keycloak, Google and otherssign-in and roles, for every readerCalseda apps, as containers on your own platformCredit riskScreeningLiquidityTrading deskKafkaShares the work, and moves it when a machine failsYour dataTrading and booking systemsMarket data and pricesPositions and paymentsReference data and listsYour engines and modelsCalled when their inputs changeWhere the figures goBrowser pages and the consoleExcelPython notebooksAI agentsTeams, Slack and webhooks Where Calseda runs: everything inside your own environmentYour environmentYour data and your enginesTrading and booking systemsMarket data and pricesPositions and paymentsReference data and listsYour engines and modelsCalled when their inputs changeCalseda apps, as containers on your own platformCredit riskScreeningLiquidityTrading deskKafkaShares the work, and moves it when a machine failsYour identity providerEvery reader signs in; roles decide what they seeWhere the figures goBrowser pages and the consoleExcelPython notebooksAI agentsTeams, Slack and webhooks
Inside your environment: your data (trading and booking systems, market data and prices, positions and payments and reference data and lists) and your engines and models feed the Calseda apps, which run as containers on your own platform with Kafka beneath them. Your identity provider signs in every reader. The figures go to Browser pages and the console, Excel, Python notebooks, AI agents and Teams, Slack and webhooks.

Bring one calculation that runs overnight or lives in a spreadsheet

Become a design partner: one of your figures live in about six weeks, for a fixed fee, built by your developers or quants with our support. At the end you keep the framework, licensed to run what you built on one server.