The trading and risk platform
you can own, audit, and extend.
OpenTRMS runs the full trade lifecycle for FX, money markets, derivatives and fixed income — with an immutable audit trail and an AI control room that works inside your existing controls. Self-hosted, with every number reproducible from its inputs.
20 short videos of the real system — start with Getting started.
A trading platform that answers to four people at once.
TRMS decisions don't get made by one team. OpenTRMS is built so each stakeholder gets a clear, defensible answer — not a feature checklist.
Replace your TRMS instead of renewing it.
Mainstream, boring, hireable technology — nothing exotic to staff for. Your stack, your roadmap, your cost base: infrastructure and the team you already have, instead of per-seat metering that reprices at every renewal.
See the extension model Treasury & front officeCapture any product. Settle any way. See the book in real time.
FX, money markets, IRS, bonds, repos and structured deals on one ledger. Traders book in seconds; ops moves on without re-keying.
See asset coverage Risk, audit & controlEvery change is immutable, attributed, and replayable.
Event-sourced from day one. The history is the system of record, so the evidence a reviewer asks for is already there — attributed, timestamped, and reproducible on demand.
How the audit trail works CISO & securityRead the code. Host it yourself. Control your data plane.
Open-source code you can audit line by line. Run it air-gapped, in your VPC, under your IAM. Nothing calls home, and nothing about your deployment is visible to us.
Audit the codeOne ledger for everything your treasury actually trades.
Partial coverage is what pushes the remainder of the book into spreadsheets. OpenTRMS books FX, money markets, fixed income and derivatives against the same event store, so positions, P&L and exposure stay consistent without nightly stitching.
Rates
- ›
- ›
- ›
- ›
- ›
- ›
FX
- ›
- ›
- ›
- ›
- ›
Credit
- ›
- ›
Equity
- ›
Instruments
- ›
- ›
- ›
- ›
One position model. One P&L. One audit trail — reconciled by construction rather than at end of day.
Follow one trade from capture to closeout.
What a trading platform is worth shows in the path a deal walks every day. Here is that path on OpenTRMS, told from the seat of the person who does the work.
- 01
Captured
Front officeA trader books a 5Y USD interest-rate swap with ABC Bank. One screen, one click — or one sentence to the AI desk assistant.
- 02
Validated
STP engineLimits, counterparty, product schema and credit checks run in milliseconds. Eligible trades flow through; exceptions stop and explain themselves.
- 03
Approved
Middle officeA scoped approval chain routes the trade to the right desk head. Self-approval is structurally impossible, and every signature is recorded as an event.
- 04
Confirmed
OperationsConfirmation flows out, the deal is locked, and the position updates on the trader's blotter and the risk desk's exposure view at the same time.
- 05
Settled
Treasury / settlementsNetting collapses cashflows by counterparty and currency. Payment messages (MT103/MT202) are generated and dispatched on schedule.
- 06
Accrued & valued
Finance / riskEnd-of-day rebuilds curves, accrues interest, marks the book to market and posts journals — every step is an event you can replay.
- 07
Closed out
Back officeAt maturity or termination, rule-driven matching offsets positions and the deal walks cleanly off the book — with the full history intact.
Behind every state change: a typed event, an immutable hash, an authorised user, a correlation id. Reconstructing what happened on any day, for any deal, is a query — not an investigation.
Your audit trail isn't a report. It's the platform.
Most TRMS vendors bolt audit tables onto a CRUD database and hope. OpenTRMS is event-sourced from the first commit — the history of every deal is the deal. Audit, control and risk teams get the answer they actually want: a single, attributed, replayable timeline.
-
Nothing is overwritten — ever.
Every state change appends a new event. The history of a deal is the deal — there is no separate change log to request, because the record is nothing else.
-
Tampering breaks the chain, visibly.
Every event is hashed and linked to the previous one. Insert, delete or modify any record and the chain refuses to reconcile, so a silent edit is detectable rather than deniable.
-
Immutability enforced by the database, not by trust.
UPDATE and DELETE on the event table are revoked at the database level. Application bugs cannot rewrite history. Neither can a misbehaving DBA.
-
Every action is attributed.
User, scope, correlation id and timestamp are part of the event. "Who approved this?" is a one-line query.
-
Replay any day, on demand.
Rebuild the book as it stood at any point in time. Reconcile to a regulator, run a what-if, or unblock a dispute — without freezing production.
A live hash chain
An operations control room that works the night shift — inside your controls, on the record.
Agent autonomy is a model-risk question before it is a productivity one. In OpenTRMS every agent action is scoped, logged and reversible: agents call the same domain services a person does, under the same permissions and approval chains, and stop the moment they reach a limit. What they earn you is the boring half of trade ops — chasing breaks, pulling confirmations, summarising P&L moves.
-
Agents that go through your controls, not around them.
Every agent calls the same domain services as the REST API. Same scopes. Same approval chains. An agent cannot do anything a user with its scope couldn't do — and every call it makes is attributable after the fact.
-
Human-in-the-loop where it matters.
The agent proposes; the human approves. Material actions never auto-execute, and every proposal is recorded as an event — including the ones you rejected, which is the evidence your model-governance review will ask for.
-
Plug into your AI stack, not ours.
Built-in MCP server: any MCP-compatible client (Claude, internal agents, Copilot-style IDEs) talks to OpenTRMS out of the box. No bespoke connectors, no proprietary protocol.
-
Your data stays where it is.
Self-hosted. Bring your own model. The agent runtime sits next to your event store — not in a vendor cloud you don't control.
$ opentrms ops review --book G10-RATES
› Anything I should look at before EOD?
Agent:
3 trades exceed the +/-2σ price band on the desk:
#45215Y USD IRS · ABC Bank · +3.1σ
#45442Y EUR IRS · DEF Sarl · −2.4σ
#456110Y GBP IRS · GHI plc · +2.8σ
Flag for review? [Y/n] Y
✓ 3 deals routed to Head of Rates
✓ Events appended · correlation b3f9e1
$
Closing the day shouldn't be a leap of faith.
EOD is where most TRMS deployments quietly fall apart — partial runs, mystery breaks, finance and risk arguing over whose number is right. OpenTRMS runs EOD as a sequence of attributable events, each one reproducible from the same audit trail your auditors will read.
Cut-off
Cut-off lands and the desks stop booking. The system snapshots the book at a single, attributable point in time, so every downstream number shares one agreed "as of".
Curves & rates
Fixings come in. Discount and projection curves rebuild from that snapshot. Every input is recorded; every output is reproducible.
Accruals
Interest accrues on every open position. Finance gets numbers that tie back to specific trades on specific days, down to the cashflow.
Mark-to-market
The whole portfolio is valued: IRS, FX, bonds, options. Greeks, DV01, PV01 fall out of the same model your trading desk used yesterday.
Journals & margin
Posting rules turn valuations into journal entries; margin is calculated against the same numbers. Finance and risk see the same truth.
Settlements
Cashflows are netted by counterparty and currency. Payment messages are produced and queued, ready for SWIFT or your bank rails.
Sign-off
Every step is an event, including the ones that were retried or ran late. The next morning's regulatory report is pulled from that same trail.
One trail from cut-off to sign-off. If something needs to be re-run, it's a replay — not a rebuild.
Your models and your rules run inside the platform.
Every bank prices something its own way. In most systems that means a fork, a consulting engagement, or a spreadsheet nobody can audit. OpenTRMS exposes a versioned extension contract instead: write the piece that is yours in Python or Java, hand it to the platform, and upgrade the platform underneath it without touching your code.
Seven places your code plugs in
The whole surface is this small on purpose. Interfaces are tiered — frozen, stable or evolving — and a compatibility kit checks yours against the tier before it ships.
@SpiStability(StabilityTier.STABLE)
public interface ProductValuator {
boolean supports(Deal deal);
Valuation valuate(ValuationRequest request);
}A structured payoff as a plain function. Python runs embedded — no service to deploy, no network hop — so quants ship models without waiting on a platform release.
def _cash_amount(notional, index_rate, spread,
floor_rate, cap_rate, dcf):
effective_rate = _decimal(index_rate) + _decimal(spread)
effective_rate = max(effective_rate, _decimal(floor_rate)) # floor
effective_rate = min(effective_rate, _decimal(cap_rate)) # cap
return (notional * effective_rate * _decimal(dcf)).quantize(CENTS)
def generate_cashflows(deal_json: str) -> str:
deal = json.loads(deal_json)
details = deal["details"]
# ... one dict per coupon, returned as JSON
return json.dumps({"cashflows": cashflows}, sort_keys=True)Custom code, under the same control as everything else.
A plugin is an artifact with a lifecycle, not a file someone dropped on a server. It is uploaded, reviewed, approved and activated — and every one of those steps is attributed in the same audit trail as a trade.
A pilot you can stand up in an afternoon.
No multi-month implementation project, no rooms full of consultants. Clone the repository, bring up the stack with Docker, and book your first trade against a real ledger.
See the system before you commit a line of code.
Twenty short videos recorded against the running system — deal capture, lifecycle events, the audit trail, EOD batch and the AI control room. Screen recordings throughout, so you are judging the software rather than a deck.
Open source · No license metering · Self-hosted from day one