Ford Credit, the financial services arm of Ford Motor Company, deployed production-ready AI agents to automate the conversion of product requirements in Confluence into technical user stories. The problem addressed was the "blank page problem" where product managers had to manually translate high-level requirements into detailed technical user stories, leading to high cognitive load, variance in quality, and capacity drain. The solution involved building a user story agent using Google Cloud's Agent Development Kit and platform infrastructure, with extensive architectural controls including prompt injection defense, circuit breakers, rate limiting, human-in-the-loop gates, end-to-end telemetry, and rigorous evaluation frameworks. The results showed 24% improvement in user story fidelity, 40% faster story creation cycles, and significantly improved consistency, enabling better downstream automation and faster product execution.
Ford Credit deployed production-ready AI agents to solve a concrete business problem in their product development workflow. The use case centered on automating the creation of technical user stories from high-level product requirements stored in Confluence. This case study provides a comprehensive view of taking AI agents from prototype to production in a highly regulated financial services environment with zero tolerance for systemic risk.
The presentation features three speakers from Google Cloud discussing general principles of production AI agents, followed by Siddharth Jain from Ford Credit sharing their specific implementation journey. This combination provides both theoretical frameworks and practical, battle-tested implementation details.
Product managers at Ford Credit maintain their requirements in Confluence, but engineers need detailed technical user stories to build products. The manual conversion process created several challenges: high cognitive lift for PMs starting from scratch, significant variance in the structure and detail of user stories across different PMs, and substantial capacity drain on product management resources. This “blank page problem” was a recurring friction point in their development workflow.
Ford Credit operates in the financial services sector, providing flexible and affordable financial solutions to get people into Ford vehicles. Given their regulatory environment, they face strict compliance requirements, high security standards, and zero tolerance for systemic risk. Any AI solution needed to balance innovation and speed with absolute technical rigor.
The case study articulates a fundamental architectural paradigm shift from traditional deterministic systems to agentic architectures. Traditional systems have defined inputs with schemas, implement explicit processing steps, and produce deterministic outputs—they are predictable, safe, and rigid. In contrast, agentic architectures receive goals or objectives rather than structured inputs. The AI agent uses available context and data to reason through how to achieve the goal, then acts on that plan to deliver the solution. This makes agents adaptive, resilient, and flexible, but introduces a core tension: the blast radius of a single user message can be unbounded unless explicitly architected to prevent it.
The Google Cloud team outlined five fundamental principles for taking agents to production, breaking the agent development lifecycle into four buckets: build, scale, govern, and optimize.
Jumpstarting Agent Building: Different personas in an organization require different tools. Subject matter experts who don’t code can use visual canvases like Agent Studio with drag-and-drop components. Users with moderate coding skills can leverage pre-built enterprise-ready samples that can be deployed instantly to agent runtime or Gemini app enterprise. Hardcore developers can use frameworks like Agent Development Kit, which provides primitives for production agents including support for complex graphs, human-in-the-loop workflows, event-based triggers, and code sandboxes. Google recently launched Agent CLI as a programmatic interface for building, evaluating, and deploying agents to the agent platform.
Separating Concerns: The principle of separation of concerns, borrowed from microservices, applies differently to agents. Model Context Protocol provides an abstraction layer between agents and tools, preventing tight coupling. When an API schema or database changes, the agent code doesn’t need modification because it interacts with an MCP server that handles the endpoint communication. Agent-to-agent communication similarly uses protocol-based delegation rather than custom integration code. Skills represent another separation mechanism—instead of loading all business rules and constraints into the LLM context window, skills package roles, business rules, data, and resources into markdown files that agents load on demand. This optimization targets latency, cost, and context window usage.
Scaling Strategy: Critical decisions around memory and runtime must be made before scaling. Not all agents require memory—simple lookup or stateless agents don’t benefit from it. For agents where context matters, organizations face build-versus-buy decisions. Traditional RAG pipelines for long-term memory make sense for niche use cases or compliance-based requirements, but for out-of-the-box solutions, Google’s Agent Platform provides sessions (365-day TTL short-term memory auto-provisioned for agents) and memory bank (ready-to-use vector database with semantic search that works asynchronously). Runtime selection involves weighing infrastructure, scaling, flexibility, and cost against agent-specific needs like human-in-the-loop support, long-running operations, and native integration with memory, security, and guardrails. Agent Platform Runtime offers built-in features with support for bring-your-own containers and seven-day TTL for long-running operations. Cloud Run suits those preferring Docker and portable solutions, while GKE makes sense only for massive high-traffic agent fleets. A common pattern is deploying the agent reasoning engine to Agent Runtime while running MCP tools on Cloud Run, maintaining separation of concerns.
Governance Through Infrastructure: AI governance cannot rely on prompt engineering—telling an agent “please don’t delete my database” in the prompt doesn’t work reliably. Infrastructure-based governance addresses three problem classes: visibility (what agents and tools exist in the domain), control (what agents and tools can access and how to scope them), and security (how to proactively detect malicious rogue agents). Google’s Agent Platform provides agent identity (SPIFFE-backed IDs automatically applied to deployed agents that support OAuth providers and automatically manage API keys), agent registry (single pane of glass for all agents and tools in the domain, supporting external third-party services), agent policies (scoping agent permissions through IAM and natural language policies), and agent gateway (single governance layer monitoring traffic between ingress and egress pathways, enforcing IAM policies and principles).
Observation and Evaluation: Agent observability and evaluation are interdependent. Production agents require logs, traces, and metrics, supported by Google Cloud’s observability stack. Agent evaluation extends beyond output testing to trajectory testing—did the agent take the right path to achieve the right outcome? Metrics can be human-defined or LLM-defined. Simulator sessions provide pre-production evaluation capability by synthetically generating production traces to run against agents before deployment.
The case study advocates strongly against “God agents”—single agents handling everything. This anti-pattern should only be used for prototyping, simple tasks, specific workflows, or low-stakes internal debugging. Production systems benefit from specialization: creating separate agents for different responsibilities (like policy agents and investigation agents) enables risk containment and independent debugging of each agent’s “brain.”
Several advanced design patterns emerged from production deployments:
Guardrail Agents: These enforce core restrictions deterministically. Even if the underlying LLM is unpredictable, guardrail agents maintain 10-15 non-negotiable principles that cannot be violated.
Self-Reflection Agents: Basic bots report failures, but production-grade agents investigate themselves, determine what went wrong, and create outcomes. A self-reflection agent might recognize it used the wrong service account, identify the correct one, and adjust accordingly.
Sandbox Agents: When agents execute code, they need ephemeral, secure sandbox environments created for specific tasks and timeframes.
Council of Agents: For high-stakes decisions, single-brain decision-making is insufficient. A council of agents represents multiple reasoning systems debating and collaborating to reach consensus before taking action. This pattern suits scenarios like billion-dollar contract decisions.
Cost Optimization Through Routing: For a cyber guardian agent processing gigabytes of logs, routing less critical work through Gemini Flash (Google’s least expensive model) rather than Gemini Pro significantly reduces costs without compromising performance on high-value tasks.
Ford Credit built a user story agent that ingests product requirements from Confluence, understands context, and creates draft user stories for product managers. Rather than starting from scratch, PMs now edit and refine agent-generated drafts before pushing to backlog. This shifts the PM role from creation to high-value editing and approval.
Control Mechanisms: Ford Credit implemented multiple layers of control to contain the blast radius. Prompt injection defense uses tools like Model Armor with custom sanitization to prevent malicious input from reaching the agent. Compute circuit breakers implement token budgets for every agent execution step—when exceeded, the agent either moves to the next step or fails gracefully, preventing infinite loops. Rate limits prevent mass action execution, ensuring users cannot knowingly or unknowingly create thousands of user stories in minutes. Human-in-the-loop gates are deterministically enforced at the system level, not through prompting. When the agent needs to create a story, the system requires user approval before taking the critical action.
Observability Infrastructure: End-to-end telemetry tracing records everything in a single user-agent interaction: system prompt, user prompt, tools used, inputs provided to tools, tool outputs, how the agent reasoned using tool outputs, and final output. This comprehensive tracing enables root cause analysis when bugs occur or the agent behaves unexpectedly. FinOps for LLMs encompasses both optimization and measurement. Token usage optimization leverages skills, agent-to-agent protocols, MCP, and subagents to avoid bloating the system prompt. Cost tracking is essential for ROI calculation—leaders need to understand the relationship between spending and efficiency gains. Without cost tracking, organizations cannot assess the impact of LLM version changes, provider switches, or token price increases. User context propagation implements on-behalf-of execution, so when the agent creates a user story, the PM’s name appears as the creator, maintaining clear responsibility chains.
Testing the Unpredictable: Ford Credit emphasizes that production readiness requires rigorous evaluation despite the underlying non-deterministic nature of LLMs. Risk measurement is non-negotiable. The current user story agent includes human-in-the-loop, making higher risk acceptable. However, for future automated workflows without human oversight, significantly higher accuracy becomes essential. Risk level measurement enables engineering and product leadership to make informed decisions about acceptable risk relative to efficiency gains. Evaluations cannot be one-time efforts—they must be embedded in deployment gates to catch drift over time. If an agent doesn’t meet risk thresholds, it doesn’t reach production.
Ford Credit tracked three KPIs to measure success. High fidelity showed 24% improvement compared to manual user stories in terms of structure, level of detail, and engineering unblocking. Faster cycles reduced drafting from hours to minutes, with 40% improvement in PM user story creation speed. Consistency proved most valuable long-term because controlling variance in user story output (through higher fidelity) enables more deterministic downstream agents—predictable input structure makes agents more reliable.
The broader impact extends beyond immediate efficiency gains. Better stories lead to better products and faster execution. The consistency achieved creates a foundation for future automation, as downstream agents can rely on structured, high-quality inputs.
The implementation leverages Google Cloud’s Agent Platform ecosystem extensively. Agent Development Kit provides the foundational framework with native support for MCP, agent-to-agent protocols, and skills. Agent Platform Runtime handles deployment with built-in memory and security integrations. Agent Registry provides governance and cataloging capabilities to manage agent sprawl. Agent Gateway enforces policies and monitors traffic. The observability stack captures comprehensive telemetry. Gemini models (both Pro and Flash) power the reasoning engines, with strategic routing optimizing for cost.
The case study concludes with three fundamental takeaways that challenge common assumptions in the AI agent space. Prompting does not prevent non-deterministic behavior—hard, deterministic guardrails around agents are essential. Organizations must govern the thinking, not just the output, requiring observability across the entire AI reasoning process. Moving from “vibes” to rigorous evaluations means abandoning “it looks like it’s working” in favor of hard metrics that enable controlled future development.
The presentation positions this work within a larger historical arc: in the last decade, organizations built microservices to scale code; in the next decade, they will build agents to scale reasoning. This framing suggests a fundamental shift in how organizations approach productivity and automation.
The Ford Credit case demonstrates that deploying AI agents in highly regulated environments with stringent security and compliance requirements is achievable with proper architectural patterns. The key is treating agent deployment not as a prompt engineering problem but as a systems engineering challenge requiring comprehensive solutions for control, observability, and evaluation. The “agent chaos” that inevitably emerges as organizations scale from one or two agents to many can be managed through proper tooling and governance infrastructure, but this requires proactive planning rather than reactive responses to problems.
Snorkel developed a specialized benchmark dataset for evaluating AI agents in insurance underwriting, leveraging their expert network of Chartered Property and Casualty Underwriters (CPCUs). The benchmark simulates an AI copilot that assists junior underwriters by reasoning over proprietary knowledge, using multiple tools including databases and underwriting guidelines, and engaging in multi-turn conversations. The evaluation revealed significant performance variations across frontier models (single digits to ~80% accuracy), with notable error modes including tool use failures (36% of conversations) and hallucinations from pretrained domain knowledge, particularly from OpenAI models which hallucinated non-existent insurance products 15-45% of the time.
Prudential Financial, in partnership with AWS GenAI Innovation Center, built a scalable multi-agent platform to support 100,000+ financial advisors across insurance and financial services. The system addresses fragmented workflows where advisors previously had to navigate dozens of disconnected IT systems for client engagement, underwriting, product information, and servicing. The solution features an orchestration agent that routes requests to specialized sub-agents (quick quote, forms, product, illustration, book of business) while maintaining context and enforcing governance. The platform-based microservices architecture reduced time-to-value from 6-8 weeks to 3-4 weeks for new agent deployments, enabled cross-business reusability, and provided standardized frameworks for authentication, LLM gateway access, knowledge management, and observability while handling the complexity of scaling multi-agent systems in a regulated financial services environment.
Toyota Motor North America (TMNA) and Toyota Connected built a generative AI platform to help dealership sales staff and customers access accurate vehicle information in real-time. The problem was that customers often arrived at dealerships highly informed from internet research, while sales staff lacked quick access to detailed vehicle specifications, trim options, and pricing. The solution evolved from a custom RAG-based system (v1) using Amazon Bedrock, SageMaker, and OpenSearch to retrieve information from official Toyota data sources, to a planned agentic platform (v2) using Amazon Bedrock AgentCore with Strands agents and MCP servers. The v1 system achieved over 7,000 interactions per month across Toyota's dealer network, with citation-backed responses and legal compliance built in, while v2 aims to enable more dynamic actions like checking local vehicle availability.
