Nilou Salehi - Agent Learning Requires Compressing Info into an Executable Reasoning Structure

0:02 Thank you. My name is Nilou. I'm co-founder and CEO of a company called Across AI. I'm also a professor here. What I'm going to talk about today is that basically the whole problem that we're all solving and have been solving for years now is compressing information. Because at the end of the day that is what a model does, that is what a harness does. We are finding different ways to take lots and lots of information and compress it into a format that is executable. Like a transformer model is executable and predicts the next token. Now, over the next few years what's going to happen is we're going to come up with more and more architectures that are able to do this in more complicated ways. And one of the first problems that we're going to have to solve is what are the various types of processes and what is the optimal architecture or harness for each of these processes. I want to share one that we've had a lot of success with, which is reasoning graphs. A reasoning graph is a graph of agents.

0:55 So, each of the circles that you see in this graph is is one of the agents and we've identified that for a particular process, especially processes that need to be run repeatedly and with very high consistency, this is a very good architecture to do that. So, the way this works is that at the very bottom layer you have a layer of agents that just connect to all of the different systems where the raw data lives. And all these agents do is understand that raw data. You have another layer, these are the layers that of agents that do the reasoning. And then finally, there's a layer of agents that take the right action at the right time. So, any path that goes from the bottom all the way to the top is one possible reasoning path.

1:31 And we've seen different flavors of the same idea come up today. Like you could run these in parallel. You could optimize them in certain kinds of ways. Now, the question then becomes how do you create one of these? And we've seen also this idea show up in a couple other talks today as well. and it has to be that it's done by an agent. So, what we're going to see more and more is these sort of handshakes between an agent and a harness.

1:57 So, and that agent is trained to know very well how to work with that harness. And these different architectures are going to be good at different kinds of processes. So, one that we've been working a lot on is this architect agent that works with a processes that run consistently and highly accurately, like financial processes or supply chain or something that a company needs to keep running over and over, is non-deterministic, still needs to be intelligent, but needs to be highly consistent and explainable.

2:25 So, what you get is very high consistency. We've had routinely above 95% accuracy in running these processes. And examples are benchmarks where even Fable can only hit about 40 to 70% accuracy. And we also get very high speed. No custom code is being written in any part of generation of this harness. It's all the architect agent working together with this particular harness. So, we can launch new use cases in a matter of weeks. And the most important part of this architecture is the compounding intelligence in the weights of that model.

2:56 So, every time the architect takes a new use case and creates a reasoning graph for it and learns how to do that, it gets better at doing that. So, this is this kind of a model we're going to see more and more and we're going to see it for different kinds of processes. I wanted to give you one example of a process that we identified using this architecture. And that's invoice matching. So, very very large companies receive lots and lots of invoices and they have to make a very simple decision. Pay it or don't pay it. They receive a certain amount of fraud, so they can't pay everything. They also can't sit on it too long because if they don't pay an invoice in time, it affects the rest of their supply chain. So, imagine large companies are processing millions of these invoices every month.

3:36 So, an invoice is received, it has to be matched to a PO, it has to be normalized. There are lots and lots of exceptions, like the units might be different, the currency might be different. There's tax in certain areas. One example that I stuck in my head, which I thought was very funny, is that if it's liquid, it's okay if the amount on the invoice is up to 5% less than what was on the purchase order, but only during summers because some of it evaporates and there's nothing you can do. So the agent has to keep learning. It's not a one-time one-shot learning thing. It's also not something that happens just in one session. It's something that lasts a process that lasts long horizons, months and weeks, and every time you see an exception, you have to learn from it. A baseline agent harness, even using Fable here, only gets about 40% of it right.

4:22 This is what the reasoning graph that we built where our architect agent built for this process looks like. It's made up of lots of agents, their wiring, their instructions, what models each agent should use. Each has their own long-term memory. So all of these decisions, all of these engineering decisions are made by the agent. And what we hit was 99.9% accuracy on this real data example. The first graph was up and running in a week, and in 96% of the cases, not only did we give the right decision, but we were able to correctly explain why that decision was made.

4:53 This brought down the cost of processing those invoices at this one Fortune 500 from $5 an invoice to 1 and 1/2 in this example, and more recently, this week, we got it down to 10 cents per invoice. So those are the kinds of advances that you can make if you're able to take that learning and compress it into a reusable structure. Thank you.