C_W

What finance looks like when software becomes an actor

When software can act on money, not just record it, the hard questions stop being technical and become about permission and accountability.

Topic
Finance
Reading
2 min

For most of its history, financial software has been a ledger with a user interface. It records what people decided. Someone approves the payment, someone places the trade, and the software keeps track.

Software can now propose, decide and act. It can move funds when conditions are met, rebalance a portfolio, or respond to a request at three in the morning. Checking that the numbers are right is no longer enough. You also have to know who, or what, was allowed to act.

From records to decisions

Payment rails with APIs made the first step possible. Software can move money directly, under rules written next to it instead of in a separate process. Models add the second step, software that can read a situation and choose an action within those rules.

Put the two together and you get an actor. It is more than a tool and less than a person, and it holds permissions and uses them.

Designing the permissions

When software acts, the interesting design problem is the permission model:

  • Scope. What exactly may it do, with how much, and for how long?
  • Limits. Hard caps that no instruction can override, enforced where the money lives, not in the prompt.
  • Approval. Which actions need a human, and how that human sees enough context to say yes quickly and safely.
  • Undo. Money often can’t be pulled back, so the checks have to happen before the action, not after.
Diagram
flowchart TB
  R["Payment rails with APIs<br/>money software can move"] --> A(("An actor"))
  M["Models<br/>read a situation, choose an action"] --> A
  A --> S["Scope<br/>what, how much, how long"]
  S --> L["Limits<br/>hard caps where the money lives"]
  L --> Q{"Needs a human?"}:::lit
  Q -->|no| X["Act"]
  Q -->|yes| H["A person, with enough context"] --> X

Good financial infrastructure already treats people this way. Delegated access, spending limits and multi-party approval are old ideas. The new part is applying them to something that acts at machine speed and never gets tired.

Accountability stays with a person

Regulation doesn’t care whether a person or a program made the call. Someone is still responsible. That’s healthy, because it forces a clear line between what the software proposes and what an accountable party authorises.

The systems that work will make that line visible. Every action traces to a permission, every permission traces to a person, and the log can go to an auditor without being rewritten first.

Open questions

  • How much autonomy will customers actually want over their own money, once it’s on offer?
  • What does a useful audit trail look like for a decision made by a model?
  • Where should limits live: in the model, the application, or the asset itself?