The Agentic Stack: A Founder Conversation on the Open Infrastructure Powering AI Agents

Summary

This video brings together the founders of LangChain, LlamaIndex, Agno, and CrewAI to discuss how agent patterns have evolved from simple chains to multi-agent systems, and what the emerging open agentic stack looks like in production today.
The panel debates when multi-agent coordination genuinely outperforms a single well-built agent, how to own your enterprise agent stack for privacy and security, and what accountability looks like when an open-source agent takes an autonomous action on production data.
Discussion covers the future of the open agent ecosystem—whether the stack consolidates around model providers or remains a thriving set of open frameworks—and how coding agents are changing the way open-source documentation itself is consumed and written.

The Agentic Stack: A Founder Conversation on the Open Infrastructure Powering AI Agents

The next great platform shift isn't a model. It's the infrastructure that turns models into autonomous action. Just as cloud produced a layered stack of open technologies, the agentic era is producing its own, defined right now, in the open. This panel brings together the founders building each layer: how agents are constructed, how they collaborate as teams, how context is processed and made agent-ready, and how they're governed at scale. Together, they'll discuss what the "Linux moment" for agents looks like and what it means when the most consequential software in an enterprise writes itself. The big questions: Where does the open platform stack land in next 2-3 years - a thriving ecosystem or a consolidated stack? What happens when agents become the primary consumers of infrastructure, not humans? When does multi-agent coordination actually outperform a single well-built agent and when is it just complexity for complexity's sake? Who owns accountability when an open-source agent takes an autonomous action on production data? How do agents process context differently than humans? What are the implications on how context must be processed and exposed through tool interfaces?
Talk By: Ashpreet Bedi, CEO, Agno ; Hanlin Tang, CTO - Neural Networks, Databricks ; Harrison Chase, LangChain ; Jerry Liu, Co-founder and CEO, LlamaIndex ; Joao Moura, CEO, CrewAI, Inc ;

Chapters

FAQs

How have agent patterns evolved from LangChain's early days to multi-agent systems?

This video features Harrison Chase explaining that LangChain started by chaining sequential LLM calls, then launched LangGraph to give developers more workflow control as models improved, and has since evolved toward true multi-agent systems where LLMs operate in a loop with tools. The panel agrees that the industry has moved through roughly four major pattern iterations in a short period.

When does multi-agent coordination actually outperform a single well-built agent?

The panel discusses this directly in this video, drawing on production experience from their respective frameworks. The consensus is that multi-agent setups deliver real advantages when tasks can be genuinely parallelized or when they require specialized sub-agents, but add complexity without benefit when coordination overhead exceeds the gains from parallelism.

What is LlamaIndex and how has it evolved beyond RAG?

LlamaIndex started as a retrieval-augmented generation (RAG) framework and has since evolved into a document infrastructure platform purpose-built for AI agents. This video features Jerry Liu explaining that the shift reflects the broader maturation of agent patterns—agents need richer, more structured access to enterprise documents than early RAG pipelines provided.

What are the biggest open-source AI agent frameworks recommended by this panel?

The panelists represent their own frameworks—LangChain, LlamaIndex, Agno, and CrewAI—and each describes the specific niche their project fills in the open agentic stack. This video ends with each founder recommending libraries they personally use, providing practical guidance for teams choosing tools for building production agents.

Full transcript

[00:08] Thanks everybody for being here. Uh my name is Hanlin. I'm CTO of our AI group here at Data Bricks. And uh very excited to have a distinguished panel of um AI founders and and CEOs uh to have a discussion about where we see this
[00:21] Agentic stack that we've been working on over the last couple of years sort of developing, you know, today and also into into the future. Um, and I said, we're absolutely blessed to have a powerhouse collection of the folks who
[00:34] have actually built a lot of the core components in the open-source uh for this new agentic stack that's emerging. So, maybe we'll go through and just do a quick round of introductions. Many of them don't actually need them, but we'll
[00:46] do a quick round of introductions. Uh, maybe starting with uh you, Jerry. >> Great. Um, thanks for hosting Holland. Uh, I'm Jerry, co-founder CEO of Llama Index. Uh, you might have known us as a rag framework three years ago. Uh today we're building the best-in-class
[00:58] document infrastructure for AI agents. >> Thank you Anan for having having us here. I'm Ash Pri. I'm the founder of CEO of a company called Agno and we help businesses build and run agent platforms.
[01:10] >> Um well very excited to be here. Hey there everyone. Um my name is kind of hard to pronounce. I go by Joe to make everyone lives easier. Founder and CEO of Cai and very excited to be chatting. >> And my name is Harrison, co-founder CEO
[01:23] of Langchain. We build a bunch of agent frameworks and agent infrastructure. >> Awesome. Yeah, maybe a round of applause for both show and up
[01:37] off with one question which is agent patterns have changed a lot over the last few years. It started with just prompting an LLM to a rag. It's now to multi- aent systems agent tools in a
[01:49] loop. curious for each one of your projects how you've adapted to that kind of change in sort of agent agent patterns. Maybe Harrison, you want to take a crack? >> Yeah, I I I can start. I think we've gone through maybe like four different
[02:03] iterations of like these agent patterns. So, we started off with Lang Chain uh pretty early on and at that point the LLM models weren't weren't amazing and so a lot of what people were building were more chains, hence the name Lang Chain and so they were chaining one call
[02:16] to another to another. Um about a year after that we launched Lang Graph. Uh the models were a little bit better but they still needed these kind of like workflowy things. And so part of the reason for us launching langraph was people wanted more control over what
[02:28] exactly what went on and wanted to build these more complex things that had loops but but but were still workflows at the end of the day. Um and then about a year ago uh we started working on lang chain 1.0 and deep agents. And these are both
[02:42] more centered around the idea of a of a pure agent which is uh I think I like the definition of just an LLM running in a loop calling tools. And so lang chain is just that very minimalistic. And then deep agents is uh what we call an agent
[02:56] harness these days. Um and my interpretation of that is there's just more things built in. So it's got access to a file system, access to skills, access to sub aents. Looks kind of similar to coding agents but more general purpose. And so I think these
[03:10] reflect what we've seen the the agents look like over time going from places where you need more control to now things where you're really handing it off to the LLM as much as possible. >> Yeah. for us was interesting because we almost went the opposite route like we
[03:24] start with a way more higher level multi- agents like you throw more at the LLM out of the gate and kind of like shooting a little bit where the puck was going back on 2023 and we launched it and yeah the LMS back then like they
[03:37] they kind of suck a little bit.
[03:49] we we got a lot of pardon my French we got a lot of back in the day because of that people would say well but if one agent hallucinates three agents are going to hallucinate like 95% of the time and it's funny because I think the market made its way to like oh
[04:02] yeah no multi- aents is actually the way to go um and then eventually we end up launching kind of like the internals of what we use for these agents. Uh, and that's what we call CI flows for people that want to have kind of like more
[04:15] control and go in there and change things. So, it's funny because we went the the opposite route like when Langchain was launching, we're actually launching the Mucci agents thing and eventually kind of like we met in the middle. >> Brilliant. I think they covered a lot
[04:28] but for us the clues in the name. So, our name is Agno. So, we believe that every business has different use cases. You can solve problems with a single agent, a few tools. Sometimes you need
[04:41] more multi-agent capabilities. If there's an agent that's interacting with a lot of sources, you want sub aents dealing with those problems. So in those cases, you want multi- aent and sometimes you need stepbased workflows. So for Agno, what we believe is every
[04:55] business needs all kinds of uh products. They need full flexibility. So we basically just keep up with the environment and uh whatever build whatever people need. Yeah, I I can kind of speak to this a little bit at the
[05:08] context layer because we kind of started off building a lot of the core primitives for like rag and stuff. You know, you have uh some chunks, you put it into a vector database um and then you do some topk retrieval, fetch it, put into the LM context window. Um
[05:20] everyone was kind of building these naive chatbots back in 2023. Um I think from the context layer, what we've seen is both the agent harnesses have gotten a lot better um as a function of the models and the agent harnesses themselves. Um and then also some of the
[05:32] tool interfaces have standardized, right? you have like MCPs and skills um that enable you to kind of like have a more standardized way of accessing various types of data, structured databases, uh unstructured document based data like what we do, web data and
[05:45] others. Um and then I think basically a lot of like kind of the initial and stuff that we worked on too honestly like we worked on a bunch of these like tricks to kind of like hack rag because it just wasn't very good. Um but now as agents got a lot better um you could
[05:57] start offloading a lot of the complexity to the agent layer, right? agents can now like get really good at just running your file system commands in a loop like GP, ls, cat, combine it with a bunch of other operations and basically start to
[06:10] approach this idea of like generalized computer use which means they can basically just start using relatively simple tools. You can still keep semantic search, you can still keep like BM25 or GP. You can still keep kind of just like generalized like read access
[06:23] uh to various snippets within a file. Um but you can offload a lot of the reasoning to the agent. Um, and so that's awesome because it means uh actually kind of being able to focus a little bit more on the core of just making that context available is a lot
[06:36] more easy than trying to like hack like like rag. >> Yeah. I mean, I still remember maybe last year or the year before the companies I would talk to, they'd say, "Hanland, we have 50 rag pilots in our
[06:48] company." Oh, no, we have a hundred. We have 200. And over the years, I think people have realized that there are kind of more interesting agentic patterns or use cases of this technology. To that point, maybe Harrison, you've had a lot
[07:00] of experience working with folks on building agents and things like that, you know, in the enterprise. What do you think is needed, you know, from a architectural or infrastructure layer for these agents to really operate very
[07:12] reliably? Um, I mean, I I I think the the core issue in my mind at the end of the day is that the agents don't necessarily behave as you as you want them to behave, and that's because they're driven by LLM. And so, I think a lot of
[07:24] what um we and probably everyone up here on the stage has thought about when building frameworks is like, okay, great. Like, is this is this, you know, a lot of what Jerry was mentioning around the hacks to make rag work? Like, how do you make things work reliably? Um
[07:38] I think uh but maybe I'll call out some maybe like less obvious things like around making agents work reliably. One I think like UX is really important. I think like in certain cases like reliab you need reliability to be 100% but if
[07:51] you switch the framing a little bit it's actually okay if it's 90% and suddenly that makes it way more successful for agents. So I think coding is an interesting example where you can run these coding agents for a really long time and they can put up PRs and do a
[08:03] lot of work but most people review the PRs hopefully. um and and review them. And so it's a first draft. And so it's a little bit different than if you just tell it to push directly to prod. And so I think like there's some UX tricks that can make agents uh more amenable in
[08:16] certain situations. But but a lot of what we think about is just how to how to really get the the >> performance of the agent mostly from the perspective of like accuracy or whatever that means for your domain up. Um that's why we invest a lot in like
[08:28] observability and eval. We think those are core parts of that. >> Yeah. >> Yeah. Makes sense. I mean and speaking of kind of pushing code to prod you know Ash Preit you know you've talked about in the past how a company should own kind of their agent stack so what does
[08:42] it mean for a company to build you know its own agent platform focusing on kind of privacy and security. Yeah, I think we especially after the events of last week, I think all companies feel the need now that we should be owning our
[08:54] agent stack and we should be building our own agent platforms and with the help of the ecosystem. It's actually much simpler now than it was previously. All you need is a good SDK. You can choose from many on this stage. You need
[09:07] a good lightweight runtime that runs your agents and your workflows securely self-hosted in your cloud. And then finally you just need a private database which you can monitor and observe and have persistence for uh your
[09:20] application. So looking at your own agent platform from the lens of privacy and security privacy is a lot simpler and I think um almost everyone gets that
[09:33] natively that let's run everything in our cloud. Let's keep control of our data. Let's make sure that user data doesn't leak to other users. And from that perspective, privacy we can get strong guarantees. I think security is
[09:46] where things get harder. And your question on agentic patterns comes back into the mix. For security, you want to make sure that whoever is running the agent, whether it's the user or for
[09:59] coding agents, the developer is the user, they have the appropriate permissions and the agent is built on demand to handle the request from that user. For example, if a user does not
[10:11] have access to delete a database, then the agent shouldn't have access to delete a database. So from that perspective, if you own your agent platform, run it in your cloud securely and have the right security controls
[10:23] around it, you uh it's a lot easier to build the agent platform today. >> Yeah, makes a lot of sense. Um and uh especially when it comes to kind of control and security of agents. You
[10:35] know, Joe, you've you know, career is built on kind of multi- aent and multi-agent orchestration. Curious maybe your thoughts on this on this lens of a you know, what is the secret sauce for actually making multi- agent
[10:48] orchestration work? And second, from a security standpoint, where does this, you know, sit if you have agents spawning other agents and crews of agents working on working on problems? Yeah,
[11:00] interesting because I think we all converge a little bit in kind of like uh on how we think about this and that is that one not everything necessarily needs to be an agent, right? I think a lot of people want to just like slap agent on it. It's like all right, this is an agent. The the reality is there's
[11:13] a lot of like a lot of like um workflows out there that Sue should be and could be deterministic and they benefit from that, right? It's fun because when you when you see kind of like most of these companies flying off the agent implementation and like, oh, I wish it
[11:26] returned this. I wish it returned that. I wish it was this way. I almost like like you got to stop and ask well what is this an agent? Is this benefiting from the fact that you're actually having inference and tapping into this intelligence as as an LLM, right? So
[11:40] what we see a lot out there that actually ship these use cases into production is usually a combination, right? Is not have like necessarily a if this then that implementation nor like a pure like agents that are getting to
[11:53] each other. is usually some sort of like deterministic backbone. So there is an element of even like events based or graph based some sort of like backbone that controls the flow and then you can
[12:06] opt in at each step how much uh agency you want from a single LLM call to maybe a single agent to potentially entire crew of agents that are going to be doing some sort of like agentic behavior
[12:19] for you. But then that step benefits from like agents bring to the table either decision making or being very good at handling structured data whatever you're trying to accomplish with that uh agents step that you have
[12:32] in there. And you know speaking of running agents in production, one of the common themes in this conference so far is sort of context right sort of like how do you get that right context into
[12:44] into these agents and you know Jerry you've been working on this problem now you know both actually through rag and chunking all the way now to kind of PDFs. Um curious how you think of what are the most challenging parts of this
[12:57] called this context layer. >> Yeah. Um, I appreciate you bringing that up because you're basically speaking uh kind of our language. Um, I really do think context is uh everything. Um, especially in this world where you know agents are getting kind of better and
[13:09] better at reasoning and just like generalized capabilities where the abstractions are also moving up the stack too where you can start like prompting your coding agent in English or cloud co-work in English to start doing things. Um, I think for us basically these models are blank slates.
[13:23] Um, and by itself, uh, like it's kind of on you to basically give it the right context, prompts, and task to to actually have it do things, right? To actually meaningfully contribute to your productivity. This includes the task that you give it, you know, being able
[13:36] to actually come up with the complete spec of what's going on. Um, this also includes, you know, especially if you're in an enterprise organization, uh, the just massive quantity of like unstructured data or structured data that lives within various silos that you
[13:48] basically need to bring together in some sort of, uh, structure. Um, so they actually give agents efficient context and understanding of not just like kind of what is ground truth but what are like cultural norms kind of like
[14:00] business context SOPs and a bunch of other things. So I think for us you know we care a lot about this from the lens of like unstructured document based data. Um because the issue is you know if your agent hallucinates or or sorry if the agent doesn't have access to the
[14:13] right context whether it's because it's like parsed incorrectly because it's locked up within like a really complicated PDF or because it can't find it due to you know access controls or because you know it just doesn't have the right tools into like a structured
[14:26] database um you know it's going to hallucinate. So, so I think uh being able to actually create the context layer for every agent, you know, I think Ashra, you mentioned like owning the agent stack. Um we we really do think also like every organization should own
[14:39] like the context layer too and deeply figure out how to structure that. I >> I think like the mental model that I think that across all of our answers and this is the way that I think about it and I might narrate on this for a hot second but it's just like in the end of
[14:51] the day like the the LLMs are like basically intelligence for hire, right? You're you're paying for tokens. So your job as harness framework agent extract whatever it is is how I tap in the most
[15:04] valuable token that I can right and the the math here is like all right I need to pay less for that token that whatever value that token is going to generate for me that's very at the end of the day right so all the harnessers all the
[15:16] logic all the agents and and the context that you're injecting is to make sure that you access the space of that model that has the tokens that are most kind of like significant for whatever you're trying to do either a workflow that
[15:28] you're trying to automate an answer that you're trying to get. So in the end of the day, I think that context is a big piece of that and how you do it. But that is kind of like my mental model and for people out there that are thinking about building it is that how I would
[15:40] think about it is yes, I'm going to have the context. Yes, I'm going to have some sort of evaluation. I'm going to have some sort of steering, some sort of hacking still around it. But the idea is to get the most precious token out for
[15:52] whatever I'm trying to accomplish. Yeah, I I like the concept of these, you know, these LLMs are intelligence for hire. It makes me feel better that I'm not being replaced. I'm, you know, I'm hiring these these intelligence. I'm sorry, Ashp, I think you were going to chime in
[16:04] as well. >> Yeah, I think uh context is also an area where multi- aents actually shines. It's one of the only areas where I found multi-agent to shine because you want to build a single agent that's an interface
[16:16] to a lot of your applications. In those cases, let's say your agent has access to Slack, Docs, PDFs, lots of context through your databases. That's when the main agent kicks off a smaller, faster,
[16:30] sharper sub agent focused on that problem. That's also where multi-agent really shines. Getting the main model the right exact context it needs to solve that problem. >> Yeah. And maybe I want to shift the
[16:43] conversation a little bit to the open source. You are all blessed with amazing GitHub repositories with lots of contributors. You're also cursed potentially uh with a lot of AI
[16:55] generated pull requests and battling issues and that swarm of open source that begets any kind of really popular open source project. Maybe this is not for all of for anyone anyone's interested in commenting what what have
[17:08] you employed you know to kind of handle that that that kind of influx? >> We dog food our own products. So we have internal agents continuously running
[17:20] analyzing things. So if you go to our GitHub, you can probably find this repo for an agent called Kod. >> Kod is a multi- aent system for us that monitors our open source. Every day
[17:32] it'll tell us you have 20 new GitHub issues, 15 new PRs, 10 of them are slop, you can close them. So if we can use this our own technology to help us
[17:45] maintain that and improve that technology, I think that's what we found uh helps quite a bit. >> We've done some of that. We've also employed or or contract or we we buy some solutions for basically security
[17:57] review of code. I think security is becoming more and more important. And so we uh we use corridor which is a great startup uh that's does uh scanning of of pull requests. Um we have we have some internal kind of like agents for
[18:09] triaging issues. We've also just employed kind of like we we've just kind of like um uh added more just like rulebased stuff like uh I think I think we have something in one repo where you you can't open a PR unless there's an
[18:21] issue associated with it. So you at least have to describe that. Um I think we we've standardized how a lot a lot of how where we get the open source contributions is in the integrations. like we have thousands of integrations and so we've tried to just like standardize that and come up with like
[18:34] better documentation on on how to add it and how to contribute it and so there's also just some good oldfashioned kind of like you know process. >> Yeah. >> Yeah. And oh sorry you were going to say >> uh go ahead I was going to just say that software engineering helps a long way
[18:48] like if your open source repo has a small number of dependencies is clean written code I think that sets a good foundation for security as well. I did actually want to touch on agent coding a little bit because besides you know
[19:00] working GitHub, you all also run companies with software engineers and many of also you know uh do AI coding and token maxing obviously is like the
[19:12] uh worry that begets every you know CFO of every company you know as folks also with kind of limited venture capital. any tips or tricks for this group on uh taming that that token maxing within
[19:25] your own teams? >> Well, um we have been using a mix of like everything that is using out everyone is using out there, right? So, yes, there's like cloud code, codeax, you name it. >> Uh we also tried a few things with kind
[19:37] like open claw and similars and we have some of that that are running across the company. Eventually, we end up setting up our own thing like just dog fooding. We're like, "All right, let's build like a Crayi agent that has a crew behind it
[19:50] that does a lot of that." And that seems to work. I think for us, what has proven to be super beneficial is really investing on the infrastructure, right? Because whatever will be the the UX that you're going to have that cloud code,
[20:02] codeex, openclaw, whatever or something custom like our case, you will you will benefit from having that idea of sandbox isolation of like being able to set up those environments and test them out of
[20:14] being able to have keyway and tests. So I think a lot of like the OG principles of engineering is still apply and you probably want to make sure that you're checking all those boxes that will make whatever you adopt like way way way
[20:27] easier down the line and allows you to also try new things in the end of the day. Um a couple things that we didn't expect that actually were pretty good was whenever we did like this idea of like people being able to code by
[20:39] chatting and make that available for the company. um we made sure that you can only do that publicly and that was a major thing for us because people could see each other using on Slack channels
[20:52] and that start to be very infectious. >> So we start to see more people using them and the other thing is we implemented a memory layer that even if you're not chatting with it to do something it is actually just big
[21:05] brother watching the Slack channels. So it's learning from everything that is happening through all the company. So when you go and ask like oh can you do X Y and Z this agent now knows everything about what's happening about the company
[21:17] what are people having issues with are things are working the road map and kind of like makes easier to implementing so that is a couple of things that we early on didn't realize but actually had a major impact >> yeah that's really cool any other tips
[21:29] or tricks from this group >> I might be the only AI CEO that doesn't believe in token maxing I do believe in token optimization though >> so what we do is we connect our coding agents to our live platforms. So that is
[21:42] a loop which we've started to close quite aggressively now. So for us all our agent platforms we run the same platform locally on the developers machine that we run in production in main. So your coding agent has access to
[21:55] that locally running agent platform that unlocks a very special thing. Cloud code can now use test improve and iterate your system by looking at the data it's producing. And that allows your entire
[22:08] company, the agent platforms that you're building to go from token maxing to token optimization and you can start using these systems a lot better. So that's what we do internally for us. >> Yeah. Just some really quick notes. I mean, I will say we're in a privileged
[22:20] position because we're startups and at least for us, I don't know about you guys, we're on the $200 a month QuadMax plan, uh, which is subsidized. Um, so I don't know how many of you actually have that luxury versus being on the enterprise API plans. Um because like if we were were actually fully pull on
[22:33] that, I do think we'd probably have to worry a little bit about like cost optimization. Um I think in general we've uh I mean uh kind of made you know everybody from product and engineering to research uh like a member of technical staff which basically means
[22:45] like we're kind of expecting everyone to do more things at once. um kind of being able to do product scoping, customer discovery, customer discussions, engagement, success, um all the way down to if you're able to delegate uh kind of like engineering effort towards the code
[22:58] writing part, it means you're able to own a lot more stuff end to end. Um to some extent actually shapes who we look for and hire for as well. Um and really just being able to make sure you're actually more AI native and be able to handle these tools effectively.
[23:10] >> On on the cost front, um that that actually like is becoming an issue for us. I think it's it's partially because people use the APIs through cursor or something like that. Um, but one of this this has probably been the biggest thing that that we've been thinking about
[23:23] internally and and and we've started using Langmith for some of it. So we have an LLM gateway cost controls and cost availability is built into that and so we we made integrations with all the coding agents out there where it's possible and and and are are running
[23:36] everything through there. We now have a budget per person per month. Um, I think it's it's it's high, but the um the places where we've we've just seen people make mistakes. We and and and we we had one person burn um I think 30K in
[23:49] a week or something like that. >> Wow. >> And they didn't know what they were doing. It wasn't intentional. It was just they were they were taking like uh they were taking all the HTML of front-end pages and passing it back through the through the agent every single time because they were doing front-end engineering. And so we just
[24:02] want to catch things like that. And so even though we are a startup and even like we let people use whatever they want to use, it has gotten to a point now where our costs are high enough where we're starting to look more into like cost controls. And I think I think
[24:14] and this is also where open source models start to get really really interesting. I don't know how true this is or not, but I saw something that open AAI or sorry Anthropic might stop having the max plan and start my requiring token only at the end of the year or
[24:26] something like that. And so we're actively thinking what do we do in that scenario? Do we use open source models? Do we um do we use cursors composer model as that's more kind of like feasible? And so I think this is this is
[24:38] something that's top of mind for us and I think a lot of other >> yeah same thing here you know at at data bricks sort of like open source models proprietary models how do we find that right the right balance of mix for for our engineers. Um it's go it's like kind
[24:51] of interesting right like basically for all of our internal usage like cost optimization is starting to become a thing and then for any startup like kind of in the token path like any you know cursor itself uh or you know to some extent for us cuz we're building like document understanding capabilities to
[25:03] any like verticalized AI startup um you're kind of like trying to figure out the right level of intelligence needed to actually try to solve the task at hand and I think there is you know a lot of uh there's a lot of discussion like online about this but I think there's a
[25:15] lot of real offa there >> yeah I wouldn't recommend everyone to go there But we end up fine-tuning our own model in the end of the day and we just like hosting that on like a few H300 and like all right now we can hit on this like as much as we want. Um so that
[25:28] ended up helping us on that as well. I did want to kind of maybe shift the competition now to sort of the agentic stack and where we see the kind of that going over the next couple well it's really hard to predict what happen over the next couple of years maybe just say
[25:41] like the next nine months maybe um and in particular you know the foundation model providers are basically releasing harnesses that do have say memory built in and tool calling and those sort of loops so how in in light of that the
[25:55] foundation model labs kind of almost baking those into their model APIs how do Do you see like the future of these projects and and the open agent tech stack evolving >> for us? Uh we think our mission
[26:09] continues to be to let companies build and run their own agent platforms and the runtime that we provide continues to be a focus of that. For example, uh our runtime can work with any framework from
[26:22] companies. We work with Langraph Crew AI. We love like because agnos in the name it has to be model agnostic, framework agnostic, cloud agnostic. So as these projects evolve in my view, we're going to evolve to actually
[26:34] solving what the user problems are and focusing on those pieces which again how do you run these things securely at scale in your own cloud. >> Yeah, I I think honestly like the year
[26:47] is 2020 sets, right? And people are using like a multicloud. I think would be very naive for anyone of the stage in here think like oh they're only going to use CI or only going to use lang graph or only going to use a like they're going to use many different things right
[27:00] so I think there's definitely kind of like an angle in there for like like to position against models and even hyperscalers where um I think a lot of the leaders especially on enterprises where they have been the market for a
[27:12] while they actually experienced this on the onrem to the cloud migration where everyone promised hey it's going to be unicorn and rainbows and now they're stuck with like a basically management services bills that keep heading higher
[27:24] and higher and they're like all right everyone has a five years like migrating to Kubernetes project right uh because some of that so I think that's definitely an important angle for sure but I think in the end of the day there
[27:36] is such a large gap in and and this is kind of like where I I might disagree a little bit on what you said in the beginning yes like putting together on stack might be as simple as kind of like some fundamental blocks on the technical
[27:50] side but even if you ship those blocks between that and actual business value that last mile is like a thousand miles like there's so many edge case there's so much value to be captured in there
[28:03] and you can think about like from the integrations from the security from the PII from the access there there's a lot of different things that can happen in there and there's a lot of legacy systems that are in place that need to
[28:16] be tapped into so I think again there's going to be a lot of like Uh there's not going to be a one winner or take all. Um there's going to be a few that are going to win big though.
[28:28] >> I mean some some Yeah. Like maybe related to some things around around this. Um I I mean I think there's a reason model providers are building hardnesses. I think they realize that models are pretty easy to switch between and are pretty quickly getting commoditized. And I think they want to
[28:40] own more of the stack that would allow them to create some sort of of lock in. Um I do think on the infrastructure side I agree with what you said. that I think yeah I I I don't think anyone and no one
[28:52] wants to get locked into a model provider that and unless you're maybe like super early on in experimenting and don't really care about that optionality. Um we had someone from our team write a really great blog around how it's not just like I think cloud optionality cloud neutrality was uh more
[29:05] defensive. You didn't want to get locked in. Model optionality can be more offensive because a new model comes out so quickly and they're good at different things like you need that optionality a bunch. So I think on the like I don't think people are going to get locked in to a single model provider. I think a
[29:18] lot of the infrastructure is going to be horizontal. I think there is an interesting like uh question of like these harnesses, do they need to be kind of like model specific? Um, and I think there's been a few projects that have come out recently that are like meta harnesses kind of like wrapping these
[29:31] harnesses. At the end of the day, like what it means for a harness to be model specific is is largely like as far as I can tell prompt changes and tool changes in terms of like the surface area of what tools might be better for one model versus another. and then we and and
[29:45] others uh I know replicate those in the open source kind of like frameworks as well. So I think there's some interesting questions here. I think it's I think it's definitely true that uh some of the frontier labs are are post-training their models to be against
[29:58] harnesses. Um I think there's some open questions of like how much that matters and how much that's uh hard for open source frameworks to replicate. Yeah, >> I think in terms of the overall and this is a bit of a complimentary take to uh
[30:11] everything that was shared like I do think in general um all the frontier labs are and and all the open weight models are kind of working on all like longer horizon tasks. Um and so you know stuff that you know now you can do things end to end within cloud code for like 3 hours or so. Uh you're probably
[30:24] going to get to the point where it can just run continuously for days uh or assuming again like the budget and your tokens like work out. um like assuming all that stuff works out, all these labs are working on things that enable you to basically have continuously running
[30:36] agents end to end. And so I do think uh what that means is um there are basically just going to be these like generalized like agentic solvers. Um and they basically again kind of need the right context and the way that you actually build prompt and use some of
[30:48] these agents is moving up the stack towards English plus like whatever like access to systems you're able to give. Um so I do think you know for any enterprise to just like prepare themselves in this world of kind of long horizon agents you do need kind of like
[31:01] the right uh almost like organizational like management uh to be able to actually enable everyone to delegate to these agents properly. You need the right like context layer to make sure they have access to the right context. So not everyone's like reinventing the
[31:14] same thing by using these agents. Um, and and you need to be able to, you know, like to everyone else's point, be able to kind of be a little bit model agnostic, so you're actually able to stay uh, you know, on top of the state of the art. >> Yeah. And all of you started open source
[31:27] projects at a time when you're writing your documentation and your code for humans to digest. That has changed quite a lot over the last 6 to9 months. How have you adapted your project to the
[31:39] world where agents are probably the ones that are consuming, you know, your libraries, you know, even more? Yeah, this is really specific to us. Um, so I'll let you guys share, but we kind of Yeah, I mean I'm sure all of you have seen this too. Like basically, uh,
[31:52] coding agents are starting to pick up the auto installations of like, you know, lane chain, crewi, agno. Um, and to some extent a lot of our capabilities around our libraries too. Um, we focus on building this like completely free and open source parser called light bite
[32:04] parse. Um, it is completely free. You know, anyone can download it. And our goal is basically overtake pi pdf, pi bpdf, and basically all the other free and open source libraries in just popularity. um from a coding agent
[32:16] perspective, right? So when Claude wants to go read a PDF, it uses us instead of some of these other tools and and not just because you know like of popularity or whatever, but also because it's actually really really good. Um I think in general every builder is designing
[32:28] their tool uh for like AEO, but not just like kind of for search, but also for usage within the loop of a lot of these coding agents. Um so I think for us it's like really really specific to document parsing. But I'd be curious to see hears. >> I saw some of the stats that you put
[32:41] together by the way. It's pretty remarkable what you folks have done. Uh so yeah, if you haven't tried it out, you should try it out. Uh it's pretty good. Um I mean for for us it's funny because two months ago was the first time that looking our kind of like
[32:53] analytics stats. Uh for the first time we got more agents than people going into our docs and that was a turning point. I expect every month to moving forward to be like that. Um so we end up
[33:05] putting together for example a a set of skills that anyone can install in any kind like coding kind of like agent right? So you go into skills.cread.com core.com there's like hey there's how you install for codeex or whatever
[33:17] you're using right and that is kind of like of a of one of the main things and then with those skills we're kind of like just expanding on those so people can like bringing that easier and easier and then even making parts of our
[33:29] product so we have the corei management platform that's kind like where we sell to these enterprises and then exposing that to coding agents was another major unlock so people can actually use the
[33:41] platform through cloud code work to cloud code to whatever the UI and the experience they're using internally so they can kind of like a build inspect the bug through that as well but yeah I
[33:53] think there's definitely you need to make your product agent first at this day and age >> we've started to do that by default all the agent platforms
[34:05] used entirely by coding agents so when our customers start their journey of building agent platform and that's why it's so easy to uh for them to copy this template, this project, start their
[34:17] agent platform, just let cloud code build their agents, more importantly look at the data, improve the agents and solve their business value as well, build the integrations which they have don't have. So what we found is as more
[34:30] coding agents start to use agent platforms, use infrastructure, having the entire infrastructure designed for them through the right interfaces, through giving them access to the data under the hood is um is I think table
[34:44] stakes at the moment. >> Yeah. And we have like a maybe more spicy question which is the future of open source software because there's kind of two takes. One take is hey in the age of AI coding I don't need open
[34:56] source frameworks anymore I just ask cloud code to write its own agent framework and modify it for my need but then there's all these other hey with all this a there'll be more and more open source software that gets released out there because you know the cost of
[35:09] creation is lower curious where you know you all may may may sit on that on that spectrum or a completely different dimension that I that I haven't thought about >> yeah I I have a bit of a I mean because we do like the context layer stuff But I
[35:22] I would be curious to hear your guys' stakes. Like we um I do think it's really like for coding agents. Um they write code, right? And code costs tokens. Um and if you try to literally rewrite everything from scratch, it doesn't kind of make any sense. Um they
[35:35] still import libraries. Uh they still import things that like do things. Um and so to some extent, if you design the right abstractions and agents can actually use these abstractions, you know, as part of whatever they're building. Um, so I still think there's a lot of uh, you know, places for
[35:48] open-source, I guess, like software and also packages, right, that are installable because it's simply just inefficient for a coding agent to just do the entire thing end to end by itself. It's still going to use like, you know, a web framework. It's still going to use, you know, a document
[36:00] parsing solution. And I I think there's plenty of opportunities within the orchestration space for it to basically save tokens by actually using the right primitives to actually do things. Yeah, >> I see it the same way. open source uh frameworks, libraries, they are trusted
[36:13] solutions that coding agents build on top of. So you're not going to write everything from scratch. Uh you're going to use the engineering team sets up the scaffolding. They sets up the code code
[36:25] base. It sets up the guardrails in which these coding agents operate and then uh coding agents build out rest of the bits and bobs. Everything from creating agents to writing software to improving it to testing it all the way through
[36:38] that entire pipeline is now skill- driven. >> Yeah. Maybe I'll also ask sort of um speaking about open source software and proliferation of packages. What is one other open- source library that outside
[36:50] of this distinguished group that is kind of up and coming and interesting that the people here should should check out? I'll call out one that I was maybe going to use to answer the previous one, which is it's pi. Uh so pi is a very
[37:03] lightweight uh coding harness. Part of what I think makes it interesting and also ties into the previous question is it's super extensible. So it starts very bare bones and then as you it's a co it exposes itself as a coding agent and as
[37:16] you use it or I guess even via source code you can write different plugins and modify it and I think that's maybe the the kind of like really uh uh great future of open source software where
[37:28] it's modifiable and it's customizable and that's because it's open source and you can see the source code and and provide that kind of like extensibility and so I think that's a really great library and points that like maybe a bright future for open source. >> Yeah. any other interesting libraries
[37:40] the the group the community here should check out? >> Well, a random one's a little bit out there, but uh I really like I don't know if people know them. Uh basically like there's some folks that are creating this uh Python project to help you fine-tune models. I got I like them
[37:54] because they make it extremely easy for you to do it. So it's like they had a bunch of syntax shooter and abstractions on it. It's a little bit out there but uh it's very good. I really like them. Very easy to use library. Cool. I need to try out that light part because uh
[38:08] every conversation we have has some part which is dedicated to invoice processing, PDF processing. So I got to try that one out. >> I didn't prompt him beforehand by the way.
[38:20] >> Maybe a huge round of applause for the amazing open source contributions from this, you know, group of founders.

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.