Toyota Cuts AI Agent Build Time to Four Days With LangGraph Engine

Building ToyotaGPT: 50+ Production Agents, One Config File, Zero Architecture Reviews — LangChain

LangChain

Treating software agent development as a lean automotive assembly line allows enterprises to bypass repetitive architecture reviews and compress deployment times from six months to four days.

AI-assisted summary of Building ToyotaGPT: 50+ Production Agents, One Config File, Zero Architecture Reviews — original source. Check the original for full context.

Source published:

Key ideas

  • Toyota replaced its bespoke six-month, six-engineer RAG pipeline with ToyotaGPT, an automated LangGraph engine that deploys production agents in four days using a single engineer and one configuration file. (1:40)
  • Over 50 production agents now operate across Toyota facilities using modular skills auto-synthesized from unstructured data, including assembly floor tool GearPull, paint testing accelerator R&D GPT, and CAD-embedded KadyaGPT. (5:06)
  • The platform architecture pairs LangGraph with an MCP-compatible tool layer pre-certified by TMNA cybersecurity, eliminating repetitive architectural and security reviews for new agent deployments. (3:38)
  • Toyota maps its 100-year-old Toyota Production System (TPS) directly to AI engineering: LangSmith acts as an Andon board and enables Genchi Gembutsu root-cause tracing, while LangGraph implements Jidoka via human-in-the-loop controls. (8:58)

Detailed notes

## Background Published on YouTube by LangChain on July 15, 2026, this presentation features Ravi Chandu Ummadisetti and Kordel France from Toyota's enterprise AI team detailing the architecture and philosophy behind ToyotaGPT. According to the video description, the platform reduced agent delivery times from six months and six engineers to four days and one engineer, supporting over 50 production agents by mapping the historic Toyota Production System (TPS) onto modern LangChain workflows.

## TL;DR To eliminate runaway duplication and chaotic chatbot experiments across 65,000 employees, Toyota engineered ToyotaGPT—a centralized enterprise platform using LangGraph, MCP-standardized tooling, and layout-aware ingestion to run over 50 production agents entirely from single declarative config files. The architecture solves complex multi-format data extraction across CAD files, engineering tables, and legacy manuals to automatically synthesize reusable enterprise skills for applications like factory downtime troubleshooting and CAD-embedded design. Connecting modern AI to industrial history, the team demonstrates how core Toyota Production System principles map directly to software: LangSmith acts as a factory Andon board, iterative reflection mirrors Kaizen, human-in-the-loop agent routing reflects Jidoka, and trace-level debugging fulfills Genchi Gembutsu. Ultimately, the speakers argue that LangChain represents the lean manufacturing standard required to reliably industrialize AI agent production.

## Atmosphere & style The presentation carries a polished, authoritative, and deeply pragmatic tone that balances the operational gravity of a global industrial titan with the agile velocity of modern AI development. Ravi opens with an urgent, relatable account of enterprise chaos before methodically demonstrating how engineering discipline turned a six-month bottleneck into a four-day turnaround. Kordel smoothly transitions the energy into an insightful, philosophical breakdown, speaking with quiet conviction as he bridges physical factory floors with digital trace trees. The session feels less like a vendor sales pitch and more like a high-level masterclass in applying century-old manufacturing rigor to bleeding-edge software architecture.

## Bulletin - [01:40](https://www.youtube.com/watch?v=nUNuNxMhwug&t=100s) Toyota replaced its bespoke six-month, six-engineer RAG pipeline with ToyotaGPT, an automated LangGraph engine that deploys production agents in four days using a single engineer and one configuration file. - [05:06](https://www.youtube.com/watch?v=nUNuNxMhwug&t=306s) Over 50 production agents now operate across Toyota facilities using modular skills auto-synthesized from unstructured data, including assembly floor tool GearPull, paint testing accelerator R&D GPT, and CAD-embedded KadyaGPT. - [03:38](https://www.youtube.com/watch?v=nUNuNxMhwug&t=218s) The platform architecture pairs LangGraph with an MCP-compatible tool layer pre-certified by TMNA cybersecurity, eliminating repetitive architectural and security reviews for new agent deployments. - [08:58](https://www.youtube.com/watch?v=nUNuNxMhwug&t=538s) Toyota maps its 100-year-old Toyota Production System (TPS) directly to AI engineering: LangSmith acts as an Andon board and enables Genchi Gembutsu root-cause tracing, while LangGraph implements Jidoka via human-in-the-loop controls.

## Key takeaways - [00:05](https://www.youtube.com/watch?v=nUNuNxMhwug&t=5s) The generative AI boom of 2023 caused internal duplication across Toyota's 65,000 employees, prompting the centralized enterprise AI team to establish a unified platform called ToyotaGPT. - [01:40](https://www.youtube.com/watch?v=nUNuNxMhwug&t=100s) Traditional enterprise RAG deployment bottlenecks stemmed from repeated cybersecurity reviews and ingestion plumbing rather than AI model complexity. - [02:09](https://www.youtube.com/watch?v=nUNuNxMhwug&t=129s) By certifying base architecture and security with IT in advance, LangGraph dynamic graph generation reduced agent development time from six months to four days. - [02:47](https://www.youtube.com/watch?v=nUNuNxMhwug&t=167s) Toyota avoided commercial extractor licensing costs by developing in-house, vision-augmented OCR and layout-aware parsers to ingest complex CAD files, nested tables, and multilingual manuals. - [03:38](https://www.youtube.com/watch?v=nUNuNxMhwug&t=218s) Standardizing tools on the Model Context Protocol (MCP) ensures that every integrated tool is pre-secured, pre-governed, and universally accessible to agents across the enterprise. - [04:18](https://www.youtube.com/watch?v=nUNuNxMhwug&t=258s) ToyotaGPT replaces manual agent programming with an autonomous pipeline that synthesizes modular, reusable 'skills' directly from terabytes of raw unstructured documents. - [05:39](https://www.youtube.com/watch?v=nUNuNxMhwug&t=339s) GearPull indexed technical documentation across North American manufacturing plants, reducing assembly line troubleshooting from hours or days of manual binder searches to under 10 seconds. - [06:37](https://www.youtube.com/watch?v=nUNuNxMhwug&t=397s) R&D GPT indexes decades of historical paint formulation research and extreme-climate test results, compressing multi-year testing cycles into instant query responses. - [07:25](https://www.youtube.com/watch?v=nUNuNxMhwug&t=445s) KadyaGPT embeds AI assistance directly into the tool-and-die CAD workspace, surfacing component tolerances and design patterns without developer context switching. - [08:58](https://www.youtube.com/watch?v=nUNuNxMhwug&t=538s) The Toyota Production System (TPS) translates seamlessly from hardware manufacturing to software agent development, treating agents as manufactured products. - [10:14](https://www.youtube.com/watch?v=nUNuNxMhwug&t=614s) LangSmith functions as an AI Andon board, providing a centralized dashboard to observe agent traces, isolate tool execution failures, and detect user frustration. - [12:23](https://www.youtube.com/watch?v=nUNuNxMhwug&t=743s) Kaizen manifests at both macro levels via continuous platform releases and micro levels through self-correcting agent execution loops like ReAct. - [13:04](https://www.youtube.com/watch?v=nUNuNxMhwug&t=784s) Jidoka, or automation with a human touch, is realized in LangGraph by automating orchestration toil while reserving critical quality checkpoints for human-in-the-loop intervention. - [14:11](https://www.youtube.com/watch?v=nUNuNxMhwug&t=851s) Genchi Gembutsu ('go to the source') is embodied by LangSmith trace debugging, allowing engineers to bypass raw logs and inspect the exact prompt, tool call, or retrieval that caused a failure. - [15:21](https://www.youtube.com/watch?v=nUNuNxMhwug&t=921s) The team predicts that LangChain will serve as the universal manufacturing standard and infrastructure bedrock for enterprise software in the AI era.

## Detailed walkthrough ### [00:05](https://www.youtube.com/watch?v=nUNuNxMhwug&t=5s) The 2023 Generative AI Chaos Inside Toyota

Ravi Chandu Ummadisetti, head of Agent AI and product research at Toyota, opens by introducing himself alongside Kordel France, head of AI engineering. When Generative AI began reshaping technology in 2023, Toyota was confronted with massive scale: 65,000 employees, multiple manufacturing plants, and urgent pressure across departments to deploy this new technology. Because every AI use case heading to production must flow through their centralized enterprise AI team, they faced an immediate operational imperative to establish “one standard, one platform, no chaos, no duplication.” However, market tooling was inadequate for what they needed, forcing them to open a blank repository in GitHub and engineer a bespoke internal system called ToyotaGPT.

In the initial rush, fragmented teams across Toyota began building isolated, redundant chatbots. Teams were creating duplicate ingestion pipelines and extraction routines without common architecture or security protocols, creating runaway duplication across the global enterprise. Ravi recalls the intensity of that moment:

> “The pressure was real, the timeline was yesterday.”

[01:40](https://www.youtube.com/watch?v=nUNuNxMhwug&t=100s) Compressing Six Months of Delivery into Four Days via LangGraph

Early on, standing up a single Retrieval-Augmented Generation (RAG) application inside Toyota consumed six engineers and six full months of development time. This delay was not because the core artificial intelligence models were intrinsically difficult, but because enterprise governance and integration around AI were daunting. Every single initiative previously required bespoke ingestion plumbing across diverse repositories, manual cybersecurity reviews, and architecture sign-offs that had to be repeated from scratch each time.

To resolve this delivery bottleneck, the team built an automated dynamic graph generation engine powered by LangGraph. By standardizing the pipeline, an engineer only needs to define the specific use case and attach the relevant data connectors; the execution graph—supporting ReAct agents and deeper agent architectures—constructs itself automatically. Because the foundational architecture and security posture are certified in advance with enterprise IT, new apps bypass repeated security and architectural reviews entirely. As Ravi puts it:

> “So six months became four days, six engineers became one. That is not an optimization. That's a different way of building.”

- Traditional deployment: 6 engineers, 6 months per RAG application. - ToyotaGPT deployment: 1 engineer, 4 days per production agent. - Every new agent variation is defined entirely through a single config file.

```mermaid flowchart TD accTitle: Dynamic Agent Generation on LangGraph accDescr: Diagram contrasting Toyota's legacy six-month manual deployment with the automated four-day ToyotaGPT config-driven pipeline.

subgraph Legacy["Legacy RAG Pipeline (6 Months / 6 Engineers)"] L1["Bespoke Ingestion Plumbing"] --> L2["Custom Agent Code"] L2 --> L3["Manual Security Review"] L3 --> L4["Architecture Sign-Off"] L4 --> L5["One-Off App Release"] end

subgraph Modern["ToyotaGPT on LangGraph (4 Days / 1 Engineer)"] M1["Single Config File<br/>(Use Case + Connectors)"] --> M2["Dynamic Graph Engine<br/>(ReAct & Deep Agents)"] M2 --> M3["Pre-Approved Security &<br/>Zero Architecture Reviews"] M3 --> M4["Instant Production Deployment"] end ```

[02:47](https://www.youtube.com/watch?v=nUNuNxMhwug&t=167s) Solving Toyota’s Data Extraction Challenge

Data ingestion at Toyota represents a harsh operational hurdle. The enterprise repository contains vast collections of complex, unstructured formats, spanning modern PDF and Word documents, Excel spreadsheets, complex CAD and AutoCAD engineering files, and scanned maintenance manuals dating back to the 1990s. Compounding this structural heterogeneity are nested engineering tables—frequently organized as tables inside tables, placed inside further tables, or embedded directly inside raster images—as well as multilingual documentation in Japanese, English, and other languages.

Adhering to the principle that bad input text guarantees bad output text, the team avoided paying expensive enterprise third-party licensing fees by creating custom in-house extractors. Their ingestion engine leverages layout-aware parsing, vision-augmented OCR, and automated schema mapping to normalize every data source into a single unified index.

[03:38](https://www.youtube.com/watch?v=nUNuNxMhwug&t=218s) The ToyotaGPT Stack: LangGraph, LangSmith, and MCP Tooling

The core of ToyotaGPT relies on an end-to-end LangGraph pipeline that dynamically routes data according to file and source types. Harrison Chase and the LangChain ecosystem form the architectural foundation, with LangSmith providing end-to-end tracing and observability. The pipeline natively connects vector databases, corporate SharePoint sites, and enterprise repositories, with security protocols co-engineered alongside the Toyota Motor North America (TMNA) cybersecurity team from day one.

Once deployed, every agent automatically inherits these foundational security protections and is exposed through standard API interfaces. These agent backends serve downstream consumers ranging from the ToyotaGPT web interface and internal workforce software to physical factory floor equipment, production robotics, and vision-language-action models. The tool layer is standardized around the Model Context Protocol (MCP), guaranteeing that every tool integrated into the catalog is pre-secured, pre-governed, and instantly usable by any agent across the enterprise without bespoke clearance processes.

```mermaid flowchart TD accTitle: ToyotaGPT Core Enterprise Architecture accDescr: System diagram showing unstructured data inputs flowing through extraction, the LangGraph core with MCP tools, and downstream operational consumers.

subgraph Ingestion["Heterogeneous Data Ingestion"] D1["CAD / AutoCAD / Manuals"] --> E1["Layout OCR & Vision Extractor"] D2["Word / Excel / SharePoint"] --> E1 D3["Multilingual Docs (JP / EN)"] --> E1 end

subgraph Core["Core Platform Engine"] E1 --> G1["Unified Enterprise Index"] G1 --> G2["LangGraph Core Pipeline"] G2 <--> S1["Auto-Synthesized Skills Engine"] G2 <--> T1["MCP-Compatible Tool Layer"] G2 <--> L1["LangSmith Observability & Tracing"] G2 --- SEC["TMNA Cybersecurity Guardrails"] end

subgraph Serving["Downstream Integration via APIs"] G2 --> C1["ToyotaGPT Web & Internal Apps"] G2 --> C2["Factory Floor Machines"] G2 --> C3["Robotics & Vision-Action Models"] end ```

[04:18](https://www.youtube.com/watch?v=nUNuNxMhwug&t=258s) Autonomous Skill Synthesis and 50+ Production Agents

A core design breakthrough of ToyotaGPT is its concept of "skills"—modular, reusable units of enterprise intelligence. Instead of having developers manually code agent behaviors, the platform runs an automated intelligence pipeline that reads terabytes of raw unstructured enterprise documents and synthesizes reusable skills without human engineering intervention. These generated skills are added to a centralized, shared library, eliminating behavioral drift and duplicate efforts across business units.

More than 50 agents operate in production across Toyota facilities, every single one configured solely by a declarative configuration file. Among the flagship deployments: - **GearPull:** An automated manufacturing support agent deployed across North American assembly plants. - **Gura:** The enterprise long-term memory agent, codifying decades of the Toyota Way, historical principles, and corporate culture. - **Vehicle AI Experts:** Specialized domain agents capable of retrieving mechanical specifications, model variants, and historical design details across the entire vehicle catalog in seconds.

[05:39](https://www.youtube.com/watch?v=nUNuNxMhwug&t=339s) Manufacturing Deployments: GearPull, R&D GPT, and KadyaGPT

Ravi highlights three specific agent deployments demonstrating the real-world utility of the platform:

1. **GearPull:** Conceived during an internal hackathon by team member Braden Buffard, GearPull tackles assembly line downtimes. Historically, whenever a factory line stalled, a maintenance engineer had to physically walk over to a bookshelf, locate printed manuals, and flip through binders to troubleshoot the failure—a process that took hours or even days. Because halted assembly lines can cost millions of dollars in lost vehicle output, GearPull indexed terabytes of technical data into vector databases across all North American manufacturing plants. Engineers now type the machinery issue into the interface and receive an authoritative troubleshooting answer within 10 seconds. 2. **R&D GPT:** Automotive paint development traditionally requires between one and four years of rigorous laboratory testing under extreme heat and sub-zero cold to guarantee finish longevity. R&D GPT indexes decades of past proprietary research, formulations, and test results using deep research techniques, allowing materials scientists to run queries across historic institutional knowledge in seconds and compress testing cycles. 3. **KadyaGPT:** Designed specifically for vehicle tool and die engineers, this agent operates directly inside the designer's CAD workspace. Rather than forcing engineers to toggle between their drafting canvas and external documentation, KadyaGPT suggests best practices, checks component tolerances, surfaces design variations, and highlights structural patterns in real time with zero context switching.

Ravi reflects on the platform's creation:

> “We took a hackathon idea and turned it into terabytes of production. 50 agents, millions of dollars in savings. Built from zero, from scratch.”

[08:58](https://www.youtube.com/watch?v=nUNuNxMhwug&t=538s) The Toyota Production System (TPS) Meets Modern Agent Workflows

Taking the stage, Kordel France explains how the Toyota Production System (TPS)—the manufacturing philosophy formalized in the 1980s that allowed resource-constrained Japanese automakers to compete internationally—maps directly to modern AI agent engineering. TPS is founded on building complex physical products rapidly with minimal wasted materials, modular production steps, and unbroken flow from raw input to finished car. Kordel argues that LangChain serves as the software equivalent of TPS for agent production:

> “The principles from hardware manufacturing translate really well into agent manufacturing. It's just a matter of the substrate — the matter that we're manufacturing.”

Just as physical factories use an **Andon board**—a centralized, real-time status display that alerts operators to factory line breakdowns, material shortages, and throughput bottlenecks without needing to walk the whole plant—enterprise software teams require an operational counterpart. Toyota uses LangSmith as a literal software Andon board. Through LangSmith's monitoring dashboards, engineers immediately observe agent executions across the enterprise, spot failing tool calls, detect user frustration points, and isolate targets for the next software pull request.

The team also applies **Kaizen**, the TPS principle of continuous, incremental improvement. In software, this ethos manifests in continuous pull requests, frequent iterative builds, and automated nightly updates. Within the LangChain and LangSmith ecosystem, Kaizen operates across both macro scales (the system-wide baseline platform) and micro scales (fine-grained agent adjustments).

| TPS Principle | Physical Manufacturing Function | AI Equivalent in ToyotaGPT / LangChain | |:--- |:--- |:--- | | **Andon Board** | Central visual display indicating line stoppages, component shortages, and assembly status | **LangSmith Observability:** Live monitoring of agent traces, failing tool calls, and user friction points | | **Kaizen** | Continuous, incremental optimization through disciplined small adjustments | **Iterative CI/CD & Tracing:** Nightly updates, steady PR iterations, and trace-driven prompt/tool tuning | | **Modular Production Lines** | Lean, flexible hardware assembly designed to recover quickly from point failures | **LangGraph Workflows:** Dynamic, modular graph assemblies that cleanly separate tools, memory, and routing |

[12:23](https://www.youtube.com/watch?v=nUNuNxMhwug&t=743s) Kaizen: Continuous Improvement from the Platform to the Agent

Kordel France explores the concept of *Kaizen*, or continuous improvement, observing how it operates across both macro and micro dimensions in modern AI engineering. At the macro level, the ecosystem itself is constantly evolving through regular platform releases. Pointing directly to the momentum of the day, Kordel notes how rapidly new capabilities roll out across the framework. Meanwhile, at the micro level, individual agents actively practice continuous improvement in runtime. A foundational example is the ReAct agent, which systematically monitors its intermediate reasoning and outputs, constantly refining its working state before ever returning a response to the end user. This step-by-step reflection ensures the output is accurate and adheres directly to user intent rather than shipping flawed results.

Toyota’s engineering culture is built upon regular, incremental adjustments rather than volatile overhauls, making this architectural style feel completely native to their operations. As Kordel explains: “So this philosophy of continuous improvement through steady and consistent changes is something we embody at Toyota and are delighted to see with LangChain throughout the whole ecosystem.” By mirroring Kaizen across tooling updates and agent execution loops, engineering teams can rely on small, compounding improvements to achieve sustained operational reliability.

- Macro Kaizen: Continuous platform feature announcements and rapid ecosystem updates directly improve overall tooling maturity. - Micro Kaizen: Self-correcting agent architectures (like ReAct) inspect, evaluate, and modify their intermediate tool calls and generations prior to returning a final response. - Cultural alignment: Steady, reliable micro-iterations match Toyota's core philosophy of avoiding massive, uncontrolled failures by enforcing continuous quality checks.

---

[13:04](https://www.youtube.com/watch?v=nUNuNxMhwug&t=784s) Jidoka: Automation with a Human Touch via LangGraph

Moving to what he highlights as his personal favorite principle, Kordel explains *Jidoka*, translated literally as "automation with a human touch." In physical manufacturing, Jidoka ensures automated machines halt safely and notify operators when an anomaly occurs, keeping the human operator central to product quality while removing repetitive, low-value labor. LangGraph maps onto this concept by handling orchestration nuances and low-level development friction while purposefully preserving developer agency through human-in-the-loop controls.

Kordel frames this dynamic as an evolving social contract between machine capabilities and human oversight. In automotive assembly, automation is necessary to keep production lean and efficient, but human judgment remains irreplaceable when unexpected conditions arise or quality standards must be verified. LangGraph structures AI workflows around this very balance: engineers delegate orchestration toil to the graph without surrendering oversight of edge cases or domain constraints. Reflecting on this relationship, Kordel states: “And Jidoka is really like a handshake deal between AI, automation, and a human — to say: I understand each role that you play, and I understand we're going to have to adapt as technology progresses.”

```mermaid flowchart TD accTitle: Jidoka Human-in-the-Loop Pattern in LangGraph accDescr: Flow diagram illustrating how LangGraph automates repetitive orchestration while pausing for human oversight on critical decisions.

subgraph Automation ["Automated Graph Layer"] A["Incoming User / System Request"] --> B["Automate Routine Nuance & Monotony"] B --> C{"Decision / Edge State"} end

subgraph Oversight ["Jidoka: Human Touch"] C -->|"Anomaly or Critical Checkpoint"| D["Human-in-the-Loop Interruption"] D -->|"Guide & Validate Values"| E["Approved Action State"] end

subgraph Delivery ["Output Stage"] C -->|"Nominal Execution"| F["Deliver High-Quality Result"] E --> F end ```

- Abstracting monotony: LangGraph removes the repetitive boilerplate and architectural plumbing that engineers prefer to avoid. - Maintaining human values: Retaining a human in the loop guarantees that safety, domain nuances, and quality thresholds are enforced throughout development and deployment. - Fluid roles: While automated capabilities expand, the human operator’s role evolves rather than disappears, safeguarding end-customer quality standards.

---

[14:11](https://www.youtube.com/watch?v=nUNuNxMhwug&t=851s) Genchi Gembutsu: Root-Cause Debugging with LangSmith Traces

Kordel turns next to *Genchi Gembutsu*, the Toyota tenet requiring workers to "go to the source" to understand conditions on the ground firsthand rather than speculating from afar. In the physical realm, Toyota forbids trying to diagnose factory defects through high-level discussions or remote video conferences; if a problem surfaces at a facility in Texas, engineers based in California cannot resolve it through conjecture. Instead, they must travel directly to the plant floor, touch the physical machinery, determine the exact root cause, and then distribute the remedy across all other production lines so that the improvement is preserved everywhere.

In agent development, LangSmith traces function as the digital manifestation of this practice. While high-level dashboards act like an Andon board signaling that a failure occurred, trace-level observability takes engineers straight to the exact tool invocation, context retrieval, or model completion that failed. Engineers avoid sifting aimlessly through unstructured log files; they navigate directly to the faulty step in the trace, identify the defect, implement a structural fix, and propagate that solution to prevent regressions. Demonstrating how this eliminates guesswork, Kordel notes: “LangSmith traces are a direct embodiment of Genchi Gembutsu. For every query, every tool call, I can see the entire trace, the entire route to the solution.”

| Toyota Production System (Physical) | AI Software Engineering (LangChain Stack) | Operational Impact | |:--- |:--- |:--- | | **Andon Board** | LangSmith observability dashboards | Real-time signaling of application anomalies and performance dips | | **Kaizen** | Iterative agent loops (e.g., ReAct) & platform updates | Continuous refinement of agent answers before final output delivery | | **Jidoka** | LangGraph human-in-the-loop workflows | Autonomous task handling paired with mandatory human intervention | | **Genchi Gembutsu** | LangSmith end-to-end trace inspection | Bypassing raw log dumps to isolate the exact failed prompt or tool call |

---

[15:21](https://www.youtube.com/watch?v=nUNuNxMhwug&t=921s) The LangChain Production System: Bedrock of the AI Era

In closing, Kordel summarizes how LangChain translates a century of proven automotive assembly discipline into the modern paradigm of agentic software development. While the Toyota Production System has served as the universally accepted foundation for hardware manufacturing across the globe, its principles had never seamlessly mapped to software engineering until graph-based and trace-driven AI ecosystems emerged. The transition from building brittle, one-off scripts to constructing auditable, standardized agents requires an operational philosophy capable of scaling safely.

Kordel argues that the AI community is witnessing the formation of a universal manufacturing standard for intelligent software. Just as industrial production adopted TPS to conquer defects and scale throughput, the artificial intelligence industry is establishing LangChain as its structural foundation. Expressing his conviction for the industry's trajectory, Kordel concludes: “And I fully believe that in the next few years — and actually probably now — the entire AI industry will look to LangChain as the TPS, or the LangChain Production System — the bedrock on which all the SaaS services, companies, et cetera, the entire industry is built on.”

- Unifying hardware and software: LangChain successfully brings century-old lean manufacturing concepts into modern agent design patterns. - Moving past bespoke code: Viewing agents as manufactured products enables enterprise teams to build reliable, modular production lines. - Industry-wide standardization: The overarching framework provides the foundational infrastructure upon which future AI services and enterprise SaaS platforms will be built.

## Notable quotes > [08:58](https://www.youtube.com/watch?v=nUNuNxMhwug&t=538s) The principles from hardware manufacturing translate really well into agent manufacturing. It's just a matter of the substrate — the matter that we're manufacturing. — Kordel France

> [01:40](https://www.youtube.com/watch?v=nUNuNxMhwug&t=100s) So six months became four days, six engineers became one. That is not an optimization. That's a different way of building. — Ravi Chandu Ummadisetti

> [14:11](https://www.youtube.com/watch?v=nUNuNxMhwug&t=851s) LangSmith traces are a direct embodiment of Genchi Gembutsu. For every query, every tool call, I can see the entire trace, the entire route to the solution. — Kordel France

## Mentioned Toyota, ToyotaGPT, LangChain, LangGraph, LangSmith, Ravi Chandu Ummadisetti, Kordel France, Harrison Chase, Braden Buffard, Toyota Motor North America, Toyota Production System, Model Context Protocol, GearPull, Gura, KadyaGPT, R&D GPT

## Video description Ravi Chandu Ummadisetti and Kordel France from Toyota's enterprise AI team explain how they built ToyotaGPT — a platform that reduced agent delivery from six months and six engineers to four days and one engineer, with over 50 agents now in production. Ravi walks through the architecture: dynamic LangGraph-based graph generation, auto-synthesized skills from unstructured data, and an MCP-compatible tool layer secured by TMNA's cybersecurity team from day one. Kordel then draws a striking parallel between TPS — Toyota's 100-year-old manufacturing philosophy — and LangChain's ecosystem, mapping Andon boards to LangSmith, Jidoka to LangGraph, and Genchi Gembutsu to trace-level debugging.

Chapters: 0:00 Introduction and the 2023 AI chaos inside Toyota 1:40 Why one RAG app used to take 6 engineers and 6 months 2:09 Dynamic graph creation on LangGraph: 6 months becomes 4 days 2:47 The extraction problem: Toyota's brutal data reality 3:38 The ToyotaGPT stack: LangGraph, LangSmith, MCP, and TMNA security 4:18 Skills: units of intelligence generated from unstructured data 5:06 50+ agents in production — every one is a config file 5:39 GearPull: from hackathon idea to millions in manufacturing savings 6:37 R&D GPT: compressing years of paint research into seconds 7:25 KadyaGPT: AI embedded inside the designer's canvas 8:58 Kordel France: TPS meets LangChain 10:14 Andon board = LangSmith observability 11:47 Kaizen = continuous improvement at macro and micro scale 13:04 Jidoka = LangGraph's human-in-the-loop design 14:11 Genchi Gembutsu = LangSmith trace-level debugging 15:21 LangChain as the TPS for the AI era

Resources: → LangGraph: https://www.langchain.com/langgraph → LangSmith: https://www.langchain.com/langsmith → LangChain Academy: https://academy.langchain.com

[Source](https://www.youtube.com/watch?v=nUNuNxMhwug)

Reading summary

To prevent decentralized chaos and duplicate development across 65,000 employees, Toyota built ToyotaGPT, an enterprise AI platform that deploys production agents through single configuration files while mapping core Toyota Production System principles to the LangChain ecosystem. Overcoming Enterprise Fragmentation via LangGraph Automation (0:05) When generative AI expanded in 2023, Toyota's enterprise AI team faced widespread operational bottlenecks as internal business units built isolated, redundant chatbots with custom ingestion routines. Establishing a single production Retrieval-Augmented Generation application originally required six engineers and six months of development time, primarily due to repetitive ingestion plumbing, cybersecurity reviews, and architecture approvals. Standardized Config-Driven Deployment and Data Ingestion (1:40) Toyota resolved this cycle by creating an automated dynamic graph generation engine built on LangGraph. Because baseline architecture and security guardrails were pre-certified with enterprise cybersecurity, an engineer now defines use cases and data connectors entirely within a single declarative configuration file, cutting deployment time to four days per agent without recurring architecture reviews. To handle heterogeneous legacy data without relying on third-party licenses, Toyota implemented in-house extractors using layout-aware parsing, vision-augmented OCR, and schema mapping. The system digests Word files, spreadsheets, multilingual documents in Japanese and English, scanned 1990s manuals, complex CAD files, and multi-nested engineering tables into a unified index, standardizing external tool access via the Model Context Protocol. Production Factory and Engineering Deployments (4:18) The platform has deployed more than 50 production agents configured via declarative files, supported by an intelligence pipeline that automatically synthesizes reusable skill modules directly from raw enterprise documents without manual engineering. Key active deployments include Gura, an enterprise memory agent codifying institutional history, and Vehicle AI Experts for mechanical catalog lookup. Manufacturing-focused agents have targeted costly factory downtime. GearPull indexed technical documentation across North American assembly plants, replacing physical binder lookups with machine diagnostics in under 10 seconds. In material design, R&D GPT retrieves historic test data to shorten traditional one-to-four-year automotive paint testing cycles. Similarly, KadyaGPT operates directly within vehicle tool and die engineers' CAD environments, providing real-time tolerance verification without application context switching. Mapping the Toyota Production System to Agent Lifecycle (8:58) Toyota AI engineering head Kordel France maps classical Toyota Production System (TPS) concepts directly into the software architecture of agent production. The physical Andon board—a visual display signaling factory line disruptions—is mirrored in software by LangSmith observability dashboards that flag failing tool calls, latency, and user friction points in real time. Other core TPS tenets dictate development and runtime loops. Kaizen (continuous improvement) is reflected both in fast platform updates and in self-correcting ReAct runtime iterations. Jidoka (automation with a human touch) appears as LangGraph human-in-the-loop controls that automate repetitive orchestration while requiring human sign-off at critical checkpoints. Finally, Genchi Gembutsu (going to the source to inspect defects) is implemented through LangSmith trace inspection, allowing engineers to bypass raw log files and diagnose specific failed prompt completions or tool invocations directly. France forecasts that the broader software industry will eventually adopt LangChain as a standardized 'LangChain Production System,' serving as a foundational manufacturing baseline for enterprise agent development much like TPS did for physical hardware.

Source quotes

[8:58] Kordel France: The principles from hardware manufacturing translate really well into agent manufacturing. It's just a matter of the substrate — the matter that we're manufacturing. [1:40] Ravi Chandu Ummadisetti: So six months became four days, six engineers became one. That is not an optimization. That's a different way of building. [14:11] Kordel France: LangSmith traces are a direct embodiment of Genchi Gembutsu. For every query, every tool call, I can see the entire trace, the entire route to the solution.

Original transcript

[0:05] >> Hi, everyone. I'm the head of Agent AI and product research at Toyota. I have Kordel [0:11] joining, who is the head of AI engineering. In 2023, when Generative AI changed the world, [0:17] inside Toyota, 65,000 people, multiple factories, and one question that we had was: [0:24] what do we do with this? We are the enterprise AI team. Every AI use case that's going to [0:29] production comes to our team. So one standard, one platform, no chaos, no duplication. The [0:36] problem is nothing existing before that could be what we wanted to do. So we opened up a blank [0:42] repository in our GitHub and built it ourselves. So this is the story I'm going to talk [0:47] about today. I'll show you how we built ToyotaGPT, a platform that ships AI agents in very few [0:56] days, then Kordel talks about how it connects with the Toyota Production System and how [1:02] LangChain, LangGraph, and LangSmith are really useful in our ecosystem today. That part really [1:07] surprised us. Let's go. So in 2023, every team at Toyota was rushing to build their [1:14] own chatbot. Same ingestion, same extraction, same pipeline — multiple duplicate things were [1:22] coming up. No security standards, no architecture standards, pure duplication at an enterprise [1:28] scale. Our job was to stop that. To be the platform every AI agent is built on. [1:34] The pressure was real, the timeline was yesterday. So what did we need to do? We needed [1:40] to go to work. One RAG app at Toyota used to mean six engineers and six months [1:47] in the early days — not because AI was hard, [1:50] but because everything around it is hard. [1:53] Security reviews, architecture sign-offs, [1:55] and ingestion plumbing across multiple data sources, [1:59] rebuilt from scratch. [2:02] Our delivery was stuck in months, [2:05] so that gap we decided to close permanently. [2:09] In four days, we built a dynamic graph creation approach [2:12] on LangGraph: give it the use case, [2:15] give it the data connectors, and the entire graph [2:19] builds itself automatically. [2:21] ReAct agents, deep agents — everything plugged in. [2:25] No security review, no architecture review. [2:28] It's all reviewed at once, because the architecture [2:31] never changes, the security never changes. [2:33] The only difference between every AI agent we build [2:37] is just a config file. [2:39] So six months became four days, six engineers became one. [2:43] That is not an optimization. [2:45] That's a different way of building. [2:47] The thing that kills every AI agent [2:50] before it even starts is the extraction. [2:53] Bad text in, bad text out. [2:56] Our data at Toyota is brutal. [2:59] PDFs, Word docs, Excel files, CAD files, AutoCAD. [3:05] You name it, we have it. [3:07] Scanned manuals from the '90s. [3:09] Toyota tables inside tables inside tables inside tables [3:12] inside images. [3:14] We have complex data sources at Toyota [3:18] because we have Japanese, we have English, [3:20] we have a lot of different languages. [3:23] Name the format, we built an extractor for it. [3:26] Layout-aware parsing and OCR with vision. [3:30] Schema mapping, every source, one unified index. [3:35] And we built it ourselves, cutting enterprise license costs. [3:38] LangGraph at the core — thanks to Harrison Chase [3:41] for building the great framework. [3:44] LangSmith for observability, vector databases, SharePoint, [3:48] and the TMNA cybersecurity team, baked in from day one, [3:53] working with us. [3:54] Every agent inherits this and is exposed via API. [3:59] ToyotaGPT web, internal apps, factory machines, [4:03] robotics — which uses LangGraph in the background — [4:07] vision-language-action models, [4:10] everything runs on top of this framework. [4:13] The pipeline is LangGraph end-to-end, routing dynamically [4:17] by source type. [4:18] But the concept I want you to take home is skills. [4:22] A skill is a unit of intelligence. [4:25] We do two things nobody else does at scale. [4:28] One: enterprise-grade skills shared across every agent. [4:33] One library, no drift, no duplication. [4:36] And two: we generate skills automatically [4:39] from unstructured data. [4:41] We have terabytes of data sitting in our databases. [4:43] Feed these documents into the pipeline, [4:47] skills emerge without a single engineer [4:49] writing them by hand. And on top, a unified tool layer — [4:55] MCP compatible. [4:57] Every tool secured for any AI agent. [5:02] You want it? [5:03] It's there. [5:04] Is it secure? [5:05] Already done. [5:06] Today, over 50-plus agents are in production, [5:09] every single one built on ToyotaGPT. [5:11] Every one is a config file. [5:13] From GearPull on the plant floor, [5:15] to Gura, the long-term memory of the entire enterprise — [5:19] the Toyota Way, Toyota's culture and principles [5:22] codified into an agent — and two vehicle AI experts [5:26] that know every Toyota model, every spec, [5:29] every history, all queryable in seconds. [5:32] Let me walk you through a few to show you what this platform [5:36] actually makes possible. [5:39] GearPull started as a hackathon idea. [5:43] One of our team members, Braden Buffard, had a vision. [5:46] What if every manufacturing engineer could just [5:49] type the problem and get the answer instantly? [5:53] Today, GearPull sits on terabytes of data [5:57] in our vector databases, [5:59] serving every manufacturing plant across North America. [6:03] Here's the reality it replaced. [6:05] When a production line goes down, [6:09] an engineer walks to a bookshelf and pulls a manual, [6:13] flips through the pages, manually searching for information, [6:17] and fixes the problem. [6:19] That takes hours and sometimes days. [6:22] But if a production line stops for a few hours, [6:24] we lose millions of dollars because we're not making cars. [6:28] Today: type the problem, get the solution in 10 seconds. [6:31] From hackathon idea to millions of dollars in savings. [6:34] That's GearPull. [6:37] R&D GPT. [6:39] This is close to my heart. [6:40] Every color you see on a Toyota on the road, [6:43] we created that from scratch. [6:46] We created the paint from scratch. [6:48] Years of R&D testing in extreme cold, extreme heat, [6:54] to make sure the quality doesn't degrade. [6:57] A year, sometimes two, sometimes two to four years. [7:01] Today, R&D GPT learns from decades of our own past research. [7:07] Deep research is really helping us solve that. [7:10] Now, techniques emerging from old technology, old knowledge — [7:14] what used to take multiple years, now compressed [7:18] because our own institutional knowledge [7:20] is now searchable, connectable, and queryable [7:23] within seconds. [7:25] And then KadyaGPT, the design agent [7:28] that lives inside the tool designer. [7:31] Already using new car designs, existing parts, existing designs, [7:35] it can query best practices, find differences, [7:38] identify patterns without ever leaving their canvas. [7:42] Zero context switching — the AI is just there in the workflow, [7:47] exactly where it needs to be. [7:50] When we started our journey with Harrison, [7:53] nothing existed. [7:54] We built the entire ingestion [7:56] formatted from scratch, from PDF files. [8:00] The LangChain ecosystem came to life [8:02] and then we built the framework using LangChain, [8:04] LangGraph, and deep agents. [8:07] Dynamic graphs automatically populating. [8:09] We built the skills engine — intelligence [8:11] that generates itself. [8:13] We built the tool layer: MCP-ready, enterprise-secured. [8:17] We took a hackathon idea and turned it [8:19] into terabytes of production. [8:21] 50 agents, millions of dollars in savings. [8:25] Built from zero, from scratch. [8:26] We learned every single thing as we went. [8:29] We didn't wait for the industry to catch up. [8:32] We went ahead and built it. [8:34] Now, Kordel is going to show us something that genuinely [8:37] surprised us about everything we built. [8:40] Toyota invented the philosophy behind it, [8:42] I think, on the factory floor in 1988. [8:45] Kordel, it's yours. [8:50] Thanks, Ravi. [8:52] [APPLAUSE] [8:58] Toyota is arguably the best automotive manufacturer [9:01] in the world, and by extension, one of the largest [9:04] and best hardware manufacturers. [9:06] And it got there through something called [9:08] the Toyota Production System. [9:10] The Toyota Production System, or TPS, [9:12] is a philosophy, a framework, for building a lot [9:16] of anything, really, really quickly [9:19] and with really minimal resources. [9:21] So by extension, it's a philosophy [9:23] on how we can build vehicles on a manufacturing line [9:26] very leanly, with minimal staffing, minimal resources — [9:30] make a manufacturing line modular, make it robust, [9:33] so that it's amenable to breakdowns [9:36] and keep continuous flow from raw materials all the way [9:39] to when a car comes out at the other end of the manufacturing [9:42] line. [9:44] The principles of TPS are really [9:48] the backbone for any scaled hardware manufacturing line [9:52] that we see today. [9:53] It started with Toyota. [9:54] It's been fashioned over the course of almost 100 years, [9:57] but really became formalized in the '80s — [9:59] as Ravi mentioned — in order to help Japan, [10:03] who had far fewer resources than North America, [10:05] compete on the North American automotive front. [10:08] TPS is the backbone [10:12] for all hardware manufacturing today. [10:14] And we see a very similar parallel between TPS and LangChain. [10:19] LangChain is the modern backbone [10:21] on which all next-generation software and agent workflows will be manufactured. [10:26] The principles from hardware manufacturing translate really well into agent manufacturing. [10:32] It's just a matter of the substrate — the matter that we're manufacturing. [10:36] And so this has been a really pleasing and quite awesome experience not only to use [10:43] LangChain's products but to become more embedded in their ecosystem, because they embody the [10:47] ethos from which Toyota was founded and all of the principles that our team shares [10:53] and works with every day. [10:56] So a couple of TPS principles that are pretty easy to identify with LangChain — starting with [11:01] the Andon board. [11:02] The Andon board in manufacturing is a way to see what's going on really quickly without [11:08] having to survey the whole manufacturing floor. [11:11] What's broken down? [11:12] What needs supplies? [11:13] What's going well? [11:15] You allocate resources to bolster another part of the manufacturing line that's dwindling. [11:19] And LangSmith is the literal embodiment of an Andon board. [11:24] We can see observability over all of our agents in real time. [11:29] Understand what tool calls aren't working, what features we should focus on for [11:33] the next PR, for the next product release, and what's going well with our users. [11:38] What are the frustration points? [11:39] How do we better serve our users and improve our software? [11:43] LangSmith is the direct analog of the Andon board. [11:47] One term you all are probably familiar with [11:50] is Kaizen, which is continuous improvement [11:53] through slow and steady, but consistent [11:58] modifications. [12:00] And software engineering culture really embodies that. [12:03] We're always pushing PRs, [12:05] we're always bolstering new products, [12:06] and we push updates regularly — sometimes nightly. [12:10] The great thing about Kaizen is that from the LangSmith perspective, or [12:15] LangChain perspective, there's really a macro level at which Kaizen is being implemented and a micro level. [12:20] At the macro level, the software is always improving. [12:23] Harrison just announced a bunch of new features today that are going to be a huge advantage to the ecosystem — already published. [12:32] And then at the micro level, there are agents that are continuously improving. [12:37] A very rudimentary example might be the ReAct agent — [12:40] something that's always monitoring its output [12:42] and continuously improving it to make sure [12:44] that before it presents the final response to the user, [12:47] it's actually correct and does what the user intended. [12:51] So this philosophy of continuous improvement [12:55] through steady and consistent changes [12:57] is something we embody at Toyota [12:59] and are delighted to see with LangChain [13:02] throughout the whole ecosystem. [13:04] My personal favorite is the principle of Jidoka. [13:08] Translated literally, it means automation with a human touch. [13:11] And what LangGraph does really well [13:13] is it automates a lot, or abstracts a lot of the nuance [13:18] and monotony that, as an engineer, [13:20] I don't want to have to deal with [13:21] or don't care to deal with. [13:24] But it keeps me in the loop. [13:25] It keeps me plugged in so that I still have the values of a human [13:28] and can still guide the product [13:30] as it's being developed and deployed. [13:32] And Jidoka is really like a handshake deal between AI, [13:35] automation, and a human — to say: I understand each role [13:39] that you play, and I understand we're going to have to adapt [13:41] as technology progresses. [13:43] On the manufacturing line, Jidoka means that a human [13:46] understands we need automation in order to manufacture things [13:50] very leanly and very efficiently. [13:53] But as technology evolves, a human's role will change, [13:57] because that automation will change. [13:59] But a human is still critical to ensuring [14:01] high quality of products and delivery to the final customer. [14:04] So, yeah, LangGraph is a literal embodiment of the Jidoka principle, which we love. [14:11] The next term is Genchi Gembutsu. [14:14] This means to literally go to the source and understand what's going on. [14:19] Try to find the root cause of the problem. [14:21] We can't figure things out on a Teams call. [14:25] If there's a manufacturing issue in Texas, we can't sit in California and [14:30] try to figure out what's going on. [14:31] The best way to solve the problem [14:32] is to go to the manufacturing line, [14:35] actually touch the hardware, [14:36] understand the root cause of the problem, [14:37] and then proliferate the solution [14:39] throughout the rest of the manufacturing line [14:41] so that we Kaizen the remedy. [14:44] LangSmith traces are a direct embodiment of Genchi Gembutsu. [14:48] For every query, every tool call, [14:50] I can see the entire trace, the entire route to the solution. [14:54] And if there's an issue, I can see exactly what caused it. [14:58] And so it goes beyond the Andon board [15:01] by giving me direct insight into what the problem is [15:05] for any one of my products, my bots, my agents, [15:08] and helps me as an engineer not have to sift through logs [15:12] or spend a lot of time debugging. [15:13] I can go directly to the problem, try to solve it, [15:16] and keep our products up and running for our customers. [15:21] LangChain is a direct embodiment [15:24] of the Toyota Production System philosophy. [15:27] And while the framework is timeless, [15:30] and TPS is the bedrock for all hardware manufacturing today, [15:35] it hadn't been well translated into software [15:39] or agentic manufacturing of agents — until LangChain. [15:43] LangChain carries the legacy of TPS forward, [15:46] allowing all these principles to be carried over [15:50] into manufacturing for the new era of software engineering. [15:55] And so I'm really excited to see where LangChain is going to go, [15:59] because our cultures are so similar. [16:01] And I fully believe that in the next few years — [16:04] and actually probably now — the entire AI industry [16:09] will look to LangChain as the TPS, or the LangChain Production [16:13] System — the bedrock on which all the SaaS services, [16:17] companies, et cetera, the entire industry is built on. [16:21] [APPLAUSE]