Agentic Approaches to Capital Markets

ELI5/TLDR

A “co-pilot” suggests things while you do the work. An “agent” actually does the work for you, inside the system. The S&P Global CTO’s argument is simple: in finance, an agent that gets one thing wrong can break trust permanently, so you can’t just let it loose. The real work isn’t making the AI smarter — it’s three boring things underneath: making sure every system means the same thing by the same word, connecting systems with open standards, and wrapping the whole thing in policies that decide what the agent is and isn’t allowed to do on its own.

The Full Story

This is a podcast conversation between S&P Global’s research chief Eric Hanselman and Krishna Venkatamuri, their CTO for Enterprise Solutions. It’s a vendor talking about a vendor’s worldview, but the spine of the argument is sound and worth pulling out.

Co-pilot versus agent — the unit of work moved

The first useful distinction. A co-pilot sits next to you and suggests; you’re still driving. An agent is in the workflow, carrying the task itself. Venkatamuri calls this a shift in “the unit of work” — from doing an activity to handing over a whole job.

An agent is different. It’s in the workflow. It is carrying the task.

And clients now expect more than speed. They want the agent to “solve the whole estate, and solve the problem next door, and also solve the problem which I haven’t imagined yet.” That ambition is the setup for everything that follows — because the more you hand over, the more it matters when it’s wrong.

Why finance is a harder room

We need to only make a mistake once. That’s good enough to actually lose the trust which we have with the industry.

This is the load-bearing line. In a lot of AI use cases (drafting, brainstorming, summarizing), being occasionally wrong is fine. In capital markets — and he draws the same parallel to healthcare — trust is the entire product, and it’s fragile. So the constraints aren’t a tax someone imposes; they fall out of the nature of the business. He’s honest that some tasks (information synthesis, exploratory research) can tolerate error. The discipline is reserved for actions that touch money or records.

Why agents make things up (and it isn’t the model’s fault)

The most genuinely useful section. When an agent hallucinates, Venkatamuri says it’s almost never the model — it’s one of three data failures:

The ground truth wasn’t retrievable — so the agent invented an answer.
The data was ambiguous — two systems use the same word to mean different things.
(folded into the above) — the agent guessed at the meaning and guessed wrong.

His example: words like instrument, counterparty, exposure, position mean subtly different things in different internal systems. Connect those systems and let an agent roam, and it confidently merges things that shouldn’t be merged.

The fix he proposes is an ontology — and he’s careful to say it’s not a data dictionary. Think of it like this: a dictionary lists what words mean; an ontology is a machine-readable map of every entity and how they relate to each other, so every agent stands on the same conceptual ground. He name-checks two existing open standards so nobody has to invent this — the Common Domain Model (now under FINOS) and FIBO (the Financial Industry Business Ontology). Map your messy internal data onto a shared model, expose it through that model, and your agents stop inventing.

But to be fair, this is boring work for most people. But this is the foundation of how… you get the most exciting work later.

That’s the honest core of the episode: the unglamorous plumbing is the actual moat.

Autonomy is the wrong question

A nice reframe. The industry obsesses over “how autonomous can the agent be?” Venkatamuri thinks that’s noise. The real question:

How much of responsibility do we want to safely hand over to an agent?

He tells the one concrete story in the whole conversation. His team built a demo — “wickedly cool,” lit up the room — and then he asked the unglamorous questions: how do I know its actions are right? Where do I put a stop? Where’s the boundary it can’t cross? His lesson: the leverage isn’t in making the agent cleverer, it’s in the envelope you bound it to — evaluation, regression tests, monitoring for behavioral drift, and a security model (prompt injection, data leaking across boundaries are real attack surfaces).

The mechanism is policy-based governance, using OPA (Open Policy Agent — an open-source tool for writing rules that approve or block actions). Low-risk steps the policy lets the agent do alone; something like a settlement transaction the policy routes to a human. So the agent is autonomous inside the fence and controlled at the edges. He’s refreshingly blunt that this is never finished — every new case needs a new rule, and “it’s never going to be 100% complete.”

Build versus buy

His rule of thumb: rent the commodity, build the IP. Don’t build a frontier model — rent it, keep models swappable, because today’s best model isn’t tomorrow’s and prices keep falling. Build the things that make you unique: the knowledge graph, the systems of record and how you orchestrate them, the business flow, the policy, the semantics.

A connection without a shared meaning is just plumbing.

That’s his closing image, and it ties the whole thing together: connecting systems is easy; agreeing on what the data means is the hard, valuable part.

Key Takeaways

Co-pilot vs agent: a co-pilot suggests while you work; an agent takes the task into the workflow itself. The “unit of work” handed over gets bigger.
The one-mistake rule: in capital markets (and healthcare), a single wrong action can permanently break trust — which is why governance is structural, not optional.
Hallucination is usually a data problem, not a model problem: either the ground truth wasn’t retrievable, or the same word meant different things in two systems.
Ontology ≠ data dictionary: an ontology is a machine-readable definition of every entity and its relationships, so all agents reason on common ground.
You don’t have to invent the ontology: open standards already exist — Common Domain Model (under FINOS) and FIBO.
Supporting architecture: map data to the common model → expose it → overlay policy (OPA) so every action is governed and auditable → use a data mesh so each domain owns its own data (handles jurisdictional restrictions).
Reframe autonomy: don’t ask “how autonomous?” — ask “how much responsibility can I safely hand over?”
The leverage is the envelope, not the cleverness: evals, regression tests, drift monitoring, and a security model bounding the agent matter more than a smarter agent.
Deterministic + non-deterministic by design: policy decides which steps run unattended and which need a human in the loop (e.g., settlements).
Build vs buy: rent the frontier model (keep it swappable, prices falling); build the IP — knowledge graph, systems of record, orchestration, policy, semantics.
Agent attack surface is real: prompt injection and data leaking across boundaries are named threats, not hypotheticals.

Claude’s Take

The skeleton here is genuinely good and the boring-plumbing thesis is correct: in regulated finance, the value really is in semantics and governance, not in whichever model is hot this week. The three-causes-of-hallucination breakdown and the “autonomy is the wrong question” reframe are both worth keeping.

But read it for what it is — a CTO podcast, which is to say lightly disguised positioning. Notice the rhetorical move: the problem is framed exactly as the layer S&P Global wants to sell (ontology, governance, the connective tissue), while the part anyone can rent (the model) is dismissed as a commodity. That’s convenient, and also probably true, which is what makes it persuasive. The transcript is also rough — phrases like “agent TKI,” “between necessarily folded up,” and “eight-time trade-off analysis” are mangled auto-captions, so some precision is lost.

There’s almost no specificity about results — no numbers, no failure rates, no before/after. The one concrete moment (the cool demo that couldn’t ship) is the most honest thing in the episode, and it’s an admission, not a case study. Everything else is principle. Useful principles, but principles you could apply to any regulated industry; “capital markets” is barely load-bearing beyond the counterparty/position example.

Score: 6. A clear, well-organized articulation of how to think about agents in a trust-critical setting, with two or three ideas worth carrying. Marked down for being a vendor’s framing with zero evidence and a fair bit of marketing gravity. If you’ve already internalized “governance and data semantics are the hard part,” you can skip it; if you haven’t, the first half earns its 24 minutes.