Databricks
Machine learning cannot scale across corporate decision-making until autonomous agents take over ongoing model maintenance, which currently consumes up to 80% of engineering time.
AI-assisted summary of Agentic machine learning with Genie Code (includes demo) — original source. Check the original for full context.
Source published:
Key ideas
- Databricks introduced AI Runtime with serverless, on-demand GPUs and multi-node distributed training support for deep learning and LLMs, entering public preview with zero upfront commitments. (7:46)
- Genie Code for ML is now generally available, embedding domain-specific engineering heuristics and native integrations across Databricks feature engineering, training, serving, and monitoring. (8:57)
- Genie ZeroOps for ML launches later in the summer to invert production operations, autonomously investigating alerts, engineering missing features, retraining models, and presenting production-ready fixes for human approval. (13:20)
- Danfoss leveraged Genie Code's ontology-driven context to build and deploy a complete production ML system in 90 minutes, bypassing the weeks or months of typical engineering lead time. (9:57)
Detailed notes
## Background Published by Databricks on YouTube on June 24, 2026, this keynote presentation highlights Genie Code's upgraded intelligence for machine learning engineering. According to the description, the release delivers native integrations across every Databricks ML Platform layer, including feature engineering, model training, serving, and monitoring.
## TL;DR Databricks leaders Mike Del Balso and Amber Roberts outline how autonomous AI agents can overcome the decades-old technical debt and maintenance burden of production machine learning. The keynote introduces AI Runtime for serverless GPU-powered deep learning training, Genie Code for ML to construct context-aware pipelines using organizational tribal knowledge, and Genie ZeroOps for ML to automate operational triage and patching. A live demonstration illustrates Genie ZeroOps autonomously diagnosing an accuracy regression in a ticket forecasting model, engineering missing tournament features, retraining the pipeline, and serving a verified candidate model for human approval.
## Atmosphere & style The presentation carries the confident, polished cadence of a major developer keynote, balancing seasoned industry reflection with forward-looking technical ambition. Mike Del Balso establishes an authoritative yet accessible narrative, connecting his foundational MLOps background at Google and Uber to modern generative AI pressures. Amber Roberts's live demo introduces relatable operational tension by framing the scenario around a high-stakes Friday afternoon alert, delivering a satisfying and pragmatic payoff as autonomous agents replace weekend firefighting with a single click of human governance.
## Bulletin - [07:46](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=466s) Databricks introduced AI Runtime with serverless, on-demand GPUs and multi-node distributed training support for deep learning and LLMs, entering public preview with zero upfront commitments. - [08:57](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=537s) Genie Code for ML is now generally available, embedding domain-specific engineering heuristics and native integrations across Databricks feature engineering, training, serving, and monitoring. - [13:20](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=800s) Genie ZeroOps for ML launches later in the summer to invert production operations, autonomously investigating alerts, engineering missing features, retraining models, and presenting production-ready fixes for human approval. - [09:57](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=597s) Danfoss leveraged Genie Code's ontology-driven context to build and deploy a complete production ML system in 90 minutes, bypassing the weeks or months of typical engineering lead time.
## Key takeaways - [00:00](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=0s) The core machine learning code represents only a tiny fraction of a production system, while the surrounding data ingestion, serving, and monitoring infrastructure creates massive technical debt. - [01:12](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=72s) Generative AI is accelerating the demand for traditional ML by generating massive volumes of new software that require automated decision points like pricing, fraud detection, and recommendations. - [03:43](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=223s) Automating ML has historically lagged behind software engineering automation due to a lack of cohesive, closed-loop infrastructure and the absence of rich tribal context for autonomous agents. - [04:44](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=284s) Databricks redesigned its platform over 18 months to make it agent-ready using 100% serverless compute, a unified instrumented data model, and action-level governance in Unity Catalog. - [07:46](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=466s) AI Runtime provides serverless GPU infrastructure that scales on demand without upfront commitments, supporting both single-node and multi-node distributed training for frontier models. - [09:57](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=597s) Genie Code incorporates organizational ontology and tribal knowledge to reuse existing pipelines, adhere to internal evaluation scripts, and generate production-grade code that matches senior engineer output. - [13:20](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=800s) Because teams spend 60% to 80% of their time maintaining existing deployments, multiplying development speed by 100 will create an unsustainable operational crisis without automated maintenance. - [14:26](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=866s) Genie ZeroOps inverts traditional alerting by placing an autonomous agent on call 24/7 to triage alerts, test hypotheses, and retrain models while human engineers act as approvers. - [16:07](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=967s) In a live demonstration, Genie ZeroOps detected a ticket forecasting failure, diagnosed an omitted knockout-stage feature, engineered the new feature, retrained the model, and prepared a fix within 30 minutes. - [20:19](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=1219s) Operators can review the agent's evaluation benchmarks and roll out candidate models to live traffic with a single click, eliminating high-severity operational downtime. - [21:40](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=1300s) Automating the end-to-end development and operations lifecycle enables enterprises to manage 100 times more models and replace static business heuristics with intelligent ML decisions.
## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=0s) The Hidden Technical Debt of Production Machine Learning
Mike Del Balso, Director of Product Management at Databricks, steps onto the stage, quipping that the walk out was deceptively long. He reflects on his career dedicated to production machine learning, tracing his roots back to the Google Ads ML teams that helped spark the MLOps discipline, co-founding the ML team at Uber where he built and led the Michelangelo platform, and running his own production ML startup that recently joined Databricks. Across that entire journey, he notes, the machine learning industry has chased a single, persistent dream: “And the whole time, my whole career, the whole machine learning industry has had one goal, and a single dream, which is to make machine learning as easy and automated as possible, so we can bring intelligent decisions to all of the important places, all the important decisions across our business.”
Displaying the iconic technical debt diagram from a paper his Google team published roughly twelve years earlier, Del Balso emphasizes that actual machine learning code occupies just a tiny red box in the center. Everything surrounding it consists of the massive, complex peripheral systems required to build, run, and maintain true production deployments—systems that are fundamentally data problems under the hood. While many expected generative AI to dampen the demand for traditional machine learning, Del Balso argues it has achieved the exact opposite. Companies are deploying vast amounts of new software, creating an explosion of critical decision points: more product recommendations, dynamic pricing calculations, fraud detection evaluations, and automated loan decisions.
Because production ML remains painfully difficult, organizations are forced to ration it, reserving models for only a handful of critical workflows. When compared against the thousands of other business decisions that could be automated, companies continue to rely on static logic, rigid heuristics, and simple rules of thumb. As Del Balso puts it: “And because we're not using intelligent machine learning there, we're leaving money on the table.” Automating this workflow is exceptionally hard because human experts—such as data scientists and PhDs—are embedded at every stage of the lifecycle deciding which features to craft, which models look viable, what objective metrics to optimize, and which candidates deserve promotion to production.
- Google Ads ML engineering teams originally laid the conceptual foundation for modern MLOps. - Mike Del Balso co-created and led Michelangelo, Uber's pioneering internal machine learning platform. - The classic Google paper illustrating the "hidden technical debt" of ML systems was published approximately 12 years prior.
```mermaid flowchart TD accTitle: The Reality of Production Machine Learning Systems accDescr: A diagram contrasting the small ML code core with the vast peripheral infrastructure required in production.
subgraph Periphery["Vast Data & Operational Infrastructure"] DataIngest["Data Collection & Verification"] FeatEng["Feature Extraction & Pipelines"] ResourceMgmt["Resource Management & Serving"] Monitor["Analysis & Monitoring Tools"] end
subgraph Core["The Small Center"] MLCode["ML Code"] end
DataIngest --> MLCode FeatEng --> MLCode MLCode --> ResourceMgmt MLCode --> Monitor ```
---
[03:43](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=223s) Why AI Agents Are the Only Path to Full ML Automation
Del Balso asserts that software and traditional code alone cannot solve this bottleneck; artificial intelligence agents represent the only technology capable of automating machine learning end-to-end. While AI coding agents have already completely overhauled general software engineering, machine learning workflows remain stuck in their traditional manual patterns. Del Balso explains that this lag is driven by two specific blockers across the industry:
1. **Infrastructure maturity:** Only a small handful of companies possess the sophisticated, cohesive infrastructure required to support a fully closed, automated machine learning loop. 2. **Context deficit:** Agents cannot replicate the choices of expert machine learning engineers unless they have access to the exact same depth of domain, pipeline, and operational context.
Databricks aims to bridge this gap by delivering both agent-ready machine learning infrastructure and specialized agents capable of navigating that infrastructure with deep organizational context. Del Balso stresses that agents must do more than execute blind scripts: “Second, of course, we need the agents that can drive the loop with your context to do it in the same way that your teams would do.”
---
[04:44](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=284s) Building Agent-Ready ML Infrastructure on Databricks
Turning to infrastructure, Del Balso notes that Databricks has spent over a decade constructing its data science and machine learning platform, leading to its industry recognition as the top-right leader in data science and ML platforms. However, that entire surface was designed for human practitioners. Over the past 18 months, Databricks focused on redesigning and optimizing the entire ML stack to make it completely agent-ready through three core architectural pillars:
- **100% Serverless Operations:** Agents should never spend time configuring compute clusters, diagnosing environment dependencies, or managing machine state. Compute is completely serverless out of the box, allowing agents to instantly spin up, scale, and tear down resources on demand. - **Unified Instrumented Data Model:** The end-to-end lifecycle—spanning training datasets, feature tables, inference logs, serving payloads, and live monitoring metrics—is unified inside the same governed data model. This single source of truth allows an agent to immediately observe the downstream impact of an upstream pipeline tweak. - **Default Governance for Agent Actions:** While machine learning assets like models, experiment tracking runs, and serving endpoints already live under Unity Catalog, governance has now been extended to the precise actions and mutations agents can perform, guaranteeing auditability and operational trust.
As Del Balso summarizes: “The problem is that we solved we built all of this and we solved all of these problems for humans to build an ML. But now we're going to have agents do it for us.”
- Over 500 million machine learning models were trained on the Databricks platform in the past year alone. - Unity Catalog governs both static assets (models, features, endpoints) and the runtime actions permitted to autonomous agents.
---
[07:46](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=466s) Introducing AI Runtime and Genie Code for ML
Del Balso announces the launch of **AI Runtime**, a brand-new Databricks compute architecture built specifically for training deep learning models and large language models (LLMs). AI Runtime offers on-demand, serverless GPUs that require zero upfront financial commitments, enabling teams to scale elastic GPU compute instantly. During its initial two-month preview, hundreds of enterprises migrated deep learning workloads onto the runtime—including pharmaceutical giant Merck, who partnered with Databricks to train advanced drug discovery models. Expanding the capability further on launch day, Del Balso announces that AI Runtime now includes full support for multi-node distributed training, opening up large-scale foundation model development on arbitrary dataset sizes.
With the underlying infrastructure transformed into an agent-ready foundation, Del Balso transitions to the agents built to drive the lifecycle: **Genie Code for machine learning**. Available immediately, Genie Code for ML introduces upgraded engineering intelligence specifically tuned for real-world machine learning tasks, rather than generic web development or basic script generation. It incorporates operational heuristics drawn from Databricks’ vast production exposure and features native, out-of-the-box integrations with every layer of the Databricks ML ecosystem, including feature stores, model training runs, deployment infrastructure, and live system monitoring.
Del Balso captures the motivation behind tailoring the model: “Nobody has seen more machine learning in the real world than Databricks. So, we've taken all of those lessons, what works, what doesn't work, what good looks like in production, and we've built that into Genie code.”
- AI Runtime provides serverless, on-demand GPU clusters with no upfront resource commitments. - The platform was validated in private preview across hundreds of enterprises, notably powering Merck's drug discovery models. - Multi-node distributed training support is added to AI Runtime to accommodate frontier deep learning datasets and architectures. - Genie Code for ML is directly integrated across the Databricks feature engineering, model training, model serving, and pipeline monitoring APIs.
[09:57](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=597s) Context and Ontology in Genie Code
Mike Del Balso highlights that what excites him most about the latest release is the upgraded context built into Genie Code, which enables the agent to understand how data science and machine learning teams actually operate. Reflecting on an older ML platform diagram from a decade prior, he notes that earlier tools only solved the human interface problem. In reality, when human engineers drive an ML lifecycle, they make decisions based on institutional memory and tribal knowledge scattered across an entire platform: remembering past experiments, interpreting business metrics, recalling past failures, and locating company-approved evaluation scripts. Without direct access to this distributed context, an autonomous agent risks using the wrong datasets, running improper evaluations, and producing output that looks plausible on the surface but cannot be trusted.
```mermaid flowchart TD accTitle: Genie Code Context and Ontology Architecture accDescr: Flowchart showing how Genie Ontology feeds tribal knowledge and institutional context into Genie Code to automate model building. subgraph Context["Genie Ontology (Tribal Knowledge)"] A["Feature Patterns & Workflows"] B["Historical Experiments & Metrics"] C["Existing Training Pipelines"] D["Standardized Evaluation Scripts"] end
subgraph Agent["Genie Code Agent Loop"] E["Feature Engineering"] F["Pipeline Construction"] G["Evaluation & Benchmarking"] end
subgraph Outcome["Production Delivery"] H["Senior ML Engineer Level Output"] I["Rapid Production ML Deployment"] end
Context --> Agent A --> E B & C --> F D --> G Agent --> Outcome E & F & G --> H --> I ```
To resolve this limitation, Databricks integrated Genie Code with Genie ontology, which was unveiled the previous day by Ken. By infusing ontology into Genie Code, the agent understands how a company's specific ML teams build, test, and validate models. It constructs features using the exact conventions already adopted by the organization, reuses existing training pipelines, and honors proprietary evaluation scripts. Because it evaluates candidate models against the team's existing baseline metrics, data scientists can rely on its recommendations. Del Balso explains that this context allows Genie Code to act like a senior machine learning engineer embedded directly on the team, outperforming other leading coding agents on real-world data science tasks.
- Danfoss, a multinational engineering corporation, leveraged this capability to move from zero machine learning footprint to a complete production ML system in just 90 minutes. - Traditional deployment workflows for comparable systems typically require weeks, months, or entire quarters of engineering effort. - “We've found that Genie code performs way better on real-world data science and machine learning tasks than other leading coding agents now,” Del Balso states.
---
[13:20](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=800s) The Maintenance Crisis and Introducing Genie ZeroOps for ML
While speeding up model development is an enormous leap forward, Del Balso cautions that the initial build phase accounts for only a fraction of an ML engineer's daily reality. Real-world teams spend between 60% and 80% of their working hours maintaining existing applications rather than creating new ones. Accelerating model development by a factor of 100 will inevitably lead to organizations creating 100 times more models, creating a proportional operational burden that no engineering staff could realistically support. Once a model is deployed, teams face a long tail of operational failures: feature values drift over time, inference servers encounter latency spikes, upstream data pipelines break, and edge-case errors degrade performance.
```mermaid flowchart LR accTitle: Traditional Monitoring versus Genie ZeroOps Paradigm accDescr: Comparison showing the shift from traditional alerting to autonomous investigation, remediation, and human approval. subgraph Traditional["Traditional Monitoring"] T1["Metric Degradation"] --> T2["Alert Fired"] --> T3["Page On-Call Engineer"] --> T4["Manual Root Cause & Patch"] end
subgraph ZeroOps["Genie ZeroOps for ML"] Z1["Continuous Monitoring"] --> Z2["Autonomous Root Cause Investigation"] --> Z3["Generate Fix & Retrain"] --> Z4["Human Review & One-Click Approval"] end ```
To automate the operational side of the lifecycle, Del Balso introduces Genie ZeroOps for machine learning, describing it as the single biggest launch in machine learning over the past decade. Traditional monitoring tools merely track metrics and page human operators when a threshold breaks, leaving engineers to do the heavy lifting of triage and repair. In contrast, Genie ZeroOps for ML detects an issue, autonomously investigates the root cause, tests hypotheses, and delivers a completed, production-ready fix directly to the team. This completely inverts the industry's historical operational model: an agent remains on call around the clock, while human engineers step into the supervisory role of reviewing and approving validated solutions.
- Production ML systems regularly succumb to a long tail of thousands of operational failure modes, including data drift, inference latency spikes, and broken data dependencies. - Genie ZeroOps monitors every deployed model continuously while enforcing human-in-the-loop governance prior to any production deployment. - “And zero ops for ML inverts that and allows an agent to be on call and your team is just in a position to approve the recommendations from that agent,” explains Del Balso before welcoming Amber Roberts to the stage for a live demonstration.
---
[16:07](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=967s) Live Demo: Autonomously Resolving Issues with Genie ZeroOps
Amber Roberts, Staff Tech Marketing Engineer at Databricks, demonstrates how Genie ZeroOps pinpoints and resolves machine learning defects in real time. She frames the demonstration around a real-world scenario at Berkshire Sports Global, where her team maintains a mission-critical production model that forecasts ticket sales for every match of the Data and AI World Cup. Because ticket sales forecasts directly guide tens of millions of dollars in venue staffing and operational overhead—and mispricing risks leaving stadiums half-empty—predictive precision is essential. To safeguard the pipeline, Roberts prompts Genie Code to establish an automated alert that fires whenever actual ticket sales deviate by more than plus or minus 5% from forecasted values. Genie Code generates, configures, and registers the alerting agent without requiring manual infrastructure setup.
Roberts then fast-forwards the scenario to Friday at 5:30 p.m., just as an engineer emerges from back-to-back meetings to find that the accuracy alert triggered 30 minutes earlier. Instead of an engineer spending the weekend manually tracing error logs, the notification features a "View investigation in Genie ZeroOps" link that navigates directly into the ZeroOps inbox. While the engineer was away, Genie Code had already opened an incident thread marked with the highest severity and spent the preceding half hour testing dozens of hypotheses. Leveraging the ontology of the workspace, the agent inspected model notebooks, queried Unity Catalog tables, ran SQL diagnostics, monitored feature distributions, and evaluated recent MLflow experiment runs to identify the failure point.
The agent determined that the model suffered from an omitted feature representing the specific tournament stage. Without this variable, the model failed to account for the surging consumer demand and fan attention associated with knockout matches, leading to a sudden loss in predictive accuracy as group play ended. Rather than stopping at diagnosis, Genie Code discovered existing, unutilized match metadata, synthesized new features for tournament rounds and team matchups, retrained the candidate model, performed hyperparameter optimization, and registered the updated artifact in MLflow. Because it preserved complete lineage across the project, Genie Code applied the team's original validation criteria to benchmark the new model against historical standards before presenting the finished fix for approval.
- “And this model is mission critical because that forecast affects tens of millions of dollars in event staffing and operation spend,” Roberts emphasizes. - The monitoring alert was defined to trigger whenever observed ticket sales deviated beyond a ±5% margin relative to predicted game attendance. - Genie ZeroOps autonomously explored and eliminated dozens of potential failure modes across Unity Catalog, SQL queries, and MLflow runs within 30 minutes of the alert firing. - The identified root cause was a missing knockout-stage demand feature, which Genie Code resolved by engineering features from existing match data and retraining the pipeline following Databricks best practices.
[20:19](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=1219s) Deploying the Retrained Model and Eliminating Operational Toil
Amber Roberts wraps up the live demonstration by reviewing the results of the automated fix generated by Genie Code. The new candidate model restores model accuracy and brings the forecasting pipeline back to expected operational levels. Because she was able to inspect the exact evaluation metrics and validation benchmarks used by the agent, Amber feels fully confident rolling out the new candidate to a small percentage of production traffic. With a single click, she promotes and deploys version two of the model, bringing the remediation process to an end without manual coding.
```mermaid flowchart LR accTitle: Genie ZeroOps Incident Remediation Flow accDescr: Progression from alert and agent evaluation to single-click production rollout.
subgraph Evaluation ["Evaluation & Verification"] A["Alert: Degraded Accuracy"] --> B["Genie Code Diagnoses & Retrains"] B --> C["Review Evaluation Benchmarks"] end
subgraph Deployment ["Rollout"] C --> D["Deploy Candidate (v2)"] D --> E["Route Low % of Traffic"] E --> F["Incident Fully Resolved"] end ```
Amber contrasts this seamless experience with the traditional engineering reality of diagnosing and patching stale models in production. She notes that in standard environments, model degradation triggers high-severity team incidents that consume days of engineering time and risk tens of millions of dollars in business losses. By automating root-cause diagnosis, feature retraining, and verification, Genie ZeroOps eliminates this operational drag, allowing data teams to manage massive model fleets without linear increases in headcount. As Amber emphasizes: “Give ML teams the tools that they need to stop spending all this time fighting operational toil and start building breakthrough AI.”
- **One-click deployment:** Engineers can promote agent-generated model versions (such as version two demonstrated) directly into serving endpoints after verifying evaluation results. - **Incident severity mitigation:** The agent resolves stale-model incidents that typically disrupt entire teams for hours or days, directly averting potential eight-figure business impacts. - **Scaling ML operations:** Addressing operational toil is presented as the primary requirement for surviving the transition into the "100X era of ML," where organizations must support a hundredfold increase in model volume and complexity.
[21:40](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=1300s) Recap, Availability, and the Automated ML Era
Mike Del Balso returns to the stage to summarize the keynote's three major platform announcements and outline their release statuses. First, Databricks AI Runtime is available in public preview, providing serverless GPU infrastructure optimized for deep learning models and LLMs. Second, Genie Code for ML is generally available directly within existing Genie Code environments on user laptops. Third, Genie ZeroOps for ML will arrive in the summer, delivering full-loop autonomous incident management.
Reflecting on the overarching history of the field, Mike reminds the audience that the long-standing vision of the machine learning discipline has always been full automation. By combining agent-ready, managed infrastructure with intelligent agents capable of driving the development and maintenance loops, teams can now develop systems 100 times faster and manage 100 times more models. Mike states the strategic outcome clearly: “The machine learning industry has always been about automating machine learning, and we're finally at the point where we have the infrastructure and we have the agents to drive the loop.” This capability enables businesses to scale ML into every granular operational decision and deliver personalization across all touchpoints while engineers direct their energy toward future breakthroughs.
- **AI Runtime:** In public preview; delivers serverless GPU support designed for building deep learning architectures and large language models. - **Genie Code for ML:** Generally available (GA); integrated directly into the local Genie Code tooling on developer machines. - **Genie ZeroOps for ML:** Slated for release later in the summer to handle automated monitoring, retraining, and operational remediation. - **Vision for 100X ML:** Autonomous agents close the loop on routine ML workflows, allowing companies to apply optimized ML decision-making across all core products.
## Notable quotes > [21:40](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=1300s) The machine learning industry has always been about automating machine learning, and we're finally at the point where we have the infrastructure and we have the agents to drive the loop. — Mike Del Balso
> [07:46](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=466s) Nobody has seen more machine learning in the real world than Databricks. So, we've taken all of those lessons, what works, what doesn't work, what good looks like in production, and we've built that into Genie code. — Mike Del Balso
> [20:19](https://www.youtube.com/watch?v=C1rEj2VQtwU&t=1219s) Give ML teams the tools that they need to stop spending all this time fighting operational toil and start building breakthrough AI. — Amber Roberts
## Mentioned Databricks, Genie Code, Genie ZeroOps, AI Runtime, Unity Catalog, MLflow, Mike Del Balso, Amber Roberts, Google, Google Ads, Uber, Michelangelo, Merck, Danfoss, Berkshire Sports Global
## Video description Genie Code now comes with upgraded intelligence for ML engineering and native integrations across every Databricks ML Platform component: feature engineering, model training, serving, and monitoring.
Learn more: https://www.databricks.com/blog/whats-new-ai-platform-agents-ml-engineering-our-deep-learning-platform-and-new-capabilities
00:00 — Mike Del Balso, Director, Product Management, Databricks 01:12 — The hidden tech debt of ML systems 03:43 — AI agents are the the only way to automate ML 04:44 — Agent-ready infrastructure with Databricks 07:46 — Introducing AI Runtime 08:55 — Driving the agent loop with context 09:19 — Introducing Genie Code for ML 13:29 — The looming AI maintenance burden 14:26 — Introducing Genie ZeroOps for ML 15:49 — Justin introduces Amber Roberts, Staff Tech Marketing Engineer, Databricks 16:08 — Amber demos Genie ZeroOps for ML 21:47 — Mike wraps up
Presenters: Mike Del Balso, Director, Product Management, Databricks Amber Roberts, Staff Tech Marketing Engineer, Databricks
[Source](https://www.youtube.com/watch?v=C1rEj2VQtwU)