# AI Cut Our Research Time From 7 Days to 15 Minutes — Gareth Yoder, Vanguard

Gareth Yoder, Vanguard

[Talk page](https://ai.engineer/talks/uA4ah-dVHvU-ai-cut-our-research-time-from-7) · [Video](https://www.youtube.com/watch?v=uA4ah-dVHvU)

## AI Cut Our Research Time From 7 Days to 15 Minutes

Gareth Yoder explains how Vanguard modernized a cash ledger through parallel data, producer, and consumer migrations—and made its legacy code and migration guidance available to AI tools.

![Yoder reports the research feedback loop falling from seven days to 15 minutes.](https://ai.engineer/api/talk-essay-media/73ed766cba5e03d832e01d428cb0db53c29e5dc7294010ebe321a44cf849a5da)

Yoder reports the research feedback loop falling from seven days to 15 minutes.

### A ledger to modernize while it keeps moving

[0:12](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=12s)

Vanguard’s cash ledger tracks money moving into brokerage accounts and between accounts, across payment rails such as ACH and wires. It serves web, mobile, and batch channels in an active-active, multi-region system. Gareth Yoder, the cash program’s technical lead, says its services receive up to 30 million calls a day and clients generate half a million ledgers daily.

![He introduces the three parallel migration pillars.](https://ai.engineer/api/talk-essay-media/bfbcaf9d6b37eba7e22fb540b184e810d44794ae8fe08b1ff16367163d3a6f39)

He introduces the three parallel migration pillars.

After the 2022 launch of Cash Plus, the program took on modernization as an enterprise priority. Data, producers that write it, and consumers that read it all had to migrate in parallel. That made understanding the existing system an immediate dependency: engineers and architects needed to work out what the new data schema should contain.

Initially, answering a legacy-code question meant asking a mainframe engineer to investigate and return with an analysis. Once the codebase became available to AI tools through an MCP server, the team could prompt the tool directly. Yoder reports that a research feedback loop fell from seven days to 15 minutes. The comparison describes the team’s experience with that research loop; it does not establish that every answer or migration task took 15 minutes.

### Move the data and check the details

[3:11](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=191s)

The data migration used change data capture (CDC), followed by daily scans of the legacy and cloud databases. The team compared row counts, then checked individual attributes: amounts, account information, and state and federal withholding. The distinction matters: matching counts can reveal missing or extra rows, while column comparisons can reveal records whose contents differ.

![He describes checking individual attributes across the legacy and cloud databases.](https://ai.engineer/api/talk-essay-media/76e74bda5841dcd9dd0015c83af51788598cf91a11b4f9a4a7a77d364216a164)

He describes checking individual attributes across the legacy and cloud databases.

Yoder cautions against over-engineering the audit solution. Its job was to support the transition, and the code would be deprecated when modernization was complete. The checks provided migration evidence; matching counts alone would not establish that every value matched.

### Make writes visible and give producers a migration path

[4:12](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=252s)

How did the old write paths compare with the new one? Legacy producers used a service request, an API wrapping that request, or direct table inserts. Direct inserts were particularly troublesome: data appeared in the database without the team necessarily knowing who had produced it. The new design placed a common data schema on a gateway wrapping the APIs that insert cloud data, giving producers a defined route into the modern system.

![He describes the gateway wrapping the cloud insert APIs, immediately after explaining the legacy write paths.](https://ai.engineer/api/talk-essay-media/9200edfe02fb1fbafa705e71e75b8f956a1be46eeb39b1841806747a09e0f154)

He describes the gateway wrapping the cloud insert APIs, immediately after explaining the legacy write paths.

The move also let the team change behavior. It adopted idempotency—the property that a repeated operation can be handled without creating a second effect—and sought strong consistency across multiple writers. Yoder describes using a paradigm similar to a Snowflake ID, though he does not specify its implementation. The goal was to redesign the producer offering around modern capabilities rather than reproduce every legacy path.

There were 35 producers to bring across. The team first wrote migration documentation manually, published it in the company wiki, and later exposed it through MCP. Producers could then ask questions through prompts instead of relying as heavily on separate support chats. Yoder reports a large reduction in those chats and support requests.

The cloud ledger also used human-readable enum values where the legacy system used status codes. Yoder says the AI tools helped bridge the intent between the old and new representations. The migration guidance was therefore part of the product during onboarding, even though it too would eventually be retired.

### Three ways to consume the ledger

[6:38](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=398s)

Consumers had different timing and data needs, so the modern system offered three access patterns with a schema registry across the channels:

![He introduces real-time, batch, and streaming access with a common schema registry.](https://ai.engineer/api/talk-essay-media/9f7f6fecd66b0e3f697237e1cb98eed14bef323dfe4ecfdc4b9a19eb2a9a5244)

He introduces real-time, batch, and streaming access with a common schema registry.

- **Real time:** The heavily used funds-available API helps determine the balance displayed on an account. Consumers call through GraphQL and select the attributes their use cases need.
- **Batch:** For reconciliation or analytics, the data warehouse exposes data-share views tailored to each consumer’s stated needs. Data governance supported limiting each consumer to the attributes it needs.
- **Streaming:** A Kafka topic carries database inserts and updates. Fraud teams can ingest those events into their tooling in real time.

The event stream provides at-least-once delivery: a consumer can receive an event more than once. That makes idempotent handling important when work is retried. Yoder gives the example of a batch job failing halfway through; a retry needs to avoid creating duplicate ledgers while the event stream still delivers the ledger events. He does not detail the implementation of those safeguards.

### Use onboarding context during incidents

[8:58](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=538s)

Fifty consumers needed the ledger. Alongside Vanguard’s three-character application code, the team asked each one for a description and business justification. A trade order might need cash data to meet its obligation; a retirement application might support a required distribution; a 529 application might support a contribution. Those descriptions say what the data enables, not just which application receives it.

![He discusses using consumer business descriptions to understand supported functions and incident impact.](https://ai.engineer/api/talk-essay-media/832e395fe8e008acf059fdca9edcce7bbd1ee07291a5d4ad2adb6be945636b19)

He discusses using consumer business descriptions to understand supported functions and incident impact.

AI tools can compile those descriptions into a view of modernized use cases and the business functions the ledger supports. They also make an incident question easier to ask: what happens if a service-level agreement is breached? Yoder contrasts a batch application, where the team may have hours to respond, with a real-time API returning errors to a client, where it may have minutes.

The team was still evaluating how to combine business justifications with observability and log traces to improve response time. The useful link is between an application identifier in an incident and the human consequence of its failure; the integration was presented as ongoing work.

### Fix forward, share context, and keep observability

[10:59](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=659s)

AI arrived after the migration had begun, and the teams adopted it as their tools changed. Yoder reports that 90% of cash-program engineers now use AI tools daily for work that includes research, development, and testing. Teams also use multi-agent workflows and shared knowledge bases. In the “team brain” approach, knowledge generated while building features goes into common storage, where a new engineer can bring it into a prompt alongside context available to long-standing teammates.

![He discusses daily AI use, multi-agent workflows, and shared knowledge bases.](https://ai.engineer/api/talk-essay-media/f7cdd75d9c778967495cc8f3854e4df346fce687d0aac37e9434e8914005ce38)

He discusses daily AI use, multi-agent workflows, and shared knowledge bases.

Maintaining two codebases creates a harder choice when the team discovers an old bug. Yoder recommends fixing it in the modern system and using that improvement as an incentive to migrate. That can make the databases intentionally differ, so the audit process needs a way to allowlist expected discrepancies rather than treat every difference as a migration failure.

The most difficult producers and consumers to onboard, in Yoder’s experience, were those trying to transfer the old design directly. Teams that reconsidered their products could use the modern ledger’s capabilities. His closing advice joins that redesign with practical support: make legacy code queryable, maintain migration docs while people need them, and adopt AI incrementally as tools become available.

Observability remains necessary after the migration. Metrics, alarms, and traces help teams see who produces and consumes data and support the ledger in daily operations. The direct inserts that once appeared without an identifiable producer show why that visibility matters.

## Key takeaways

- Exposing legacy code through MCP let the team ask AI tools research questions directly; Yoder reports a feedback loop falling from seven days to 15 minutes.
- Daily migration audits compared both row counts and individual attributes. Expected differences from fixes made only in the modern system needed allowlisting.
- A common gateway gave 35 producers a modern write path, while queryable migration documentation reduced the team’s reported support burden.
- Real-time, batch, and streaming consumers had distinct access patterns; at-least-once event delivery made safe retry handling important.
- Consumer business justifications can connect an application’s technical failure to its impact, while metrics, alarms, and traces remain essential for daily operations.

## Related talks

- [We Mapped 115 Microservices for Our Coding Agents — Kamalakannan Nandagopal, Postman](https://ai.engineer/talks/k2ClBT4aqAg-we-mapped-115-microservices-our-coding-agents) — A complementary approach to giving coding agents access to service dependencies and production context.
- [What Data from 20 Million Pull Requests Reveal About AI Transformation](https://ai.engineer/talks/WqZq8L-v9pA-what-data-from-20-million-pull-requests) — Examines AI adoption and engineering outcomes across a large pull-request dataset.

## Slides

### No Cash Left Behind: A Vanguard Modernization Journey

Gareth Yoder introduces Vanguard’s modernization journey, which began after the 2022 launch of Cash Plus for Vanguard brokerage account clients.

[0:12](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=12s) [Title slide for Gareth Yoder’s Vanguard modernization presentation.](https://assets.ai.engineer/sites/aiecode2025/sha256/e7d227b71e3c01eaf98c92fc4d558bfb78319632e3dc945aedcba4811ba11bee.webp)

Vanguard

No Cash Left Behind: A Vanguard Modernization Journey

Gareth Yoder
Cash Program Tech Lead
Oct. 13, 2026 · AI Engineering Conference

Interface text:
AI Engineer
NEW YORK
PRESENTED BY
arize
OCTOBER 13, 2026
LEADERSHIP SESSION
Sutton Room

### The Journey

Vanguard’s cash ledger migration began in 2022. By 2024, AI-assisted discovery made legacy knowledge queryable and cut research from days to minutes; the timeline moves on to self-service onboarding and multi-agent workflows.

[0:27](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=27s) [Timeline of Vanguard’s cash ledger modernization from 2022 through today, including AI-assisted discovery and multi-agent workflows.](https://assets.ai.engineer/sites/aiecode2025/sha256/8e6d7abfe73de32993e71418a8d9e95b363e5c069b665c4cc0577a0bcddb0e6a.webp)

SETTING THE STAGE
The Journey

A multi-year mainframe-to-cloud migration for Vanguard's cash ledger — and where AI started changing how we worked.

2022
Program begins
Mainframe-to-cloud journey kicks off. No AI coding tools in the loop yet.

2023
Three lanes, in parallel
Producers, consumers, and data migration run side by side.

2024
AI-assisted discovery
Legacy knowledge becomes queryable — research time drops from days to minutes.

2025
Self-service onboarding
Migration docs and crosswalks become AI-accessible for every team.

Today
Multi-agent workflows
Shared knowledge bases and evolving AI harnesses meet ongoing modernization demand.

2 / 13
V

Interface text:
OCTOBER 13, 2026
LEADERSHIP SESSION
Sutton Room

### Background

Vanguard’s cash ledger handles money entering brokerage accounts and transfers between accounts. Its active/active ecosystem supports web, mobile and batch, with 30M daily service calls and 500K ledgers created daily on average.

[1:05](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=65s) [Cash ledger migration background, supported channels, and metrics of 30 million daily service calls and 500,000 average daily ledgers.](https://assets.ai.engineer/sites/aiecode2025/sha256/da118706f42688f305efa80004f3165bb8b601f96da317c6337e7a16503c5615.webp)

BACKGROUND
Background

• Migrating this system from mainframe to the cloud is a multi-year journey that started in 2022.
• A cash ledger covers all money movement and account-to-account transactions — ACH, wire, and more.
• Ledger creation is supported across Web, Mobile & Batch channels.
• The ecosystem runs active/active and fault tolerant.

30M
Daily service calls

500K
Avg. daily ledgers created

Web
Mobile
Batch
ACH
Wire
Account-to-Account

3 / 13
V.

OCTOBER 13, 2026
LEADERSHIP SESSION
Sutton Room

### Approach

The modernization runs three migrations in parallel: CDC moves DB2 data to the cloud, alongside migrations of 35 legacy producers and 50 consumers. The speaker says the enterprise priority drove the parallel approach.

[1:50](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=110s) [Three parallel migration pillars: data, producers, and consumers.](https://assets.ai.engineer/sites/aiecode2025/sha256/efb704b53488d44bcb950830c82cc239dc87dda712a81b0f27c817121a7cef25.webp)

STRATEGY
Approach

PARALLEL

Data Migration
CDC
Move data from DB2 to the cloud via Change Data Capture, with validation audit jobs.

Producer Migration
35
Legacy producers migrated to the cloud. Define a common schema up front.

Consumer Migration
50
Legacy consumers migrated to the cloud. Provide APIs, streams, and a data warehouse.

4 / 13
V.

OCTOBER 13, 2026
LEADERSHIP SESSION
Sutton Room

### AI-Accelerated Discovery: Legacy Analysis MCP

An MCP server made legacy code and DB2 metadata searchable by an AI agent. Yoder says the feedback loop for a legacy research question fell from seven days to fifteen minutes.

[2:32](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=152s) [An AI agent queries legacy code through an MCP server; a sample analysis accompanies a seven-day to fifteen-minute comparison.](https://assets.ai.engineer/sites/aiecode2025/sha256/738934340debd2879ce5cbda8d34da5fdfe9d3116a1da3b54c4c9006a1a839e6.webp)

AI IN THE JOURNEY
AI-Accelerated Discovery: Legacy Analysis MCP

We integrated the legacy codebase into an MCP server so any agent could query it directly — COBOL, copybooks, and DB2 catalog metadata, all searchable.

7 days → 15 min
Typical datamining cycle time for a legacy research question

AI Agent → Legacy-Analysis MCP →
search_codebase_keyword
read_codebase_file
get_db2_table_info
COBOL · Copybooks · DB2 Catalog

How is the transaction reversal flag stored in the transaction history table?
• Called legacy-analysis 12 times
• Found it — a transition-history module with a REVERSAL_FL field. Digging into those files.
• Called legacy-analysis 12 times
• This is the COBOL stored procedure backing transaction history retrieval. Inspecting the table/column definition directly.
• Called legacy-analysis 6 times
• Found the real table — T_TXN_HIST (view: TXN_HIST), column REVERSAL_FL. Pulling the copybook for the exact field definition.
• I now have the exact column definition. Here's the answer.
• Transaction Reversal Flag — column REVERSAL_FL in T_TXN_HIST, database LEDGERDB — a single-character flag, nullable.
• COBOL (copybook CPYTXNH): 10 REVERSAL-FL PIC X(1)
• Set by program TXNHIST01 based on transaction type — exchanges flip buy/sell codes, distributions check share quantity.
• Flows downstream into TxnHistoryDao.java and the GTT_TXN_HIST temp table used for history display.
* Churned for 1m 59s

Interface text:
ai-agent — legacy-analysis MCP
5 / 13
V
OCTOBER 13, 2026
LEADERSHIP SESSION
Sutton Room

### Data Migration

CDC connected legacy DB2 to the cloud while daily audits compared row counts and individual columns. The slide advises accounting for replication lag and keeping the temporary audit solution simple.

[3:19](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=199s) [Data migration approach using change data capture and daily database comparisons.](https://assets.ai.engineer/sites/aiecode2025/sha256/dc6f53af2381b5223327b2daa96354ad054c088ec18b25673f1664c38d7a8ef3.webp)

DATA MIGRATION
Data Migration

• Set up a Change Data Capture (CDC) process.
• Use ETL jobs to scan both databases and produce daily audit reports.
• Start with row-level counts, then ensure accuracy with column-level comparisons.

✅ TIPS
✓ Comparing timestamps was accurate but needed to account for replication lag.
✓ Given the interim lifespan, don't over-engineer this solution.
✓ Allow the ability to whitelist known data-mismatch scenarios.

Don't lift and shift — reimagine your process flow, naming conventions, and field consolidation.

Legacy DB2 → CDC → Cloud DB
Daily ETL audit job compares row & column counts across both sides

6 / 13
V.

Interface text:
OCTOBER 13, 2026
LEADERSHIP SESSION
Sutton Room

### Producer Migration

Legacy producers used three paths, including direct table inserts whose source was sometimes unknown. The team put a common schema on a gateway around APIs that insert data into the cloud.

[4:11](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=251s) [Three legacy producer paths and a gateway-to-cloud migration flow.](https://assets.ai.engineer/sites/aiecode2025/sha256/c94a1cc8c4714f162aa3c5bd9cb6f3f356e05e1e5079fad93b2221268ff5b4c0.webp)

PRODUCER MIGRATION
Producer Migration

Legacy producers created data three ways. Each one had to be contacted, its use case understood, and its migration scheduled.

1. Wrapped API
An API that wrapped a legacy service request.

2. Direct Service Request
Called the legacy service request directly.

3. Direct Table Insert
Wrote straight into the legacy database tables.

Gateway → API → Cloud DB

TIPS
✓ Idempotency at the data layer is critical for strong consistency during retries.
✓ Ensure the database maintains strong consistency across a multi-region architecture.
✓ Handle autoscaling by avoiding traffic spikes from batch jobs.

Interface text:
7 / 13
V.
OCTOBER 13, 2026
LEADERSHIP SESSION
Sutton Room

### Producer Onboarding

The team exposed migration documentation through an MCP server, reducing producer support conversations. The example maps DB2’s fine-grained activity code to a human-readable cloud status, without using the coarse status.

[5:30](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=330s) [Migration documentation exposed through an MCP server, with an example mapping legacy ledger statuses to cloud statuses.](https://assets.ai.engineer/sites/aiecode2025/sha256/56d661192f8bdfa62311acb6591beaf0078b1be50edc9ea1445119388e2b258b.webp)

PRODUCER ONBOARDING
Producer Onboarding

The team published migration documentation through an MCP server — reducing cross-team requests for information.

Help me map ledger status codes from DB2 to the Cloud
• Source: migration FAQ doc, confirmed against the Cloud ledger-status enum and the legacy status/activity codes.
• Key insight: two legacy fields collapse into one cloud field.
• DB2 tracks status at two levels — LEDGER_STATUS_CD (coarse: PNDG / SENT / CMPL / REJC / CNCL) and LEDGER_ACTIVITY_CD (fine-grained).
• The Cloud enum has only one field, and it maps from the fine-grained activity code — not the coarse status.

Cloud Status | DB2 Activity Code | Coarse Status | Cancellable? | Meaning
OPEN | n/a | n/a | No | Written to the cloud ledger store, not yet confirmed in DB2
CREATED | ENTR / WEBN / BTCH | PNDG | Yes | Entered, passed validation, not yet sent to recordkeeper
ROUTED_TO_REVIEW | RVRT | PNDG | Yes | Queued for review
APPROVED_BY_REVIEW | APRV | PNDG | No | Reviewed & released, ready to send
REJECTED_BY_REVIEW | REJB | REJC | Yes | Reviewed & rejected
SENT_TO_RECORDKEEPER | SNRK | SENT | No | Sent to the recordkeeper
PROCESSED_BY_RECORDKEEPER | PRCK / PRCM | SENT | No | Posted to the recordkeeper's customer ledger
COMPLETE | CMPL | CMPL | No | In transaction history
CANCELLED | CNCL | CNCL | No | Canceled before completion

• Trimmed to the representative rows — full crosswalk lives in the schema registry.
✳ Churned for 1m 12s

8 / 13
V.

Interface text:
ai-agent — migration-docs MCP
AI Engineer NEW YORK
PRESENTED BY arize
OCTOBER 13, 2026
LEADERSHIP SESSION
Sutton Room

[5:58](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=358s) [Slide describing an MCP server for migration documentation, with an example mapping legacy ledger status codes to cloud statuses.](https://assets.ai.engineer/sites/aiecode2025/sha256/9ae21f84e2fc115fd7b3de11d8ae7f575adbdb76c4f0646fff89d981403a27d7.webp)

PRODUCER ONBOARDING
Producer Onboarding

The team published migration documentation through an MCP server — reducing cross-team requests for information.

Help me map ledger status codes from DB2 to the Cloud
• Source: migration FAQ doc, confirmed against the Cloud ledger-status enum and the legacy status/activity codes.
• Key insight: two legacy fields collapse into one cloud field.
• DB2 tracks status at two levels — LEDGER_STATUS_CD (coarse: PNDG / SENT / CMPL / REJC / CNCL) and LEDGER_ACTIVITY_CD (fine-grained).
• The Cloud enum has only one field, and it maps from the fine-grained activity code — not the coarse status.

Cloud Status | DB2 Activity Code | Coarse Status | Cancellable? | Meaning
OPEN | n/a | n/a | No | Written to the cloud ledger store, not yet confirmed in DB2
CREATED | ENTR / WEBN / BTCH | PNDG | Yes | Entered, passed validation, not yet sent to recordkeeper
ROUTED_TO_REVIEW | RVRT | PNDG | Yes | Queued for review
APPROVED_BY_REVIEW | APRV | PNDG | No | Reviewed & released, ready to send
REJECTED_BY_REVIEW | REJB | REJC | Yes | Reviewed & rejected
SENT_TO_RECORDKEEPER | SNRK | SENT | No | Sent to the recordkeeper
PROCESSED_BY_RECORDKEEPER | PRCK / PRCM | SENT | No | Posted to the recordkeeper's customer ledger
COMPLETE | CMPL | CMPL | No | In transaction history
CANCELLED | CNCL | CNCL | No | Canceled before completion

• Trimmed to the representative rows — full crosswalk lives in the schema registry.
✳ Churned for 1m 12s

8 / 13
V.

Interface text:
ai-agent — migration-docs MCP
AI Engineer NEW YORK
PRESENTED BY arize
OCTOBER 13, 2026
LEADERSHIP SESSION
Sutton Room

[6:28](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=388s) [Migration documentation served through an MCP server, with an example mapping legacy ledger statuses to cloud statuses.](https://assets.ai.engineer/sites/aiecode2025/sha256/dcf422007680c58d1a8daef6e4e68cc5292485f0967191a6db8f5a8c35c8f344.webp)

PRODUCER ONBOARDING
Producer Onboarding

The team published migration documentation through an MCP server — reducing cross-team requests for information.

Help me map ledger status codes from DB2 to the Cloud
• Source: migration FAQ doc, confirmed against the Cloud ledger-status enum and the legacy status/activity codes.
• Key insight: two legacy fields collapse into one cloud field.
• DB2 tracks status at two levels — LEDGER_STATUS_CD (coarse: PNDG / SENT / CMPL / REJC / CNCL) and LEDGER_ACTIVITY_CD (fine-grained).
• The Cloud enum has only one field, and it maps from the fine-grained activity code — not the coarse status.

Cloud Status | DB2 Activity Code | Coarse Status | Cancellable? | Meaning
OPEN | n/a | n/a | No | Written to the cloud ledger store, not yet confirmed in DB2
CREATED | ENTR / WEBN / BTCH | PNDG | Yes | Entered, passed validation, not yet sent to recordkeeper
ROUTED_TO_REVIEW | RVRT | PNDG | Yes | Queued for review
APPROVED_BY_REVIEW | APRV | PNDG | No | Reviewed & released, ready to send
REJECTED_BY_REVIEW | REJB | REJC | Yes | Reviewed & rejected
SENT_TO_RECORDKEEPER | SNRK | SENT | No | Sent to the recordkeeper
PROCESSED_BY_RECORDKEEPER | PRCK / PRCM | SENT | No | Posted to the recordkeeper's customer ledger
COMPLETE | CMPL | CMPL | No | In transaction history
CANCELLED | CNCL | CNCL | No | Canceled before completion

• Trimmed to the representative rows — full crosswalk lives in the schema registry.
✳ Churned for 1m 12s

8 / 13
V.

Interface text:
ai-agent — migration-docs MCP
AI Engineer NEW YORK
PRESENTED BY arize
AI Engineer

### Consumer Migration

Consumers access data through real-time APIs, batch warehouse views, or Kafka topics. Each path has a schema registry; migration guidance also calls for consumer registries and safe event replay.

[6:36](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=396s) [Real-time, batch, and streaming access methods, with tips for documentation, registries, and safe event replay.](https://assets.ai.engineer/sites/aiecode2025/sha256/a132863f881482ff1934857ff7893ecc0a88419f3445095f1fe2bd39198c4cdd.webp)

CONSUMER MIGRATION
Consumer Migration

REAL-TIME
APIs with pagination
Schema: GraphQL Schema

BATCH
Data Warehouse
Schema: Datashare Views

STREAMING
Kafka Event Topics
Schema: Avro / Protobuf Registry

✅ TIPS
✓ Provide self-service migration documentation for data transformation from old to new.
✓ Maintain a schema registry and a consumer registry.
✓ Ensure consumer idempotency-safe operations — safe replays of events.

9 / 13
V.

Interface text:
Engineering the future of AI

### AI Analysis: Determining Consumer Impact

Consumer business cases give AI the context to summarize supported services and assess outage impact. The example connects ledger data to trading, retirement, advisory processes, and client-facing agents.

[8:55](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=535s) [An AI-generated service description, business functionality, and potential client impacts of unavailability.](https://assets.ai.engineer/sites/aiecode2025/sha256/eb69b87529be6e8843e685ab2f720c0da09a056146540b8dc82fa466f8b14de0.webp)

AI IN THE JOURNEY
AI Analysis: Determining Consumer Impact

When a consumer registers for our data schema, we require a business use-case justification and SLAs.

From that, an AI agent can generate:
• An up-to-date service description
• Top business functionality supported
• Client impact if SLAs are breached

DESCRIPTION
This subgraph provides client ledger data — pending and historical cash transfers and share journals across brokerage, retirement, and mutual fund accounts. It replaces legacy REST and DB2 passthroughs, and is consumed by trading platforms, mobile apps, advice services, batch processes, GenAI agents, and compliance tools.

TOP BUSINESS FUNCTIONALITY
• Trade validation: preventing overselling and enforcing good-order rules.
• Pending activity: showing clients pending transfers on web and mobile.
• Retirement services: RMD distributions, conversions, contributions.
• Advisory batch processes: feeding recommendation engines accurate pending data.
• GenAI agents: powering client-facing assistants that answer pending-activity questions.

CLIENT IMPACT IF UNAVAILABLE
• Trade validation fails — order submissions blocked on web and mobile.
• Clients can't see pending transfers, deposits, or withdrawals.
• Retirement operations produce inaccurate or failed results.
• Compliance and fraud checks are disrupted, raising regulatory risk.

Interface text:
10 / 13
V
OCTOBER 13, 2026
LEADERSHIP SESSION
Sutton Room

[10:02](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=602s) [Slide explains how AI summarizes data consumers’ business needs and the impact of service outages.](https://assets.ai.engineer/sites/aiecode2025/sha256/1b28a2fb34521cd898cc03b48d5d1be4312f8970ababac5932e8857d554a147c.webp)

AI IN THE JOURNEY
AI Analysis: Determining Consumer Impact

When a consumer registers for our data schema, we require a business use-case justification and SLAs.

From that, an AI agent can generate:
• An up-to-date service description
• Top business functionality supported
• Client impact if SLAs are breached

DESCRIPTION
This subgraph provides client ledger data — pending and historical cash transfers and share journals across brokerage, retirement, and mutual fund accounts. It replaces legacy REST and DB2 passthroughs, and is consumed by trading platforms, mobile apps, advice services, batch processes, GenAI agents, and compliance tools.

TOP BUSINESS FUNCTIONALITY
• Trade validation: preventing overselling and enforcing good-order rules.
• Pending activity: showing clients pending transfers on web and mobile.
• Retirement services: RMD distributions, conversions, contributions.
• Advisory batch processes: feeding recommendation engines accurate pending data.
• GenAI agents: powering client-facing assistants that answer pending-activity questions.

CLIENT IMPACT IF UNAVAILABLE
• Trade validation fails — order submissions blocked on web and mobile.
• Clients can't see pending transfers, deposits, or withdrawals.
• Retirement operations produce inaccurate or failed results.
• Compliance and fraud checks are disrupted, raising regulatory risk.

Interface text:
10 / 13
V
AI Engineer

### What We Learned

As AI tools matured, teams adopted multi-agent workflows and shared knowledge. Yoder recommends fixing bugs in the modernized system, whitelisting audit differences, and regularly reviewing application telemetry.

[11:10](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=670s) [Lessons on adopting AI, reducing dual-codebase overhead, and reviewing application telemetry.](https://assets.ai.engineer/sites/aiecode2025/sha256/1ad31169a729a996fdfe250d27680864df426ec2ce9ead4b2620815a72544bd3.webp)

REFLECTIONS
What We Learned

• AI tools weren't available when this journey began — teams adopted them as capability grew, aiding research, development, and testing.
• Today, teams use multi-agent workflows, shared knowledge bases, and continuously evolving AI harnesses to meet modernization demand.
• Minimize the overhead of maintaining two codebases by investing in producer migration and whitelisting.
• Ensure app metrics, alarms, and traces are captured — and reviewed often.

Interface text:
11 / 13
V
OCTOBER 13, 2026
LEADERSHIP SESSION
Sutton Room

### Lessons for Leaders

Yoder’s team cut research from 7 days to 15 minutes by exposing legacy code and data through an MCP server. He also urges leaders to improve migration docs, rethink migrations, adopt AI incrementally, and monitor operations.

[13:12](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=792s) [Five leadership lessons, with making legacy knowledge AI-queryable emphasized.](https://assets.ai.engineer/sites/aiecode2025/sha256/15eeb6a6744672c7cac5c1bfe27e112725ae5efdedf51881aefbb25283855528.webp)

FOR THE LEADERSHIP TRACK
Lessons for Leaders

01
Make legacy knowledge AI-queryable
Cut a 7-day research cycle to 15 minutes by putting legacy code and data behind an MCP server.

02
Treat migration docs as a product
Self-service, AI-accessible docs reduce cross-team requests and speed onboarding.

03
Reimagine, don’t lift-and-shift
Use the migration as a forcing function to fix naming, consolidate fields, and simplify flows.

04
Adopt AI incrementally
Tools arrived mid-journey. Keep evolving the harness as capability grows — don’t wait for a perfect starting point.

05
Observability is non-negotiable
Minimize dual-codebase time, and keep metrics, alarms, and traces under continuous review.

Interface text:
12 / 13
V.
OCTOBER 13, 2026
LEADERSHIP SESSION
Sutton Room

[15:02](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=902s) [Five lessons on AI-queryable legacy knowledge, migration documentation, reimagining migration, incremental AI adoption, and observability.](https://assets.ai.engineer/sites/aiecode2025/sha256/3c391606118df26aae57e43dd966bc0edcc5305e9b053c4fced2b1246453e8d8.webp)

FOR THE LEADERSHIP TRACK
Lessons for Leaders

01
Make legacy knowledge AI-queryable
Cut a 7-day research cycle to 15 minutes by putting legacy code and data behind an MCP server.

02
Treat migration docs as a product
Self-service, AI-accessible docs reduce cross-team requests and speed onboarding.

03
Reimagine, don’t lift-and-shift
Use the migration as a forcing function to fix naming, consolidate fields, and simplify flows.

04
Adopt AI incrementally
Tools arrived mid-journey. Keep evolving the harness as capability grows — don’t wait for a perfect starting point.

05
Observability is non-negotiable
Minimize dual-codebase time, and keep metrics, alarms, and traces under continuous review.

Interface text:
12 / 13
V.
OCTOBER 13, 2026
LEADERSHIP SESSION
Sutton Room

### Questions

Gareth Yoder invites questions if time allows and offers to connect outside the room.

[15:27](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=927s) [Vanguard questions slide identifying Gareth Yoder as Cash Program Tech Lead, alongside the event broadcast and speaker view.](https://assets.ai.engineer/sites/aiecode2025/sha256/277a18e94caa26b3b9a3cb67f3b3b3c3af8c309d2ed5e3cd669110ee1134f82f.webp)

Vanguard

Questions

Gareth Yoder
Cash Program Tech Lead

Event text:
AI Engineer
NEW YORK
PRESENTED BY
arize
OCTOBER 13, 2026
LEADERSHIP SESSION
Sutton Room

## Full transcript

[0:12](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=12s) My name is Gareth Yoder. I'm the cash program technical lead here at Vanguard. I help oversee four to six teams in the cash program. This is No Cash Left Behind, a Vanguard modernization journey. This journey really starts after we delivered our Cash Plus offering to our Vanguard brokerage account clients, and we launched that in twenty twenty-two. And after we did the launch, we started to get the whispers that modernization

[0:42](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=42s) is now coming down the pipeline, and that will be our next major project. How many here have legacy code bases? Right? That's a lot of you. How many of you wish that legacy code base would just modernize? Right? Many of you would say the same. So looking here at the journey, we're gonna go through this timeline in today's presentation, but I wanna first talk to you what a cash ledger actually is. A cash ledger involves all money

[1:12](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=72s) movement transactions into our Vanguard brokerage accounts from the outside world. It also involves cash being moved between accounts. And so the payment rails, think ACH, wires, and more. We support the web channels, mobile channels, and batch channels. Our system runs in an active-active multi-region fault-tolerant ecosystem, and our services will receive upwards to thirty million

[1:42](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=102s) calls per day. Our clients will generate a half million ledgers every day as well. And so as we start to go down this modernization approach, we broke it down into three pillars: a data migration, a producer migration, and a consumer migration. But because this was an enterprise priority, we had to do all three in parallel. So now, as we look

[2:12](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=132s) towards the research analysis, remember we're at the beginning of our timeline, the AI tooling wasn't there. And so oftentimes we would work with mainframe engineers, and we would work with architects to try to determine what that data schema model would look like. And there was a turning point in this modernization journey, and that's when we had our legacy code base being available to our AI tooling via an MCP server. And now we saw faster

[2:41](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=161s) feedback loops. What was taking seven days for a mainframe engineer to go into the code, do their analysis, and then kinda, and come back to us for an answer now could all be done via an AI tool prompt. And what we saw was that the feedback loop was reduced from seven days down to fifteen minutes. It was a huge win for our product owners, our technical

[3:11](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=191s) leads, and developers alike. They all contribute this tool to helping our modernization succeed. So let's talk about data modernization. We utilized a standard CDC change data capture approach that's common in industry, and we had to then scan both databases. A team did daily audits. We first made sure we had strong consistency by verifying the row-level data counts,

[3:41](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=221s) and then we ensured that we had strong integrity by checking the individual columns, making sure that the amounts matched from the legacy to the modern, making sure that the account information would match, or the state withholding, the federal withholding. All of the attributes in the legacy database had to match to the, to the cloud. A major tip here is that you don't wanna over-engineer this solution because as modernization would complete, this code would then get deprecated.

[4:12](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=252s) Now, let's talk about producer migration. Our producers called our infrastructure in three ways from the legacy state. One was through a service request. The second was an API that wrapped that service request. And the last, and probably the most daunting, was direct table inserts because we would see data appear in our database, and we weren't sure how it got there or who produced that data. So we took that common data schema, and we

[4:42](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=282s) put it onto a gateway that wrapped our APIs that would do our cloud data inserts. Now, take your modernization journey as an opportunity to reimagine your data ecosystem. We took concepts from Fintech, such as idempotency. We also ensured that we had strong consistency across multiple writers. And so we used, utilized a similar paradigm to what a Snowflake ID would provide us. We reimagined, and we didn't do a lift and

[5:11](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=311s) shift. Now, we have a modernized producer offering available. How do we get our producers? We had thirty-five producers that had to then modernize to our ecosystem. Early on, we had to produce manual documentation to facilitate this transition. And as the AI tooling became available, we provided that documentation in our company's wiki but then exposed it via the MCP server.

[5:42](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=342s) And that was really great because what it did was we used to have many teams having chats with us, and we had to try to keep all of those organized. Now that communication and that back and forth could all be done via the prompt on the producer side, and we saw that the number of chats and, and producer support that our team was doing was greatly reduced when we had the MCP available. The AI tools also did a really good job of transitioning

[6:12](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=372s) state from the legacy ecosystem to the cloud. We made our cloud ecosystem, the ledger enums, to be human-readable versus just ledger status codes in our legacy ecosystem. And so our AI tooling did a really good job at bridging the gap of the intent from the legacy ecosystem to the cloud.

[6:38](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=398s) So now let's look at the consumer migration path. We had three ways to access consumer-level data. We had real-time use cases, batch use cases, and streaming use cases. And the commonality here is that we provided a schema registry no matter which channel that your, uh, consumer would access that data. And so for a funds available, that's our most, that's our most, uh,

[7:08](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=428s) heavy traffic, uh, real-time API, and that goes into determining what is the balance that's displayed on your account. They're gonna be calling us via GraphQL, and they're gonna subscribe to only the attributes that meet their use cases. Now, for batch use cases, think of reconciliation or data analytics. We have our data warehouse that will expose data share views to each individual consumer. Each of the consumers tells us

[7:38](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=458s) their use case, and we provide a, a view that's specific to their data needs. This, this was supported by our data governance team that strongly advocated that only the consumers that need the certain data attributes, they should only see, uh, those pieces of data. Our last piece was around streaming. We have a Kafka event topic that we would stream all of the inserts and updates to that database. Our fraud teams were able to take,

[8:08](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=488s) take advantage of this technology to provide real-time data ingestion into their fraud tooling. We provided at-least-once delivery, and so our concepts of idempotency that we did through the producer side, we carried forward through the event streaming. And so as they subscribe to at-least-once delivery, we made sure that they had idempotent safe, uh, operations so that if a batch job would,

[8:38](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=518s) would fail halfway through the process, those teams could retry, and we can ensure that we don't have, uh, duplicate ledgers being created. But the at-least-once delivery from the eventing side ensured that they had all of the ledger events that were created.

[8:58](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=538s) Now, when we onboarded consumers, we had fifty different consumers across our organization that needed our data. At Vanguard, when you onboard an application, you need to have a three-character application code to register to onboard. This application code describes what your application is and h- and what it performs. But we took it a step further. We requested that our consumers would provide us

[9:29](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=569s) a description and a bu- business case justification for their need for the data. And so think about if I am a trade order that needs a cash ledger to fill-fulfill the cash obligation of the trade, that could be a business use case. Or for a retirement account that needs to do a, a required mandatory distribution. A 529 account could do a contribution to their college tuition account.

[10:00](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=600s) By grouping together all of these business descriptions, now the AI tooling can compile that together and provide an accurate description of what use cases have been modernized in our ecosystem, as well as we now have what is the top business functionality that we support. We can also take it a step further by asking, "What is the impact if our SLAs are breached?" And this is critical because if you're in a

[10:29](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=629s) major incident, and if we see an app code that starts to go beno- go below the five nines of availability, we can go in and we can see, okay, a batch application, we may have hours to respond. A real-time API where there's a client on the other side that's receiving errors, we have minutes, and time is of the essence to self-heal. We're continuing to evaluate how we can get

[10:59](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=659s) faster response times by combining the business use case justification into our observability and, and, uh, log traces. So what we've learned. We've learned that although we started this journey before the AI tooling was even available, we adapted and continued to adopt the newer technologies. This greatly aided in our research, in our

[11:29](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=689s) development, and our testing. Today, in our cash program, ninety percent of our engineers utilize these AI tools on a daily basis. Our teams use multi-agent workflows, and we have shared knowledge bases. We're continuing to evolve this AI harness to meet our modernization demand. We have the concept of a team brain, that as engineers are, are building out product features,

[11:59](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=719s) that knowledge goes into a common storage where it's now accessible by all members on the team. And if there's an engineer that has just joined, they can tap into this common knowledge base And now they have the same context in their prompt as an engineer that has been here for the last five years.

[12:20](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=740s) Now, when you're in a modernization process, maintaining two code bases is challenging, and what you'll want to do is you'll want to continue to fix forward. Don't fix the past. As you encounter bugs that have-- may have listed-- have, uh, existed for decades, continue to fix the modernized state and allow that to be the incentive for your producers and

[12:50](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=770s) your consumers to modernize to the cloud. Now, this will throw off your audit logs, so you'll wanna have whitelisting available, and that's really critical. And the last piece is ensure that you have the right metrics, alarms, and traceability because you're gonna review those often as your product continues to grow. Now, because this is a leadership track, I wanna call out five main points. Number one was make your knowled-- or make your

[13:20](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=800s) legacy codebase AI queryable. That-- Exposing that via an MCP server or legacy codebase, it cut that research cycle time and gave quicker feedback loops. That's seven days down to fifteen minutes. That was a huge win. Treat your migration docs as part of your product. It needs to... Your migration docs are just as critical as your business functionality because that's what all of your producers are going to utilize to

[13:50](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=830s) onboard to your application. Eventually, yes, those will get deprecated out, but for that interim process, those migration docs are critical. Reimagine and don't lift and shift is, is the third point. The consumers and producers that we had the most trouble onboarding to our modernized state were the ones that wanted to do a direct lift and shift transfer of old to new versus those

[14:19](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=859s) that took a moment to step back and say, "How could we better evolve our product by taking advantage of the modern capabilities that the cash ledger ecosystem provides?"

[14:35](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=875s) The fourth component is adopt AI incrementally.

[14:41](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=881s) As the AI tools arrived, you continue to enhance your product. There's never going to be a perfect starting point in the world that we live in today. The important thing is that you get started and you continue to enhance and adapt as the technology changes. Last piece is observability is non-negotiable. You need to know who's producing your data and who's consuming your data, and this is ever more important as your product goes to

[15:11](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=911s) BAU, and once the modernization is complete, your teams will now have to support this as their, uh, daily operations.

[15:22](https://www.youtube.com/watch?v=uA4ah-dVHvU&t=922s) Thank you very much, all. If we have time, we'll take questions. Otherwise, I'll be outside of the room. You can connect with me later, and thank you again for the opportunity.
