Read the full episode transcript
Generated from the exported YouTube subtitle track. Timestamps appear roughly once per minute and link back to that point on YouTube.
We are listening to the Data Hustle podcast, where data is turned into business impact. Today, I'm joined by the tall, dark, and handsome Italian gentleman Ciro, he's CEO at Bauplan Adjunct Professor of AI Engineering at the Industrial Engineering and Operations Research Department at Columbia University in New York. Before Bauplan, he built Tooso, an AI search and product discovery company for e-commerce that was acquired by Coveo in 2019. After the Coveo acquisition, he built the AI platform and pushed it to an IPO on the Canadian stock exchange, valuing the company at 1.6 billion Canadian dollars and raising around 250 million Canadian dollars.
Notice here that Ciro has been doing all of this way before LLMs and agents became all the raise that they are today, far before ChatGPT was even released. Consequently, today, with Bauplan, he and his dream team are taking on the core problem of the agentic era. Agents are becoming useful enough to help with data work, but most data platforms and data teams are not equipped with the tools to let them anywhere near production. So Ciro, thank you for joining us today. I guess the first question that I want to ask is, when we first met and spoke at the day-to-day Texas earlier this year, I think the entrepreneurial journey you went through was very fascinating and interesting.
It's definitely one of the more interesting stories that I've heard so far in the community. Can you tell us a little bit about how you and your co-founder started in Italy and then went over to the pond and built a company in the US, sold it, and then were ambitious enough to create another one?
Thank you very much for having me, guys. I'm really happy to be here. Yeah, I mean, our story has been a bit wild. That is true. So basically, my co-founder and I, so this is like, I don't know, 2017. So I'm working on computational linguistics because that's how people in academia call natural language processing pre-LLM. None of this matters. Now, all of this is just a prompt now. But at the time, it was still hard to do those things. And so I'm working in academia and I'm kind of very annoyed by the fact that there's a job market that ones tap into a lot of the knowledge that my colleagues and my students do have. And they seem to just not notice this at all.
So I kind of like after a while, we're just like, well, I think like the industry is more interesting. I was getting like very frustrated with the kind of like academic approach things. So Yaka boys in New York and he's working for a fairly bizarre startup at the time, like we never quite figured out what they were doing. But they got like a bunch of people with like fancy PhDs in physics and so on. They're all friends. They're all fantastic people. The company was very strange. But they so we started kind of like working on a bunch of concepts just like really kind of like pizza and beer. That's that's what it was. And then after a while, we got like some some ideas that were kind of like practical.
And what we're doing is essentially kind of like natural language processing on search engines. So we're kind of like trying to do on the fly, some entity recognition semantics and so on. And and then we're just like, well, maybe somebody can buy this, you know. And so that's when we brought Mattia was an old friend of mine as because he was doing like another thing in Germany. So we're just like all spread out. I was in Belgium. He was in New York or in Germany. And and we kind of like build this initial concept of using this API for like large retailers to enhance their retrieval of recommendation search capabilities. And then one guy from California basically tells us like, yeah, this is a cool idea.
I give you 50K if you move here and we build a company here and we're just like, all right, we just pack our stuff and come. And then pretty much like two hours into that, we realized that 50K would have brought us pretty much like a month. And so that we needed like way more money than we anticipated for like orders of magnitude. But now we're in California, so I know nobody. And I was a linguist three hours ago. So so we kind of like had to figure it out. So that initial company, the initial stretch of the company was absolutely insane. And Mattia actually slept in the garage and we did that from a house in San Francisco. And then we managed to get like customers.
So at a certain point, like this thing against a lot starts working. So now we get the customers and we get we get to raise around fundraising was absolutely insane. I had to talk to something like 97 people, 96 of which told me to get lost. So it was really wild. But that company worked out and then we kind of like we were able to find the market was smaller than we anticipated. And so at a certain point, we were like, well, I think like we weren't able to grow this business in a very large also, I think like we're kind of like discounting a little bit the fact that we're coming from Europe. So like the concept of what is big is very different in California.
Then, you know, in Europe. And so we decided to get to bring the company to a position and get like a very fantastic offer from the folks at Coveo we liked very much at the time. And they were like very ambitious and wanted to go IPO. And then, you know, like we worked with them for a few years and it was like a great ride. And then we started in the same team. And then after when LLMs came along, it was very clear that what we were kind of like special at doing was no longer needed to a certain extent, but also was opening up this gigantic hub of developers, which like all the developers can use AI now because like somebody else is training the model, somebody else is doing the hard part.
And we started about one because we knew that it was just a matter of time that also the cloud infrastructure supporting those use cases and especially data infrastructure is so important needed to change quite drastically to accommodate this gigantic shift in the market. And and that's where we are now.
That's been quite a shift. I used to think like the most important thing about writing code and building your infrastructure is that humans are able to maintain it. But when they say that in the last couple of years, I'm like, Oh, and also AI is able to understand it.
Yeah, I think like, look, like Bauplan was built the very initial concept was if developers can do AI, developers will also require to do data and a full stock developer then becomes a data team and an AI team, right? This bed was like the initial premise and data infrastructure is not necessarily the super supremely developer friendly thing is just a very strange sub sub genre of DevOps and people have like very special expertise and the tools are different and some of the practices in software kind of like never made it into data. So that was like the initial idea. And it turns out that if you build very, like very methodically for developers, what is good for developers actually good for an AI agent.
Because an AI agent is essentially kind of like a synthetic developer, it was very exciting. A lot of the ergonomics that they use are the same as developer like Git, the IDE, the terminal, the testing process. And so a year ago, it became kind of clear to us that are we were no longer building for humans. I mean, I don't want to sound like weirdly dystopian, like, it's just like, we're still building for humans, but like, but the thing that calls my API is no longer directly the developer is the developer is this intimidated through an agent. And it's fascinating because like when you get to data, it's not it's not like, like, it should be like software, but ultimately, it really isn't to a certain extent, because like, it's closer to DevOps, your problem is never generating a lot of code.
Your problem is that you're managing a stateful system that changes over time and breaks and, you know, so the problems are different. And I think where we are in the industry is that we definitely got the code generation in DevOps, we're just like starting, we're just getting started to have like agentic DevOps and I think data in general falls more into the second category.
That makes sense. Before we even go, because I think we have a lot of questions, I have one that I'm very curious about. I remember I saw an interview with Steve Jobs, like, long, long time ago, where he was explaining to people what Siri was, and nobody would get it. Like, what do you mean this is a search engine like Google? It's like, no, no, it's different. Before this whole, like, element craziness that now everybody understands what AI is, what was your pitch back then to explain to people like to educate them like this is what we do? Like, how would you explain AI back when you first started with your business?
I was in search engines, by the way. So that was like most of what we were doing. So. I think that they so at the time it was very unclear, I think, to people what the potential was and a lot of a lot of like, like more conversational or just like more intelligent linguistic interfaces where kind of like hard to pitch because like. All chatbots, inverently sucked so much. So like everybody was just like, oh, and not another chatbot, which is like fair. Chatbots are just like the worst. But hear me out. That's what we were kind of like trying to do. And what we're trying to do, in fact, was not to change too much like the interface. It was still like a search engine because I think it at the time, all the people who jumped too quickly into conversational, like, you know, you chat with with with something or running into a bunch of problems that an LLM solves, but at the time was we're kind of unsolvable.
And so the problem that you did, you're looking to solve when you when you do search is actually relevant. Right. Like ultimately, what you're trying to do here is to help a person to find a needle in a haystack. And now, because like everybody was excited at this idea that like, look, it can chat. They were like they were kind of like making this harder for themselves. But adding a bunch of stuff that is not really useful is it was just like there and it was making the experience weird. And so we kind of like we chose to go like let's keep the interface as you know, as a search engine. But instead of bending your mind into the search engine, that was pretty much my pitch.
You're a user. You have you kind of have to think like the search engine because you know, the search engine is not great. Yeah. And I'd much rather do the other way around the search engine kind of like tries to meet you where you are. Not completely not in the conversational thing, but at the very least understanding some of the terms, some of the semantics of what you were doing. And look, my use case was also ecommerce. So the queries were not that long. Like, you know, what is the we had like this customer was a big retailer was selling a lot of issues. You know, what is the the most frequent query on that website? Shoes. Oh, like, it probably is the opposite.
Like people were expressing thoughts with one word and our job was filling the gaps. Like what shoes do you need? Who are you? What are you looking for today? Where are you crawling from? You know what I'm saying? Like it was a lot of the things that were happening in search at the time for us. We're not when people were searching like those. That's where the most important data was harvested is in your browsing session in your history where you do like in the in. Yeah, because when you when you just ask, yes, shoes, there's not a lot I can do now is completely different, of course, like but but it's it's a complete different architecture where you used to be.
I'm hearing a lot of interesting things here that we can draw parallels to to the current day and age. And I think will be interesting to go into before we go into like the specific details of how you guys address this with Bauplan. But you know what I'm hearing in your story is you're actually connecting technology to a proper ROI, a business use case. You have an actual user persona. You understand what they need, how to use it, what they do, which, grantedly, even with the new technology, it's just shifting. Now you just see things like token maxing and, you know, CEO says I want AI in the business. Thank you. I'll have it tomorrow, please.
So where do you see it going wrong today with like data professionals, businesses and teams when it comes to translating, you know, the technological capability to something that the business can actually use? You probably learned a lot of these lessons.
You know, the hard way. Look, like I think data, to be honest with you, I think in data like the problem that you have with AI today is a little like to a certain extent is fundamentally the problem you always had, which is this kind of like shift between I want the final user who can be like a domain expert and is not necessarily a data person, but he's the person who understands the business is the person on the field is the person who's building the product is the person who is the last mile that creates that business value. And like your dream is that this person will be able to just like use the data and get all the value out of it and ideally do that with a certain degree of being autonomous.
Right. But then that creates like all kinds of problems because data like that needs to be kind of like collected and curated and then evolved over time and tested and quality checked. And so you always have this kind of like tension between let it loose and everybody can just like write queries in Looker and just like, no, no, no, close it up. We have a platform team and you open a journey like everybody else. Right. That's kind of like the tension that I always seen in data. And that is mostly due because like, especially in a large organization, the data engineers sense become like detached from the business. And so you often talk to that's what be like my single biggest advice.
If you're in data, just like, please take the time to understand what the data is for. Because like the worst thing that happened in your life is to have a data team that have absolutely no idea why we need the data because they're going to make decisions based on engineering principles that make zero sense to everybody else. And it becomes like a very configural relationship with the business. But what happens with AI now is that the self serving piece, if you look at from the outside, is a self serving piece should be freaking fantastic, right? I mean, the agent is so intelligent, I should just be able to just like ask this thing to do something and it does it.
That's the promise, right? It's kind of like, I don't have to go through Alteryx. I don't have to. I don't need the GUI. I can literally talk to this thing. But the problem of getting your data right remains because like brute forcing creates like wasted tokens. The problem of semantics remains a problem, right? The problem of how efficiently you process the data remains a problem so that last mile becomes more powerful where you still kind of have to figure it out. So I think like what the most exciting piece for us in data now is connecting those two. Because one thing is very different now. That is true. And it's unprecedented. The business user and the engineer, they now use the same interface a lot.
And it's the first time it happens. As the first time it happens, they use it for different things. Okay, they use it for one, use it to generate the order. The other guy ultimately also generates code. It just doesn't see it. Right. And so the question of your infrastructure, which is the question that we answer professionally is what is an infrastructure that is built from first principles for the idea that everyone in the company, engineers and business people can just really hook their clogged instance to the data and get the most value. Keeping in mind that we definitely don't want to leave an agent along with the production data with no guardrail.
Like what is the trend? Like what is the right balance of like self-serving without creating like a bunch of problems? If you figure that out, the guy who just asked for AI now gets one thing that is very important for his organization, which is what can now reason about the data of your company, which is really what makes your company unique. But the rest, like the rest, the intelligence of Clod is the same for everybody. You can get a lot of it out of the harness. You can become more efficient. But the really, really, really unique thing that you have is your data. So if Clod can reason about that data, it can help the business in ways that are pretty phenomenal.
Well, with everyone having Clod, then I would assume there's going to be some engineering or some hubris that say, well, we can do this. We can vibe code the platform like that or something.
Luckily, I would say the actual problem is the opposite. Because they know, like most data engineers tend to be like a conservative species, right? Like they just like, because they sit on something that is very valuable and sensitive. And so like they don't like, they just don't like this pitch. They just don't like the idea that you can just like let an agent lose. What we do there is, so there's a number of things you can do. One is certainly like this ergonomics that we build of Git for data. Like one of the reasons why we can have like coding agents and we're fine with coding agents is that we have very good ways to undo what they do. And we have very good ways to work with them.
Like when you have like several agents hitting the same code base, you have Git, which doesn't mean that Git is perfect. We see that GitHub is down all the time now. Like that space also needs to be kind of like redesigned because AI changes so much of the volumes and the query pattern and so on. The review process can be different. But you do have this model, you know, when you have like several people hitting the same code base and you have a way to kind of like organize that, you can resolve conflicts, you can roll back if things are bad and so on. You don't have that in there. And so when you change the table, this table is read by 50 other systems.
And so if you're a data engineer, you know this problem very well. Like there's a table that changes somewhere and then like 50 dashboards break in Korea or something. Right. It's just like, so that is that, that like the first thing that we did that we are very bullish on in this concept that everything should be like it. So the data is always version. You can create multi table branches. And your ergonomics with which you expose that is very much like it. So like you have a common in your CLI that is branch create and that creates like in 80 milliseconds, an entire zero copy of your data lake. Now you're good to go and you do branch merge and add in a second is going to publish all the tables atomically.
And the reason why it needs to be that simple is because the agent needs to do that for you in the terminal. And so if it looks like software, you don't have to teach the agent anything that it doesn't already know because he picked it up in the training set, which means that you can be very token of.
That's very interesting. I've never thought about it that way. So really what you're saying here is you know, you're building data infrastructure in such a way that AI age that been trained with like more classically, software engineering related tasks with like Git and whatnot around ops.
Your transformation should be something that the agent know like it should be simple or Python. That's it. The infrastructure should be declared in the code. So the agent can generate the code and also handles the infrastructure. And if something goes wrong, your API should return that those those those errors in a way that the agent can put in in the context and reason. But if it is not in the context, it doesn't exist. And so like it needs to be very much like software. That when you do software, that's what you do, right? Like you write a piece of code, you run it locally, it breaks the agent reads the trace back error and goes like, whoopsie, and it does it again.
And you're in a branch. So the worst case scenario is like whatever, like no, no system is impacted by this. There's a deliberate moment when we bring it this to production with a CI/CD process. And that's why the agent can do all these things like very quickly. So if you bring the same model in data, you already know what the agent already knows what to do.
I think even more so if you look at if you look at typical evals and benchmarks of very long running agents, they tend to run into a lot of problems like doom loops. I'm sure you've seen a lot of that research as well. And kind of what it sort of boils down to is they need too many tool calls to understand what they're doing. So like how a classical data engineer without this framework would tackle that is like, oh, you know, maybe I'll create a branch, I'll create a separate table or zero copy clone database, but then still there's a lot of tool calling that needs to happen for it to understand that something is wrong. Then the more you need to do that, the higher the chances it's just going to like derail complete.
That's why we think like the like, like a good way of designing your system in that sense, like you, I mean, like if you want to use our platform, please do if you don't like this kind of like more general design principle for you, but like you're like you want to keep you want to design a system ideally where the states are persisted in a place where you can go back and find them and they're stateless like S3. Like the worst thing you can have is a system where your agent needs to go like through a bunch of tool callings that depend on one another all in a fly like all in midair. That like that creates like a whole bunch of problems that is impossible to debug. But if your system is built in a way where you go like look, we're going to do like simple steps. And ideally, the systems are designed to do that. And you know, like we put a lot of effort in designing our system to be like very agentic friendly. So small API, composable API, token efficient API and
so on. But you do that one piece. And when you're done, write to a street, you know, just like this is just pause in a place where I can go back and see like, well, I mean, working scenario, I can go back to that moment and that table is there. And then you pick it up again. It's like in the the most like the places where you don't write, you need to make sure that when you write, that is transaction. Like you do you do have this example with tables all the time, right? Like a table is transactional, you cannot write half a table. Cool. But indeed, the pipelines, you totally can write a half transactional pipeline. That's actually what happens most of the time to data engineers, right? Like the pipeline breaks at a certain point, half of the tables are updated, half of the people are not. Nobody noticed this two days down the line, somebody goes like, wait, what? It looks like some kind of like number that now makes zero sense. It comes back
to you. It's like, where's the problem? It's like, honestly, I don't know. Because like, it could have broken in so many different places, the data has moved along now. So I honestly don't know, I'm going to rerun it. And maybe it works. Right? So imagine like that, you're mentioned to ask that in front like this, just a rabbit hole. So your system should be, if the pipeline publishes, you see all the tables that the pipeline writes, or you see none is way better to, you know, you have to kind of like relax your concept of what a transaction is. To workflows. Because that's what you ask your agent to do is workflows.
I suppose a different way to put it a term that I've seen kind of hit on the same vernacular before is the right audit publish pattern, right, which typically used to be very complicated to do as an engineer with technologies. It's very painful to implement, but then you gain so much advantages when you're able to do
that. Exactly. Like a branching system is like is designed to kind of like bring your right audit publish. And it's always like, it's always a good sign the fact that like, if you if you talk to 100 people in data about right audit publish, my experience is that 75 of them don't know what that is. It is still kind of like, you know, it's still kind of like a niche thing. So who cares? Like, get like, I don't I necessarily need you to learn that. But if I design a system that is right audit publish, natively, now you gain all the beauty of it, you don't have to like really kind of like get into the weeds. Like, every time you run something, create a branch in your data. Right. And if it goes well, you merge it. And I just don't notice the run of a pipeline that went through.
But if it breaks, oh, I have a I have a branch open, that it stops where that broke and I can debug now. So you always have right on, but like it should be a part of your platform. It shouldn't be something that you as a data engineer have to grow up together. Like your platform should work like that. With agents, I think is more. I mean, this one could argue that this just like good mental hygiene. But like, but with agents, this becomes like a serious problem. Because what we see with our customers now is that when you have a lot of agents like hitting the same data at the same time, you find yourself in a situation where data team historically doesn't find themselves very often. The data team is kind of like slow moving. Right? You run things on a schedule, you prepare the data, if something breaks, you have a few hours to figure it out. Like, you know, it doesn't mean it's not a stressful job.
But it's not a job where you main problem is that like everybody's sitting there all the time. But with agents, this is what happening. So now you have two main problems, two big problems. One is like, how do I get the agents pockets of air to access the data so they can get value, but they don't destroy things? Because otherwise, it's just like opening the doors to just like, you know, hordes of birds of birds of barbarian. And the other one is like, I don't think you claw the loan with a credit card and a snowflake. Because that is that can be tricky. So that's the whole different set of problems you need to figure out. But yes,
I actually want to take it one step backwards. So imagine that I hear this concept of like, oh, building self service using AI and I start by coding it. Right. What I can imagine is that after some iterations of companies trying that approach, they eventually realize a lot of the problems that you're fixing right now with about plan. Can you maybe give us a list of like, what are like the pain points that people need to experience before? Like, yeah, we probably should like talk to the guys from about plan to solve this.
So my customers come into but like in for some of them, about one is just is an enabler of something that they want to do, need to do or asked to do by the management, and they just can't do otherwise. And so there's no before after it's just like, oh, we don't, there's nothing like I can't we I just can't let people use Claude Code on the data. And now I can. Awesome. Right. And some others are like more like, oh, we sort of tried something, it doesn't work very well. So the second category that the typical problems that people will encounter is is mostly kind of like giving mapping the more traditional way, the traditional way in which you would do this year will have a staging environment of your data, right? And then you have your production environment. And the staging environment is kind of like stale, or maybe it's just like the subset of data, you know how that goes, right? And so the first thing that they do is like, maybe they kind of
give access to this environment to a coding agent. But that creates like, like decorates three main problems. One, the data is stale. Two, the data doesn't represent necessarily the data. Three, it's slow, very slow to bring things to production, because now we have to go through like the copying of your own environments. And the agent is like the feedback loop on the agent becomes so slow that you kind of is like less a lot of the value of getting the agent gets lost in the fact your womb for it, to bring something to production takes forever. And it doesn't really solve the problem that people self serve. You're just giving people like this first mile when they can kind of like vibe code something and they feel good about themselves and you go like, so is this a thing now I can use the dashboards like no, absolutely not. It's like, you did this thing is cool. Go brag with your colleagues. But like, yeah, now the grownups will take this thing and do
the data engineering stuff and put it production. Like, that's kind of like the problem we want to solve. So that's where I think like most of the customers that we had, it's like we have customers they are doing now things are like really fascinating. Like, if you are a developer, and you want to just like dump a ticket into Linear, right? And you want the data platform team to pick up the ticket and build a pipeline for you or like create a table for you or do something for you or fix a pipeline is breaking. And like the concept there like in their design is nobody looks at anything anymore. So just like Claude writes the ticket, and he goes into Linear.
When he goes into Linear, another Claude wakes up, creates a Bauplan branch on your data will create a branch in your GitHub. And I was going to just do the whole thing. But it doesn't merge. So then it comes back to the final depth, like data engineer saying like, here's a PR, where you can check both the code that produced the data and the data in the data lake. If you feel comfortable about this thing, you merge it. And so the work of the data engineering team changes pretty radically, instead of like prioritizing the tickets and one by one doing them, they review a lot of work that is done by agents that are spun by somebody else. And the way in which this kind of like get streamlined is through skills. Because like the way in which you're going to help the person who spins the first agent is just by giving skills that help them to just like minimize the prompt engineering there.
It's a fascinating concept, because like now all of a sudden, you kind of like, again, I always go back to the initial problem, you want to have the best of both worlds, you want to have self serving and you and the ability of self serving of a coding agent are unprecedented, like the amount of things that a non technical person can do now is just incredible. But, you know, it's still the production data, you know, like you don't, you know, so you want to you want to have like, then that that review and merge process that goes through human intervention by the data engineers who are the domain experts in order people form best qualified to make that call. But if you're a data engineer, right now, you probably are experiencing this, like people want more, but they're not going to give you a lot of headcount. Yeah, that's so you know, like you're kind of asking you just like, dude, you got to do like, you know, you gotta you got to do 100 more times what
you do with the same resources like, well, how am I supposed to do that? Which like, well, there's AI is like, well, for everybody else, but not for me. I mean, I work for data, like AI for me, it's just like, it's a nice thing, but it doesn't really do the job for me. So that's what we're trying to solve here.
Yes, like the job has shifted so drastically to like, enable AI being the same, it feels more like a product, working in product and the like traditional data work. Yeah, yeah. Absolutely.
But then agents will create like all sorts of like different weird things. So like, I think there's there's a distinction there in who is the persona who operates a piece of infrastructure, like about one, and then you're my user, you're my customer, you have a my value proposition for you is you have so many people in your organization to use Claude, you can enable that. And I guarantee you that your data is always protected and coherent and consistent. Under concurrent agentic access, you can let the agent do things that are potentially destructive, writing into the data lake, building a new pipeline, updating a table, importing some new data. But I'm going to give you an infrastructure that a very fundamental level will protect you from all the problems that this new model will bring. And then it's the kind of like deeper layer for us as builders is how does this infrastructure look like inside of it?
Because agents are different than people. Right? Like they run a bunch of like agents run like a stupid amount of like redundant queries, for instance, should we process all of them? Could be caching in a different way. Like, then there's like a whole set of different questions like how you design a product that in you don't necessarily care for you as the final user is a black box. But inside of that black box, there's a lot of optimization and it's to happen today to change the way in which this work.
What type of optimizations?
Well, there's a bunch of stuff like one is like, take the git for data. Okay. Right now, on Bauplan, there's a data branch, it gets open every four seconds. Okay. So if you do zero copy clone of a table on a snowflake, which is a funny way, which is a fabulous physical primitive, like I'm not like, I'm not being dismissive, it's great. But the average is like a minute and 45 seconds, something like that. So if the agent opens something every four seconds, this is not going to cut it. Right? So speed becomes like a completely different ballgame. Right? Another problem you will have is you write a query that is like select column one and two from January to March.
And I'm another agent and I write a query that is like select column two and three from March to May. They're not the same query, but it kind of rhyme. Right? So there's some data here that I don't need to read twice. Right? So I could do differential caching here. And because like agents do a lot of this, there's a lot of optimization that I can do and just like not reading the same byte twice. When I know that agents will run an order of magnitude more quick more queries, and the queries tend to be more high throughput and more redundant. This is not a problem. Historically, in OLAP, if you run these two queries on Snowflake, you're going to run two queries. That's it. And you're gonna pay for that. And then that's what it is. So this is another interesting concept. Like once I have the differential caching, how do I give you back as the final user this optimization in my pricing model, my business model? Because I think that because I didn't read this byte twice,
you shouldn't pay for it. Right? This becomes cheaper for you.
It's an interesting, it's an interesting framing, because I just immediately think of, you know, certain limitations you'd in traditional OLAP apps like Snowflake and Databricks, for example, if you're running a lot of current queries and transactions, they're going to choke compared to something like an OLTP database, like Postgres. But what you're kind of describing here is like a totally different architecture instead of optimizations. Because you kind of need to deal with a lot of concurrent queries, many of them will have similar shapes between the agents. But then also, they need to be all out and deal with like,
what exactly right, exactly right. There's there's there's a there's a there's a now there's some folks, like, you know, how the inner mechanics of this should change. There's some folks like, now like at Berkeley and Chicago, who are like working more like, in like, they have good ideas about how these things are changed. But like, but if I have to kind of like, wrap it up. You need three things, you need a different way of running things that is more optimal for this type of workload, where you have like high concurrency, we have like high throughput, when you have bursty use cases sometimes. And that needs to translate for you into something that is an order of magnitude more efficient in terms of cost. And for God's sake, not spiky.
Like, the like the paper use is great if it's the three of us. But if I have 50 agents, now my job is to make sure that they're one of them get getting like doesn't get stuck in a weird loop and just cost me 6k to just like, do a report. Right. That's the first that that's a super important thing that if you want to have agents everywhere, you cannot deal with the fact that the paper bites can't, it's just it's just insane. The second is you need isolation. Agents need to touch the data. Otherwise, we're just playing around. It needs to do like, if you do data engineering, the agent needs to do data engineering, which means that they can lock things up. So you need a way to make sure that that doesn't happen.
And the third is, you need an interface that is token efficient and simple slapping an MCP server on top of a platform that has evolved in the past 15 years for humans. I mean, you know, how much money are we wasting on Claude just to figure out how database API work? You know what I'm saying? Like, it's just like, there's a lot of optimization there that needs to happen. And I think is the difference. You see that in all the in other areas, like, you know, tools that are designed to be leaner, I think, like have an advantage in this era. When you are API first and code first, and you just like simple is that is it? You have you have a competitive advantage.
I really like this whole perspective on like building out the infrastructure for agent analytics. I mean, many people they will speak to in the industry will all folks on context layers and semantic layers, and all these assets that you just slap on top of this existing technology to sort of force it into something that may work. But what you're describing is exactly what I've seen in my own work of clients as well. That is exactly the type of problems you're going to run into. And it just grinds to a halt. You get to a point where it's different.
What you can do and kind of like reps of 15. Yeah, that's that's our kind of like main argument because like, you know, like, and look like this happened before, right? Like, it's not like it's not like I cannot run a SQL query on Teradata. You know, like I can but like, when now is 2019 the cloud, it's a thing and like, why would I like now there's this advantage to companies like Snowflake ham, because they build specifically for that, right? I was talking to a guy like not long ago, who told me like, they had this pitch from Snowflake in the early days. And they were just like, that was a weird pitch because like, basically, we asked them to do on prem. And they were just like, yeah, no.
It's like, well, we're gonna pay you like, you know, like, listen, I'm gonna say this only once, like, we will never do on prem. And that's it. And there's nothing you can do about it. So like it, this runs in the cloud. If you're not ready to do that, we're waiting for you. But we know that the world is going there. And boy, they were right. And what I think like what we want to say here is the most of the job that your workforce is doing today is moving towards the agent. So you have two choices. Now, you can get a platform that has an agent as an internal feature, or you can embrace the fact that platforms will no longer be a thing in two years from now.
And you just work in Claude Code. And you just use an infrastructure that is built under the assumption that the platform is going away. And I am here in, you know, servicing my AI overlord. And like my, my, my infrastructure is just there for that for you to be able to work in Claude working your agent working with work where you are like this whole idea that I have to bring you on my platform. So like, I do have a data agent, like, what is that? You know, you're talking about AGI, and we have the data agent, like, what is what is that? Isn't that Claude again? So can I just do this in clock, please? I do everything else. Why is this thing different?
You, you didn't mention something that's been like spinning my head for a bit and just like giving access to an LLM to do like the same type of job like, we know that you have some interesting ideas regarding the data. Like, how do you give access to an LLM to your data? Can you walk us through some of that?
I think like the good for data is the essence like in the model that we designed an agent is essentially a user. Like there's no difference in like, like, there's no difference for us. That doesn't mean that there's no difference for you as the person who manages your organization. But there's a different layer of the stack. So there will be a place where you have to deal with governance and orchestration of your agents and where you figure out like whether Tony has like some certain agents that need to be, you know, deleted or updated and so on. Like, that's, that's your, you know, or agentically or as an as an enterprise. Now these agents, assuming you figured it out, now these agents need access to systems. That's where we sit.
So we're lower there. So from my perspective, your agent is just another user with our back permissions, like everybody else. I certainly don't want the agent to be able to write into the main branch of my data, because that would be tantamount of giving the agent the possibility of changing production with no guard rooms. But I can give this agent access to write in a branch that I can do. So the agent now access true production data, not a synthetic data set, not a sample, not a stale environment is just is the real deal is the data as fresh as it comes out of the oven. But it's in a branch. And so that the agent can write into the branch can do nefarious things in the branch. As a matter of fact, that's fine.
Now we have a process to bring the data into production like we do with software. And that's a review and merge. So you can give Claude access to your data lake. But the data lake needs to be built for that.
Yeah, I think that's a great way to conclude this really fascinating conversation. I feel like we could go on forever here. This is super interesting and fascinating. So, uh, Ciro, what's next for you and Bauplan? Where can people find you?
You can find us at bauplanlabs.com. You can try our platform as a with a with a with a with a sandbox like directly in there. We typically do webinars and every every few weeks like every three weeks or so. And where we discuss like a number of different things like Git for data like, you know, next week we're going to talk about like Git for data specifically, which is like a lot of what we discussed today. We talked a lot about like semantic layer and how to do like the work with agents like generally speaking. The webinar is a good place to learn about how to bring like agents on your in your kind of like daily work as a as a data professional.
And yeah, and I'm fairly easy to reach. So just like drop us a line or just like find me on LinkedIn.
That's amazing. We'll make sure everyone that's listening can find all the links and can find you and thank you again for joining us. We had a wonderful wonderful time here with you.
Awesome guys. Have a good one. Thank you.

