Building an Agentic Platform — Ben Kus, CTO Box

Hello. So I'm Ben Kus, I'm CTO of Box, and I'm going to talk today about our journey through AI and, in particular, our AI agentic journey. And if you don't know much about Box, a little bit of background: at Box we are an unstructured content platform.

We've been around for a while, more than 15 years, and we very much concentrate on large enterprises. So we've got over 115,000 enterprise customers, we've got two-thirds of the Fortune 500, and our job really is to bring everything you'd want to do with your content to these customers and to provide them all the capabilities they might want.

In many cases, for AI, many of these customers, their first AI deployment was actually with Box because, of course, many enterprises worry a lot about data security concerns and worry about data leakage with AI. Make sure to do safe and secure AI, and this is one thing that we have specialized in over time.

But the way that we think about AI is at a platform level. So we have sort of the historic version of Box, which has the idea of the global infrastructure, sort of everything you need to manage and maintain content at scale.

We've got over an exabyte of data, we have an awful lot of hundreds of billions of files that our customers have trusted us with, and we have the natural way to protect them in addition to the type of services that you provide when you're an unstructured data platform.

But then, for the last few years, one of the key things we've been investing in has been in AI on top of the platform, and I'm here to tell you a bit about our journey here. So we started our journey in 2023, shortly after AI became sort of production-ready from a generative AI sense.

And everything I'm talking about here today will be generative AI, of course. So we ended up with a set of features: things like QA across documents, things like being able to extract data, things like being able to do AI-powered workflows.

Happy to talk about these in general, but today I'm going to focus on one aspect of the features that we built, which is the idea of data extraction. This is the idea of taking structured data from your unstructured data and using that in an enterprise setting.

And partly I'm going to focus on this one because this is interestingly maybe the least agentic sort of thing that you might think of when you're thinking about these other examples about how you interact with AI. This is much less like a standard chatbot-style integration, but what we learned and what I'll tell you about is how the concepts of agentic capabilities apply well beyond just sort of end-user interactions.

So we'll be talking about data extraction for a moment. Just quick background: when we talk about metadata or data, we talk about the things in unstructured data, be it documents, be it contracts, be it project proposals, anything that then turns into structured data.

This is a very common challenge in enterprises, is that they have like 90% of their data is unstructured, 10% of their data is in databases, structured data. And historically, there has been this challenge that it was kind of hard to utilize this.

So many customers have, for a very long time, wished they had better ways to automate their unstructured data. And there's a lot of it, and it's really critical. In some cases, it's the most critical thing in an enterprise.

So the things you do with it would be to query your data, being able to kick off workflows, being able to do just a better search and filtering across all of your data. And so the prototypical example, this is something like a contract where you have an authoritative unstructured piece of data, but then also the key fields in there are very important.

So this is not a new thing. For many, many years, the world, Box included, has been interested in pulling out structured data from unstructured data. And there were a lot of techniques to do this, and there's a whole industry.

If you've ever heard of IDP, this is like a multi-billion-dollar industry whose job in life was to do this kind of extraction. But it was really hard. You had to build these specialized AI models, you had to focus on specific types of content, you had to have this huge corpus of training data.

Oftentimes, you need to get custom vendors or custom ML models that you make, and it was quite brittle. And to the point, not a lot of companies ever thought about automating most of their critical unstructured data. So this was sort of the state of the industry for a very long time.

Like, just don't bother trying too hard with unstructured data. Do everything you can to get it in some sort of structured format, but don't try too hard to deal with unstructured data. Until generative AI came along. And so this is where our journey sort of begins with AI, is for a long time we've been using ML models in different ways, and

the first thing that we tried when confronted with sort of a GPT-2, GPT-3 style of AI models is that you just say, "I have a question for you, AI model, can you extract this kind of data?" And as we mostly all know, AI is not only great at generating content, it's also great at understanding the nuances of content.

So what we did, we first started out with some pre-processing, doing sort of OCR steps, classic ways to do this, and then being able to then say, "I want to extract these fields." Standard AI calls, single shot or with some decoration on the prompts.

And this worked great. This was amazing. This was something where suddenly a standard, generic, off-the-shelf AI model from multiple vendors could outperform even the best sort of models that you had seen in the past. And we supported multiple models just in case, and then it got better and better.

This was wonderful. So this was flexible, you could do it across any kind of data, it performed well.

Yes, you had to do OCR and pre-process it, but that was straightforward. And so we were just thrilled. This was like, for us, it was like, this is a new generation of AI. And interestingly, we would go to our customers and say, "We can do this across AI data," and then they would give us some minute work.

And then we'd be like, "Great, AI models are awesome." Until they said, "Oh, now that you do that well," and I get it, "now what about this one? What about this 300-page lease document with 300 fields? What about this really complex set of digital assets?"

And you want to get these really complex questions associated with it. What about, "I want to do not just extract data, I want to do risk assessments and things." So there are these more complex fields. You start to realize, "Huh, as a human, if you ask me that question, I'm struggling to answer it."

And then in the same way the AI sort of struggled to answer it. So suddenly we ended up with more complex documents.

Also, OCR is just a hard problem. There's seemingly no end of heuristics and tricks that you do on OCR to get itright. So I've got to scan a document, somebody writes stuff in it, somebody crosses stuff out. It's just hard.

And then for people who have dealt with things like different file formats, PDFs, it's a challenge. So whenever that OCR broke, it would just naturally give bad info to the AI, and then languages were a big pain. And so we started to get more and more challenges as we have an international set of customers across different use cases.

Also, there was a clear limit to the AI in terms of how much it could handle the attention to so many different fields. So if you say, "Here's 10 fields, here's a 10-page document, figure it out," they're great.

Most of them are great. If you say, "Here's a 100-page document, and here's 100 fields that are each of them complex with separate instructions," then it loses track. And I have sympathy because people would lose track too. And so this became very problematic because if you want high accuracy in an enterprise setting, this just starts to not work.

And then also it's just like, "Well, what is accuracy? What does it mean?" In the old ML world, they give you confidence scores. 0.865 is this one. And then, of course, large language models don't really know their own accuracy.

So we would implement things like LM as a judge, and we'd come back and tell you, "Here's your extraction. Also, we're not quite sure this isright." And then our enterprise customers would kind of be like, "Well, that's helpful to know, but I want it to workright, not just you tell me it doesn't workright."

And so this became this kind of set of challenges that we focused on. And so customers were looking for speed, they were looking for affordability, they were making this work. They were saying, "If AI is this future awesome thing, then show it to me."

And on these more complex documents. So at this point, we kind of hit our despair moment. We thought LLMs were the solution to everything. We thought that we could have these AI models that worked, but then we actually struggled.

What do you do now? How do you fix this? And I know, let's just wait until the next Gemini model or OpenAI seems to be on top of this, so wait till the next one, which is part of it,right?

The models do get better. But the fragility of the architecture was one that we weren't really going to be able to solve on our own. So naturally, one of the answers that we came up with was bringing agentic approaches to everything that we do.

And this is really one of the key things that I want to sort of bring out in this session, is that it certainly was not obvious that the way to fix all these problems in something like data extraction was to do agentic-style of interactions.

And when I say agentic, I mean an AI agent that does something like this: AI model, instructions, objectives with the model background, tools. We may have secure access. Of course, it has memory for the purposes of advancing and being able to look up information inside of the system.

But also with a full directed graph. So the ability to orchestrate it to be able to do things like where you say, "Do this, then this, then this." Either it comes up with its own plan, or we actually can orchestrate it ourselves because we have knowledge of what we want it to do.

And this was, for us, it was controversial. It was like our engineers were like, "What are you talking about? Let's just make the OCR better. Let's just add another step somewhere. Let's just add a post-processing, regular expression checks."

And then, of course, everybody always like, "I have a way to do this based on the old way of doing this. Why don't we train an ML model? Why don't we fine-tune?" And so suddenly all of the genericness of it would get lost in this process.

So we came up with a mechanism, which was a, so this is, I think, kind of LangGraph style of agentic capabilities. And so

we still had the same inputs and outputs. In document with fields, out answers. However, the approach was an agentic approach. And so we played with all the models, reflecting back and forth and criticism, being able to separate it in multiple tasks, to be able to have different multi-agent systems work on this.

And we ended up with something like this, where you have a step where you prepare the fields, you go through, you group the fields. We learned quickly that if there's a set of fields that are customers from a contract and then are parties, and then somewhere else there's the addresses of the parties, you need the AI to handle those together.

Otherwise, it's like you have three parties and two sets of addresses which don't match. So we had to break up intelligently the set of fields. We had to go through and we had to

do multiple queries on a document. Then after we got that, we would then use a set of tools to check and to double-check the results. In some cases, we used OCR. We would then double-check it by looking at pictures of the pages.

And using multiple models, sometimes they vote and they're like, "Oh, this is a hard question. Three models." From different vendors, two of them think this is the answer. That one's probably a good answer. And then onto the idea of the LM as a judge, not just a judge to tell you that this is the answer, but a judge to tell you, "Hey, here's some feedback, keep trying."

Now, of course, this takes a little bit longer, but this is something that then leads to the kind of accuracy that you'd want overall. And so for us, this was

the architecture that then helped us solve a set of problems. And it became interesting because every time there was a new set of challenges, the answer was not, "Rethink everything," or "Let's then try a whole new set of, oh, give us six months and we'll come up with a new idea."

But I wonder if we change that prompt on that one note, or I wonder if we add another double-check at the end, then we can actually start to solve this problem. So we bring the power of AI intelligence to help us then solve something that we used to think of as a standard function.

And then not only that, it helped us in other ways. So we were naturally as an unstructured content store, one of the first things you always see people, if I was going to give you a demoright now, it's, "I have a bunch of documents, I have a question."

And we had the same thing with a judge. And it would be like, "It would tell us, oh, that was a good answer, or that wasn't." And then why not, just if it's not a good answer, we'll take another bait and tell the AI, "Try again."

Before you tell the user this answer, I want you to reflect on it for a second. And this kind of thing just leads to higher accuracy. And then it also leads to much more complexity. So we just announced our deep research capabilities on your content.

So in the same way that OpenAI or Gemini does deep research on the internet, we let you do deep research on your data in Box. We'd look something like this. So this would be roughly the directed graph that you'd have, where you'd go through, first we searched for the data, kind of do that for a while, figure out what's relevant, double-check, then make an outline, kind of prepare a plan, go through, make a process.

And this is all agentic thinking. And this kind of thing wouldn't really be possible if we hadn't kind of laid the framework of having an agentic foundation overall. So I will leave you with a few lessons learned here.

So this is based on our time in the last few years. The first is that it wasn't obvious to us at first, but the agentic abstraction layer, from an architecture perspective, is actually quite clean.

Once you start to think this way, it is very natural to think, "I'm going to run an intelligent workflow, an intelligent directed graph powered by AI models at every step, to be able to accomplish a task." Not everything, but sometimes that's a great approach.

And this is independent of a high-scale set of sort of distributed system design. And both are important. At some point, you have to deal with 100 million documents on a day. At the same other point, you have to deal with that one.

And so being able to separate these two systems into somebody who thinks about the agentic framework and somebody who thinks about how to scale a generic process, this is very helpful to keep these distinct. Also, it's just easy to evolve.

In that deep research example, one of our biggest. We did it, and then it worked really well, except for the output was kind of sloppy. And so we were like, "Ah, I guess we got to redesign the whole thing," or add another note at the end to say, "Summarize this according to this."

And it would just take that in and just redo the output. Took not that long to fix. And this was something that was not obvious to me until later, which is that if you're going to be using agentic AI with a team who's been around for a while, you start to need to get them to think about agentic-first kind of thinking, AI-first thinking.

And one way to do that is to let them build something so that they can start to think, "Oh, this is not only how we can build more things, but also because we're also a platform for our enterprise customers, they can think about how to make it better for them."

So things like really doubling down on the idea of, "We publish MCP servers, what are the tools like for them, what can we do to make it easier, how can we do our agent-to-agent communications," and so on. So this is all kind of summed up with, if you're confronted with a challenge, the lesson that we learned is that if it's plausible that a set of AI models could help you solve that problem, then you should build this AI agentic architecture early.

If I go back in time, I would wish to be done this sooner because then we'd kind of have been able to continue to take advantage of that. And so that's my journey, and that's my lesson through here.

So thank you.

Anker, are we

two minutes? Okay. So if anybody, two questions. Okay. If anybody has any questions, I'm happy to answer them.

Is this available as an API?

Question being, is this available as API? Yes. So we're very API-first oriented. So we have an agent API that you can call upon these agents to do things and give them the arguments. So yes, we provide

just APIs across everything and tools to call our APIs.

Okay.

Where are you primarily just evaluating your agents with LLM as a judge, or are there other?

Makes when you start using a more manual approach as well?

In terms of evaluating our agents, and how do we do that? So we not only use LLM as a judge, but we also create eval sets. So we have our standard set of eval sets. And then we've learned that since AI gets so good over time, we created a challenge set of eval sets so that we can better explore things that not everybody asks, but if they did, it would be really hard.

And then that way you can better decide on whether or not you're not only prepared for now, but as people get more challenging things, we know that we can grow across that. So a mixture of eval sets plus LLM as a judge, plus the idea of just having people give feedback.

We have limited ability to look as an enterprise company at what's happening, but the idea of them telling us this is still useful in all cases.

You can yell if you want. I'll hear you.

So this is the first time we talk, so apologies about asking a question before you would talk about that. It seems like you're mostly building agents, but these things together out of Box, do you consider fine-tuning or any of those approaches?

So the question being, why bother with agents if you can fine-tune a model?

No, no, I'm saying.

Have you tried fine-tuning agents?

We're pretty anti-fine-tuning at this moment because of the challenges of once you fine-tune something, you have to then fine-tune all of the evolutions of them going forward. We support multiple models: Gemini, Llama, OpenAI, Anthropic. And it's just hard to consistently fine-tune across the board in ways that not only, and usually just the next version of the model gets better.

So we've gotten to the point where we use prompts or cache prompts or agenticness as opposed to fine-tuning. That's the approach for our particular use cases that works quite well.

Okay. Thank you, everyone.