From Terminals to Agents: The Hidden Infrastructure Shift Reshaping Financial Data
For decades, the financial terminal has shaped how professionals interact with markets. It bundles data, analytics, workflows, permissions, and interface into a single, fixed desktop. To “have access” to financial data still often means sitting in front of one.
Not because terminals stop working, but because the economics that support them are beginning to fail. The cost of building tailored interfaces has collapsed, workflows are increasingly specialised, and the assumption that one interface can serve all use cases is no longer credible. As desktops unbundle, so do feeds and APIs—and beneath that unbundling, a new requirement is emerging: a normalisation layer that works not just for people, but for applications and autonomous agents.
Bundling No Longer Matches Reality
The terminal model reflects a world in which software is expensive and slow to change. In that environment, bundling makes sense. One interface serves many roles. Normalisation is implicit, hidden inside the product. Identifiers, timestamps, schema decisions, and business logic are resolved centrally.
But today, roles are narrower. Workflows evolve quickly. Expectations around flexibility, integration, and speed are far higher. Teams no longer want to reshape their work to fit a static interface.
The Cost Curve Has Flipped
At the same time, the economics of building applications have shifted dramatically.
Cloud infrastructure, modern front-end frameworks, and API-first design mean small teams can now build sophisticated financial tools in weeks that previously took months.
As that trade-off flips, unbundling accelerates. Firms increasingly assemble tools around workflows rather than bending workflows to fit products.
Fragmentation Is Intentional
The financial “desktop” is no longer a single application. It is a composition of internal tools, third-party services, data feeds, and automated processes stitched together around specific tasks.
Some tools are short-lived. Others never present a screen at all. Increasingly, the consumer of data is not a person, but a process.
This fragmentation is not a failure. It reflects how work happens today: asynchronously, across systems, and increasingly through automation.
When the Interface Stops Normalising
In bundled systems, normalisation happens invisibly. Users rarely encounter inconsistencies because the interface reconciles them. Identifiers align. Schemas are fixed. Business logic is embedded.
As data flows directly into applications, feeds, and agents, that burden moves downstream. Every application now faces the same questions repeatedly: which identifier is canonical, what a metric really represents, how timestamps align, how corporate actions are reflected. In traditional development, these issues are resolved once during integration. In agent-driven systems, they occur continuously at runtime.
Speed Unlocks Choice—and Risk
Firms are actively building internal GPTs, copilots, and narrow agents. Applications that once required months of design and development are now assembled in days or even hours. Often, the “app” is little more than orchestration plus access to data.
This is liberating.
Teams unlock internal datasets that were previously underused because surfacing them through traditional applications was slow or impossible. They experiment with external data sources that would once have been dismissed as too risky or uneconomical to integrate. But speed also exposes weakness. Poorly normalised, weakly documented data does not fail at onboarding—it fails at runtime, when agents must interpret it repeatedly.
Feeds and APIs Are Not Agent-Ready
The same problem extends beyond desktops to the feeds and APIs that underpin modern workflows. Most APIs were designed as programmatic wrappers around products built for humans. Pricing models reflect that heritage: fixed entitlements, coarse usage tiers, predictable access patterns. Agents break those assumptions.
Agents query continuously and non-linearly. They explore, cross-reference, re-query, and reason. Yet many feeds still assume downstream intelligence—delivering raw or lightly structured data and expecting the consumer to normalise, reconcile, and calculate.
For agents, that burden is costly. Every ambiguity forces inference. Every missing calculation requires recomposition. Reasoning consumes tokens, latency, and compute. Normalisation done on the fly becomes a recurring operating expense.
Protocol Is Not Enough
The push to make data “agent-accessible” often focuses on protocol rather than substance. Adding an MCP server may make data callable, but it does not make it usable.
If the underlying feed is poorly normalised or ambiguously defined, the agent inherits that complexity wholesale. MCP becomes a transport layer, not an enablement layer.
Some vendors respond by layering additional fees for agent usage. That may be commercially justified. But charging more for inefficient data simply makes inefficiency more expensive.
Normalisation Becomes an Economic Control Surface
Agents expose inefficiencies humans can absorb. A human analyst compensates for ambiguity. An agent cannot without explicit instruction. Every inconsistency becomes a branch in a reasoning tree. Every extra step compounds cost and latency. As firms deploy more agents, inefficiency scales multiplicatively.
This is why normalisation must move upstream.
Rather than living inside interfaces or being rebuilt in every application, normalisation increasingly needs to exist as a dedicated layer: consistent identifiers, explicit semantics, predictable schemas, and—where it adds leverage—pre-calculated analytics.
Where This Is Heading
The centre of gravity in financial technology is shifting away from owning interfaces and toward enabling composition.
Interfaces will continue to fragment, and that is healthy. The enduring value lies beneath them: in data that is normalised, interoperable, and usable by both humans and machines.
The terminal is not disappearing. But it is no longer the organising principle of financial markets. As agents become first-class consumers of financial data, normalisation is no longer an implementation detail. It is becoming the foundation.
This is an article from The Financial Technologist: Influence List - page number: 76-77
