Automated Treasury And The Three Verbs of Programmable Money

Diana's morning starts the same way it has for years.

Bloomberg at 7am. Check the rate. Decide if it's within range. Call the desk. Get a live rate. Write the reference number down on a Post-it, and wait. Watch the inbox until the SWIFT confirmation lands. If it hasn't arrived by noon, she escalates.

This process takes 90 minutes each morning, 90 minutes that are essentially wasted.

Diana is essentially acting as a human API:

• Quote

• Trade

• Wait for settlement

Over and over again. There is no real reason she should be doing this, for many corridors in the G7 these tasks have been more or less automated for years, but Diana trades in thinner currencies where trades still happen over Telegram.

Quote, trade, settle. Over and over again. These are also the three verbs of programmable money, they are what any API that hopes to free Diana from this drudgery must do well.

So let's look a little closer at each.

Quote

Before money moves at all, someone needs to ask what it will cost, right now.

That's a quote. Not to be mistaken for a price. A price floats, a quote is a commitment: A rate locked for a specific window, attached to a reference ID. It’s the FX equivalent of a shopping cart—nothing has moved, but the item “waits” while you decide.

To do this manually, Diana must refresh her Bloomberg terminal, call her counterparty, and ask whether the 1.083 she saw there is still live. Her validity window is whatever the dealer gives her over the phone or chat. She captures the reference number on whatever stationary she has laying around.

This is the kind of semi-rote task that is well suited for automation.

When crafting an API to handle quoting, your endpoint must only return three things:

• a rate.

• a validity window (typically 30 to 60 seconds).

• a quote ID that serves as the handshake for whatever comes next.

This quote gets requested on a trigger Diana sets based on her strategic priorities and schedule.

Once we have the quote, we’re ready to execute.

Trade

Between getting the quote and confirming it, a few things happen. Diana might field some questions from her counter-party about clip size or timing. Rates might move. The quote might expire and send the process back to the beginning.

Most of this is the result of stale information or delays introduced by manual quoting. Little of this requires Diana making active decisions, it's rote requests and waiting. When multiplied across every trade, every morning, it adds significant friction.

Eventually, Diana reads the reference number to the desk and hears "done," at that point the rate gets locked and the settlement clock starts ticking. Whatever happens next, for good or ill, is up to the market.

An API here serves a dual purpose, it not only speeds the execution itself, but offers data that will help Diana understand the status of the transaction (we’ll discuss that later).

The trade endpoint takes the ID from the quote endpoint, confirms the conversion, and returns a trade confirmation all without the back and forth. This is much smoother, but doesn’t entirely push Diana’s judgement out of the loop, instead it relocates it. She must still set the thresholds that decide which trades are worth making at all.

Settle

Diana watches her inbox until noon. If the SWIFT confirmation hasn't landed by then, she escalates. This is her settlement routine: manual, dependent on her being alert at exactly the right moment, and requiring nothing from her except attention.

The trade already happened. What she's actually tracking is whether the money that was promised showed up, and in traditional FX that's actually really hard to suss out.

If you've read our piece on the anatomy of payments, this might sound familiar. In order for money to make it to its destination, messages need to wind their way through layers of correspondents, across local rails, and be interrogated by regulators.

At any point these processes might fail, either because a bank doesn't have the pre-funded capital to settle, or a regulator notices a discrepancy in naming. If it does, Diana needs to be there to respond.

The problem is that in almost every case, the information she'd need to respond, where the money is, what its precise status is, simply isn't available. Traditional finance is almost entirely opaque, which is where an API can become extraordinarily useful.

A settlement endpoint does what Diana's inbox does, automatically. It initiates the funds transfer and triggers confirmation on delivery. Critically, it also emits status messages to tell Diana where her money is and what is happening.

Despite not necessarily feeling like the most impactful part of the chain, settlement is where the API earns its keep, and grants Diana the data she needs to recover from errors faster and more reliably.

Diana's Morning, Automated

It's Monday again. Diana's dealing with the same corridors, volumes and regulatory pressures.

At 6:02am, the rate crossed the threshold Diana set during the previous quarter. The system called the quote endpoint, received a rate and reference ID, and evaluated both against her parameters. At 6:03, it executed the trade. Settlement initiated automatically. At 6:47, confirmation landed.

Diana got a Slack notification. She was, at that point, working on something that actually required her brain.

This is what quote, trade, and settlement look like when a full life-cycle payments API takes the functions over. The system handles the verbs. Diana focuses on the sentences.

That's what OpenFX's API gives treasury teams: direct access to quote, trade, and settlement endpoints, the building blocks of automated cross-border FX.