Module 16: The Agent Landscape

MGMT 675: Generative AI for Finance

Kerry Back, Rice University

Why Agents?

Questions to Ask

Before building an AI agent, consider the alternative — a conventional app with menus, dropdowns, and input fields.

  • Can users get what they need by choosing from menus? Could you enumerate all the options upfront?
  • How many screens or clicks would it take? If the menu tree is deep or the combinations are many, complexity explodes.
  • Would users need training to navigate it? If the interface needs a manual, something is wrong.

If a conventional UI can cover 90% of use cases simply, you may not need an agent. Agents earn their keep when the task is open-ended or hard to anticipate in advance.

Test Case: Exercise 4B

Exercise 4B asked you to build a chatbot that lets users query an M&A database in plain English — 200 transactions across three tables (transactions, advisors, financing).

Sample queries: “What are the five largest completed deals?” · “Which banks advised the most deals?” · “What is the average EV/EBITDA multiple for tech acquisitions?”

Could a conventional app replace this?

  • Yes, mostly. Dropdown filters (year, sector, deal type, advisor) plus a results table would handle most of those queries — no AI needed.
  • But not entirely. The chatbot shines for ad-hoc, unanticipated questions that don’t map to pre-built filters.

The more open-ended and unpredictable the user’s needs, the stronger the case for an agent.

Agents Are Replacing Dashboards

Dashboards are the traditional way to make data accessible to decision-makers:

  • Someone builds a set of pre-defined views — charts, tables, KPIs
  • Users can filter and drill down, but only along dimensions the designer anticipated
  • Adding a new question means asking a developer to build a new panel

An agent does the same job — surfaces data for decisions — but without the constraints:

  • Users ask questions in plain language, including questions no one anticipated
  • The agent writes and runs its own queries, so it adapts to whatever the user needs
  • No developer needed to add a new view — the agent builds it on the fly

Dashboards answer the questions you planned for. Agents answer the questions you didn’t.

Where Are Agents Headed?

Agent Harnesses

Everything surrounding the model — except the model itself — is called the harness. The harness has three main parts:

Orchestration

  • Model invocation
  • Tool selection and routing
  • Multi-step reasoning loops
  • Multi-agent delegation

Infrastructure

  • Code execution
  • Session state and memory
  • Error recovery
  • Persistent storage

Governance

  • Who can use the agent and what can it do
  • Logging what happened and why
  • Rules for handling sensitive data
  • Human approval for high-stakes actions

For 18 months, teams built this themselves using open-source frameworks or custom code. Now the AI vendors are shipping it as a product.

The Harness Pricing War

Five Vendors, Three Pricing Models

As of April 2026, every major AI vendor has shipped its own harness — but they disagree on pricing:

Provider Product Launched Pricing Model
Anthropic Managed Agents Apr 2026 $0.08/session-hour + tokens
OpenAI Agents SDK (open source) Mar 2025 Tokens only, no runtime fee
Google Vertex AI Agent Engine Apr 2025 Per-component consumption
Microsoft Foundry Agent Service May 2025 Per-model + per-tool consumption
AWS Bedrock AgentCore Oct 2025 Runtime primitives (coming)

Anthropic bundles everything into a session-hour fee. OpenAI gives away the harness and charges only for model usage. Google and Microsoft meter individual components. These are fundamentally different bets.

Karpathy’s Dobby: A Case Study

Andrej Karpathy built an agent called Dobby that replaced six separate smart home apps with a single WhatsApp conversation.

Before: The App Archipelago

  • Sonos app for music
  • Lutron app for lights
  • Ecobee app for thermostat
  • Shade controller app
  • Pool controller app
  • Security camera app
  • Six logins, six interfaces

After: One Conversation

  • “Dobby it’s sleep time”
  • Lights off, shades down, thermostat adjusted, music stopped
  • All through WhatsApp
  • Agent discovered devices autonomously
  • Reverse-engineered undocumented APIs
  • No configuration files needed

The method matters more than the demo. Dobby didn’t use pre-built integrations. It scanned the local network, found devices, and figured out how to control them — like a developer learning a new codebase.

From GUI to LUI

Dobby illustrates a deeper shift: from Graphical User Interface to Language User Interface.

The apps don’t disappear — but the user never touches them. The agent becomes the universal interface layer between people and software.

Interface Collapse

  • One conversation replaces many apps
  • The agent picks the right tool
  • Users describe intent, not actions

Nuance Over Sliders

  • “Too loud for conversation”
  • “Rebalance conservatively for retirement”
  • Natural language captures context GUIs can’t

APIs Over UIs

  • Competitive advantage shifts to API quality
  • Agents consume APIs, not interfaces
  • Robust API > beautiful dashboard

Access Democratized

  • Describe what you want in plain language
  • No need to know which menu or function
  • Junior analyst = senior analyst in tool access

Isn’t Claude Code Already a Universal Agent?

Claude Code already does the Dobby pattern: you describe what you want in natural language, and it picks tools, runs code, queries data, writes files.

So why do we need agent software development kits (SDKs) and managed runtimes?

Claude Code / Desktop

  • You’re in the loop, approving and steering
  • Runs on your machine, in your session
  • Single user, interactive
  • Perfect for knowledge work: data analysis, document analysis, building things

Agent SDKs / Managed Agents

  • Runs autonomously — no one at the keyboard
  • Runs in the cloud, 24/7
  • Serves many users with different permissions
  • Embedded in products (CRM, trading platform, compliance system)
  • Triggered by events, schedules, or other agents

Claude Code is the universal agent for interactive work. The SDK layer is for agents that act on their own — overnight compliance monitoring, auto-triaging customer tickets, or a research agent that runs while you sleep.