Sponsored by: KPMG | Building a Governed Synthetic Data Lakehouse for AI Agents

Summary

Real enterprise AI agent development is blocked by three data problems: access restrictions due to privacy regulations like GDPR and HIPAA, data imbalance and distributional fragility in real-world datasets, and the need for proprietary domain-specific data that generic internet knowledge cannot replace.
KPMG's YData synthesizers generate realistic tabular, time series, and text data from production data patterns—without requiring raw data movement—enabling teams to build and evaluate production-grade AI agents on a synthetic lakehouse before touching sensitive data.
This video demonstrates generating synthetic financial data for credit scoring on the Databricks Data and AI platform, building document pipelines with synthetic loan applications and support tickets, and running agent RAG demos over the resulting synthetic enterprise documents.

Chapters

FAQs

Why is synthetic data important for AI agent development?

Building AI agents requires access to domain-specific proprietary data—customer transactions, medical records, financial documents—but that data is often locked behind privacy regulations like GDPR and HIPAA. This video argues that synthetic data is not just a privacy workaround but a governance layer that lets teams build, test, and evaluate production-grade agents before touching sensitive production data.

What is distributional fragility in real-world data?

Distributional fragility means that real enterprise data is inherently imbalanced—approximately 90 percent of records represent common cases while rare but important events are severely underrepresented. Synthetic data generation can sample more evenly from rare events and edge cases, producing training and evaluation datasets that make AI agents more robust than agents trained on raw production data alone.

What types of synthetic data can YData generate?

YData synthesizers—now part of KPMG—generate tabular data, time series data, and text data from production data patterns, including JSON extraction and custom ontology injection. This video demonstrates generating synthetic financial customer data for credit scoring and synthetic documents such as loan applications and support tickets for use in agent RAG pipelines.

How is the YData synthetic data solution available on Databricks?

YData by KPMG is available through the Databricks Marketplace, allowing teams to access synthetic data generation capabilities directly within the Databricks Data and AI platform. This video demonstrates the full pipeline from schema-accurate synthesis through Unity Catalog governance to agent evaluation on the resulting synthetic datasets.

Full transcript

[00:10] Hello everyone. As well as anyone in the audience already heard about synthetic data. Yes. Awesome. So you that raised your hand in the front for what? How did you use it?
[00:23] >> Yes. >> You just know about it. Okay. So well having that said, let me introduce you today uh a new way of thinking about synthetic data. So beyond traditional
[00:35] test environments, uh I want to you to think about synthetic data rather as a governance layer that can be used to register organizational knowledge and to keep things privacy compliant. And well
[00:49] um what is my why I'm equipped to talk about this? My background is in applied mathematics. I specialize myself in generative models. Yes, beyond foundational models and LLM, there are
[01:01] others. Uh my passion lies in the intersection of generative models and privacy preserving AI, which is exactly why I'm here to talk about synthetic data today. For the past six years, I
[01:14] was actually a founder. I had my own startup Y data. Uh this company was specialized in synthetic data and was acquired by KPNG last year. And well, you know what? KPNG has excellent taste.
[01:28] And above all, this acquisition tells a lot on how the company is at the forefront of AI. I can tell you there's a handful of companies that nowadays are benefiting for the full power of
[01:40] synthetic data. Some of them are companies you are well aware of like OpenAI, Meta, uh, and Nvidia. So KPMG is one of those bunch and that tells you a
[01:52] lot about how we perceive innovation and how we see the development of AI and well
[02:04] and instead of talking just about how synthetic data can solve privacy, how synthetic data can be used for uh test developments, we I'm here to talk about the perspective in terms of AI AI agent
[02:18] training. and AI agent development. Can we all agree that one of the hardest challenges to build enterprisegrade AI agents is data and that is still actually the main problem. Access,
[02:31] availability, quality and even privacy regulations are blocking the development of many of these technologies. first because you you want to build a true competitive AI, you need
[02:44] proprietary domain specific data. Generic knowledge from the internet is actually not enough. Second, your most valuable data, customer transactions, medical records is actually locked away
[02:57] in privacy regulations like GDPR in HIPPA. That very data that could create the most value for you, it's locked down. And finally, real world data suffers from what we call distributional
[03:10] fragility. It's imbalanced. Actually, 90% of your data might not be normal. My it's probably just everyday events, but those 1% that you really want to
[03:22] capture, usually they they are not there and your AI just fails catastrophically. And for that reason I bring you the synthetic data lake as a solution for
[03:34] these problems. Actually think about this as a source of institutional knowledge for your AI development. In AI we tend to talk about this like
[03:46] epistemic uncertainty which means the gap between what the model knows and what it actually needs to know. That gap exists and is very real and it's usually
[03:58] what leads to AI agents to fail in production. A synthetic data lake is actually the most efficient way to close this gap. So how does this work? Uh the
[04:12] synthetic data links will actually help you to have an open domain sampling allowing us to create data that covers all plausible scenarios not just
[04:24] the ones you have historically collected. It allows as well the coverage for rare events uh at scale. So if you want a critical event that you don't have, you never collected, you can
[04:36] actually generate millions of those. And most importantly, it allows you for targeted epistemic injection. We can measure where your model is most uncertain and generate data precisely to
[04:49] fill the those knowledge gaps. The results are real and actually the the benefits of the synthetic data lake are easily measurable. So your hypothesis cycle for the development of an AI agent
[05:02] shrinks from months to just hours. You can get 50 times more training examples than the ones you have. And you can see up to 80% reduction in the cost of data
[05:14] acquisition. And well, in this context, data and synthetic data isn't just a replacement of real data. It actually unlocks capabilities that are impossible with
[05:26] the real data alone. For fine-tuning, we can synthesize thousand of question answer pairs. For example, for agent simulation, we are now able to create millions of behavioral interactions. And
[05:38] for rag pipelines, we can generate diverse corpora to test retrieval accuracy. And for edge case robustness, we can actually oversample rare events
[05:50] that are under represented in production. Essentially, agents built on synthetic data train or more diverse data, generalize better to new scenarios and ship with full regulatory
[06:03] compliance. And at the heart of today's sessions, we actually have white data by KPMG, the our epistemic engine. It's a comprehensive suite of models designed
[06:15] to handle any type of data that you probably have in your organization. Way data includes synthesizers for tableabler time series and complex relational data as well as LLM based
[06:27] synthesizers for text generation of question answer pairs and even the production of structurally accurate synthetic documents like PDFs or word files but you're probably still wondering how
[06:41] can I trust the synthetic data wata does provide some built-in validations and assurance reports so you can be sure that your data does represent what you need. So in this realm we include three
[06:54] key pillars. Privacy that measures the reidentification risk to ensure that no synthetic record can be traced back to real individuals. Fidelity that quantifies how accurately the synthetic
[07:06] data represents and replicates the statistical properties of our original data. And last but not the least, utility that validates its realw world usefulness which benchmarks like the
[07:18] train synthetic test onreal that ensures that models train on synthetic data do perform similarly when they are presented to real world scenarios. And well this brings us to the
[07:30] centerpiece of today's talk the govern synthetic data lake that you can leverage to train AI engines. To make this a reality, you need a foundation that inherently understands governance,
[07:42] scale, and security. And that's exactly what datab bricks is. And in this case is actually the ideal platform to build the solution. Datab bricks provides the ultimate govern ecosystem. You can
[07:56] leverage the Unity catalog and the Delta Lake as it allow us to tra treat treat the synthetic data not just as a separate experiment but actually as a fully managed enterprise asset that ride
[08:09] alongside your production data. So you just use the catalog to classify whether it's synthetic, whether it's real and they both can follow the same exact flows. So, but how does this
[08:22] architecture will actually work as a foundation for you to build your AI agents? By bringing the Y data synthesis directly into the data bricks environment, we eliminate first the risk
[08:36] of data movement. So, even if you connect the the the synthetic data generator to a data source that exists on data bricks, you won't need to exit data bricks. Everything is there, even the synthetic data generation component.
[08:49] Um afterwards and because everything happens on data bricks every single piece of synthetic data is automatically governed by your unity catalog. You get the complete data lineage meaning that
[09:03] you can trace exactly what source of data and which model generated the specific data set and you can use as well MLflow for example to seamlessly version and track those models including
[09:15] the synthetic data generators. But the real power of this architecture is actually its end to end life cycle. You secure the govern synthetic data flows directly into your downstream pipelines.
[09:29] And the final AI agent application itself is built, trained, and deployed right here on our datab bricks instance. And because we know we want to see the
[09:42] good stuff, I'm going to jump into the demo. Just to to let you know, what I'll be showing in this demo is a workflow that replicates and augment credit databases, generates triage tickets, and
[09:56] produces synthetic loan applications documents. We'll then focus specifically on how we have leveraged data bricks to build our loan analyzer agent app which
[10:08] will be used for the users to interact with the generated documents. This is a full flow since the data collection all the way to the application. Let me jump into
[10:21] the demo and
[10:57] did this, but it's not mirroring there. H it's it's done after all I do or I need yes I need
[11:14] okay perfect now you can see finally we are on data bricks just to guide you through the the presentation I have just here a simple workflow what you'll be seeing in the demo so the first step is actually the generation of the synthetic
[11:27] data. We'll be leveraging synthetic replication which is just uh the process of training a generative model on top of existing data and replicating it statistical properties in a new data
[11:39] set. We'll also combine it with the LLM synthesizer which is what we call a textto data set solution for our triage uh tickets. And last but not the least, we'll be building uh some loan documents
[11:53] out of the structured data that we have built in the first step. Afterwards, we are following a medallion architecture for the data. So we do have the row or the raw or the bronze which will be our
[12:08] delta lending zone. This will be responsible for having the customer, the credit profiles as well as the generated support tickets. We'll have as well a silver layer where we'll just filter and
[12:20] apply some business rules in order for our data to be compliant. The silver zone is actually the one that will res receive the generated synthetic documents. And last but not the least, the gold the normalized layer will help
[12:34] us to uh establish the the the right foundation for our AI agent development. This is the only layer our AI agent will have access and this
[12:47] actually follows the best practices of what you should be uh aiming for when building an agent specifically on data bricks. Having that said and serving everything on this tab we have our unity
[13:00] catalog that is responsible uh for the governed uh management of our data and our workflow. So every data that we will generate will be actually registered on
[13:14] our unity catalog. So let's start with the synthetic data generation and for this purpose I'm putting myself in the shoes of a
[13:26] potential customer. I have uh credit scores from a lot of customers and I have stripped out my data from any potential
[13:38] PII you you say names, emails, whatever. I have already stripped out all that and that's the only data I have stored. But and even though I have stripped
[13:50] everything out, my data is still considered uh sensitive and small because I only have 690 records of real credit applications for
[14:03] that reason and because I do want some variability and I also want to do several tests. I want to keep the statistics and the relationships on my data set, but I want to generate a new
[14:15] data set that is not only privacy preserving, but also bigger when compared to the original one. That's exactly what you are seeing for the demo. Of course, I'm not using a real data set. I'm using an open data set
[14:28] that I've extracted from OpenML. You can have access to this data set easily. The data set includes properties like age, uh, debit, years employed, credit score, zip, uh, marital status as well as
[14:43] other, uh, prop properties. And what I'm doing is just downloading this that data set. You can see here the properties that I've just described. But as I told
[14:55] you, we only have 653 rows, which is not enough for what we want to build. For that reason, I'm going to leverage Y data synthesizers. In this case, the regular synthesizer.
[15:08] It leverage generative models like variational autoenccoders and generative adversarial networks to learn the distributions of the real data and replicate them. So, what you are seeing here live is actually uh live if the
[15:24] machine was up, but while I'm talking you I'll I'll show you the results anyways. But in a nutshell, what I'm doing here is enabling my model to learn the distributions from existing data and
[15:37] afterwards be able to as I request generate new data. That data will have no relationship with the original one, but will share the same uh characteristics in terms of statistics.
[15:51] And that's what I'm going to show you here uh with uh the the comparison. and while the the the compute is spinning.
[16:09] So this is a side by side and what you can see on the left side is actually the original data and on the right side is the synthetic data generated. You can see that now I have 5,000 credit scores from for my experimentation and from
[16:22] those scores you can see the distribution. So for example, of course, bear in mind these are histograms and because the the the volume of data is different, you'll see some differences as well, but you see that the the
[16:35] distributions are similar if you think about the ratio in between this the populations. So let me grab for example here another example with the employment
[16:49] type. So we have about the same type of representation of an employment type credit um details of the customers but instead of just having the 500 uh
[17:02] customers now we have 5,000 which will be way better for our experimentation later. So this whole process was using one method of synthetic data generation.
[17:14] But above all um I need more and when I say I need more is that even though I have this I want more
[17:27] semantic details injected into my data. What I mean by that is that uh sure I have the credit scores of uh certain synthetic records but now I want to add
[17:41] more details like I want a name. I want a phone number. I don't want those to be real but I want them there. It's semantically enrich my data. It makes my experimentation with the AI agent more realistic and the approach way more
[17:54] close to the schemas that I h actually have in production. And what you are seeing is me using another way of generating synthetic data in another methods. In this case, this method
[18:06] adopts what we call the rulebased synthetic data generation. And this one is probably more familiar to all of you. We all have already generated some sort of rule-based synthetic data for testing
[18:18] environments or any other uh activities. What I'm doing here is just complementing semantically my uh my generated data set with the same structure as I have in production.
[18:32] But this is probably good enough for me to get started. I also need some um the generation of some uh uh you know all
[18:44] this data set is actually being sent to the the to the raw uh uh data storage on on our delta lake. So everything is being written and that's the the step that you see here. But for the support
[18:58] tickets, they have a different nature, right? Support tickets are known to have long text. they're a bit more complex than just a structured data set with numbers um and and categories, right?
[19:11] So, I want something else. I want something more rich. For that reason, what I'm here leveraging is actually what we call the text to data set. This is a solution based on a multi- aent
[19:23] architecture that is responsible to receive a schema or a request from an end user of what the data looks like and generates a tabler or a more structured data set out of that request. So in this
[19:36] case for the support tickets I'm just giving a general description of what the support tickets look like or what I want in terms of schema. I'm saying yes I will need a a ticket ID. I want the
[19:48] channel. Uh I want the subcategory. I want the priority of my ticket as well. I want the subject, the body, uh and the status. So all of this is my request for
[20:00] what the data look like. As a user, I don't want the data to look like I'm generating column by column and the columns are unrelated. What I want is every information that I have for each
[20:14] ticket is related and is reached semantically and that's what the text to synthes to synthesis is doing. Uh and this multi- aent system is what allow us to keep everything coherent.
[20:28] Last but not the least writing everything again to our delta lake and have our unity catalog dealing with the governance of this data that I've generated.
[20:40] Now that I have all the synthetic data generated that I need for the raw uh layer, I need to go through what I call the silver pipeline. In this case, I'm going to jump through this one just
[20:54] because the silver pipeline will just be responsible for filtering any data that we don't need or we don't want based on business rules. Those rules are for the customer to inject. And this is just a a
[21:08] layer to ensure that all the data that is uh written into silver does follow and complies with our expectations. Now that I have everything on my silver layer, what do I need? I need to
[21:22] generate my documents. And that's what I'm going to show you very quickly. So for each record on my silver layer that includes the credit pro the customer profile, the credit score uh as well as
[21:36] the loan application details. I want to generate a document. How do I do that? So very quickly and this is another type and another method of synthetic data
[21:49] generation. We are using what we call the document generator. Similar to the LLM synthesizer, this is also a multi- aent system uh that that combines uh
[22:01] different uh skills of agents in order to build our document. The documents can be generated from existing data. And in this case, for example, I have the data
[22:14] of an application extracted as a JSON. And that's the expectation. As long as you have as JSON, you can ask the the our document generation process to generate as many records as you want and
[22:28] you can just say I want a loan application record that's enough for us to generate the data and from there for example here I just provided two examples of application
[22:40] ids. I just need to say listen I want the format to be an HTML but you can get PDF a word document that's up to you you just uh have that configured and last
[22:52] but not the least I just need to send that data to my um to my delta lake for that I just need to define the path uh and having that said I have everything
[23:04] ready to go in order to generate the documents for the demo purposes of course I have crunched everything in a real uh example just to show you how the generation is. But as you can imagine
[23:17] the real pipeline for the document generation is just uh a query to our silver layer to structure the data in a JSON and afterwards send all the results
[23:29] from that query to generate each one of them uh a synthetic document. That's the full pipeline that is here. Having that said, I'm going to show you very quickly some of the data that we
[23:41] have generated and I'm going to show you that through the catalog. So you can see the outcomes of all this process that we have done together. Uh so for example, if I go to
[23:54] the raw layer, uh I I'll have the credit profiles, the the customer, the loan applications as well as the support tickets. Um in this case um for example
[24:07] and seeing the the the data we have here all the tickets that were generated. We have what was the channel the category what is the subcategory already classified and labeled and the subject
[24:20] related with um with the request as well as the body of the the ticket. As you can see, everything is here. Everything was generated. Everything was stored as
[24:33] we requested in the raw layer. When I come to the silver layer, I will have now two types of data. I'll have the tables which will have the credit profiles, the customers, the loan
[24:46] applications all filtered based on our rules as well as the support tickets. But I will also have what we call the volumes. And this is where I have my already generated synthetic documents
[24:58] stored. Let me show you one synthetic document just um for you to be aware on how they look like. This is a mortgage loan application
[25:11] synthetically generated and this is what the agents will have access to in order to you know for example do some loan analysis right. Um,
[25:31] let me get back here and also note that everything in our catalog is labeled. We have the fact tag the data set as saying that it does not include PII. So everything synthetic and above all we
[25:44] have as well a label saying it's synthetic. This is very important especially we don't want the synthetic data to be confused with what we call deep fix right so everything is governed
[25:56] everything is labeled correctly and all the users have the right expectations about this data now that we have everything the documents the data generator our gold
[26:08] layer done it's time for us to build our agent app and for the purpose of the demo we have built an agent app using data bricks custom apps. Uh we have used
[26:20] the open AI SDK to build the agent itself. I'm going to show you very quickly. Bear in mind the agent is simple. Actually this agent is combining two tasks. It should be two agents
[26:33] separately but just for the purpose of the demo. In this case I've done just one to simplify the process. But let me show you um the code for that
[26:45] very it's not here work. Okay. All right. Just very quickly
[26:57] agent. So uh the the files that you see here they are templates. You can extract them from the documentation from data bricks. The only thing you will see that is different from what you have on data
[27:10] bricks GitHub is that the front end is different. In this case, the front end was custom for the application that our customer our hypothetical customer wanted which is the analysis of the loan
[27:23] applications. But the what you are seeing the agent.py file it's built on top of a template that is is existing you can easily access through data bricks documentation and for example
[27:37] here is where I define the instructions of what our agent should know. Have in mind that some of these instructions were actually extracted through vector search and you can have uh a vector
[27:50] database holding all your business rules in order to be consumed by your agent. It's not the focus of the demo today, but I just wanted you to know uh that that's the way uh this is built and
[28:02] that's how you embed uh the knowledge of your um of your business rules into the agent. Uh now that we have the baseline of what
[28:14] the agent looks like, let's together analyze alone. And this one is actually already analyzed, but I'll I'll show you one live. Um in this case, I have
[28:27] Christopher Morales asking for a mortgage uh in the value of 24,000. Um and I just asked my agent. My agent analyzed the full uh loan request. So he
[28:41] analyzed the full document as well as the data of the customer uh and he flagged some of the business uh rules that he knows we need to comply with. So for example, it just flagged some of the
[28:53] missing data that we have. And bear in mind that the synthetic data is done not only to cover the ideal scenarios where the customer provides everything and we approve that loan, but we also want
[29:05] loans that fail. Fail either because they are missing data, fail because the the customer actually has some problems in terms of this credit score. Um there are many things we want to cover and
[29:17] that's the capability that synthetic data will give you. you can actually control how many of those cases you have and they are all labeled which with real data is really rare to have. Um we have
[29:31] as well some flags here uh like uh APR not clearly disclosed as well as the loan estimate was not provided within the three business days that are
[29:43] required. So I just asked my agent, help me understand what it needs to be done in order to have my customer submitting the loan successfully. So it it did give me um a few uh a few notes uh as well as
[29:58] a full message of what I need to ask to my customer for example. But this is just one example. I I want to show you another one as well. Um for example this
[30:12] one which is a different type of loan. This is a business loan. Um again we made the synthetic data to be as to have enough variety so we can cover
[30:25] different types of scenarios. So we don't have only mortgage we have car loans. We also have business loans and in the we even have more missing fields as well as we have a lot of missing uh
[30:38] compliance flags. So I'm just going to ask my agent, hey, can you write me write me an email for my customer
[30:50] of explaining why I'm denying the loan?
[31:03] So everything that you see here it's being done live and each document that you see here they are actually being generated can actually be generated live as well because the the the files that I've shown you for the process of data
[31:15] they are pipelines they are pipelines that you can say I want a new customer to be generated every hour for each new customer I want a number of loan applications
[31:27] um and for each loan application I want certain documents. All of that can be automated. So every time you are developing your agent, uh training your agent or even testing your agent, you're
[31:39] full, you have full access to the right data that you can use to cover the cases that you want to test out and cover with your agents. So I I'll show you very
[31:51] quickly the the pipeline as well. But for example, as you can see here, we have a full email answer saying, uh, "Dear Melinda Vega, I regret to inform you that we are unable to approve your
[32:04] loan application at this time. Our reviewer of your loan uh has revealed several required fields were missing." So, and it does cover all the first uh the analysis that it has done in the first instance. Um
[32:19] I'm going just to show one more which is a personal loan and after that um I'm just going to wrap up the session and give you space for some questions.
[32:31] So in this case we just had insufficient disclosure of APR and total finance charge. So we had no missing data. This is actually a good loan application. Um
[33:12] so again I'm just using my agent to help me go through the analysis. Have that that in mind. And in this case, I instead of asking for a message or just to let me know why, I just asked, can you give me a plan that I can share with
[33:25] the customer uh so we can have this act this loan approved? And well, the agent comes forward with a suggestion. It it is for the human agent to analyze that suggestion and define the next steps.
[33:39] But you get the gist. All of this was done without even touching real data. All of this was built with synthetic data and is built in a matter of hours instead of long cycles of weeks
[33:51] searching for the right data uh for the right owners of the data as well as getting the right permission. So instead of waiting months or even years to just ship a solution, you can very quickly
[34:03] test your hypothesis, but above all test the coverage of your knowledge and make sure that your agents are actually robust for everything that may happen in the real world scenario.
[34:17] Now that we have seen the full uh the end to end solution probably um there's one last question. So where can I find the synthetic data generation methods?
[34:30] How can I use them? Where can I leverage them? So uh the solutions that we have seen for synthetic data generation are found uh in Y data by KPMG. And I'm very
[34:42] happy to announce that this was uh we were able to have this available on data bricks marketplace for you to go and check uh last week. So it is really
[34:56] ready and available for you during the summit. Uh what you can find here is actually just uh a few examples as well as some notebooks on how can you use that, what are the pros and cons that
[35:09] the synthetic data will provide to you. Um and if you have any questions about the solution, please uh you can always ask me. I'll be um next in a um
[35:21] a data brick session. uh just dedicated to help you to answer questions about synthetic data. Uh but also ping me on the on the app and I'll be happy to to answer any questions that you might have. I see that we still have four
[35:34] minutes so I'll just open the floor for some questions and yeah that's it.

Learn more about the Databricks Data and AI platform.

The information provided herein is for general informational purposes only and may not reflect the most current product capabilities or configurations.