Why Wall Street Still Doesn’t Trust AI

5:49:35Vinoo Ganesh

5:49:37I'm the CEO and co-founder of Kepler.

5:49:43This is going to be kind of an interesting talk

5:49:45because it comes from what happened three months ago.

5:49:48So three months ago, I think there's a little bit of an overlap,

5:49:51but I gave a talk at AIE World Fair really around verification

5:49:55and why most institutions need verification

5:50:00in some form of the trust ecosystem of AI.

5:50:04Well, yesterday, most of you saw Jack and I were on stage talking about why Jack, who ran Citadel's biggest book and started Candlestick Capital, still doesn't trust AI.

5:50:15Since that three-month period, there's been about $270 million of VC money that got poured

5:50:23into formal verification layers.

5:50:25A VC actually took Kepler's own pitch deck and gave it to a competitor and produced something

5:50:31that has our same tagline.

5:50:32I'm not bitter, just a little.

5:50:34But the funny thing is they copied the wrong part.

5:50:36And so what I want to do is actually give you, the practitioners today, you can't just

5:50:42tack verification on at the end.

5:50:43And so when I gave that chat or that talk a few months ago,

5:50:50Anthropic had just published an article on how Kepler does what it does

5:50:53and why it's really powerful and really unique.

5:50:56So what I want to do is get into the technical side of how we do the thing that we do.

5:51:01And ultimately, this is driven by one very simple insight.

5:51:04Wall Street still doesn't trust AI.

5:51:07Most people think that's because of this.

5:51:10AI will estimate things.

5:51:11It will hallucinate things.

5:51:13A frontier model will make stuff up.

5:51:15And ultimately, it is, and that's a component of it.

5:51:18But the actual core underlying problem is we have a structural problem in this technology

5:51:23that we're all so desperate to use.

5:51:26Meaning, if you actually chat with people that are building RAG platforms, most of what

5:51:31they'll say is, well, the models will eventually get good or get better to the point that they

5:51:34will eliminate hallucination.

5:51:36That is a nonsensical term.

5:51:39You know another word for hallucination?

5:51:41Alpha.

5:51:42Alpha is how a firm makes money.

5:51:44The creativity that you have and that your analysts have

5:51:47is a mechanism through which you can be a unique firm.

5:51:51Otherwise, there should be only one company on earth.

5:51:53So when you ask these types of simple questions

5:51:56around where data comes from,

5:51:57there is a piece of this that the model will just make things up,

5:52:00and there's a piece of this that your firm's internal data

5:52:03is never actually reflected in this setup.

5:52:07So what are we seeing right now?

5:52:09we're seeing everyone with a checkbook

5:52:11buy everything they can.

5:52:12Every RAG platform,

5:52:14some firms are trying to build,

5:52:15some firms are running agent pilots.

5:52:18I had a customer meeting this morning

5:52:20where someone said

5:52:21they were actually an AI-first firm,

5:52:23which means they have one co-pilot agent running.

5:52:25All this stuff.

5:52:26So why are we not seeing the complete switch

5:52:30of fundamental investing becoming effectively,

5:52:32why are we not all Jane Street?

5:52:34Why has that not happened yet?

5:52:36And so the challenge really comes from

5:52:39this idea of in order for you to produce work product

5:52:42that you believe in, you have to trust it,

5:52:45meaning you have to blame somebody who gets it wrong.

5:52:48So we see numbers like this all the time,

5:52:50where 80% of finance execs trust numbers,

5:52:53but then 31% find those errors.

5:52:55So what do we actually need?

5:52:58We need a situation where the reviews

5:53:01that we're getting for AI apps, as builders ourselves,

5:53:04do more than just ragify things.

5:53:07And these are quotes we've actually pulled from specific, I don't want to say our competitors,

5:53:13but other people, where things demo super well and they behave like a really smart intern.

5:53:18Or things are right if you just hook up the right structured information, but that last

5:53:2210% still gets things wrong.

5:53:25So what I want to do is, we're lucky, we have great partners and folks like turbopuffer,

5:53:29and I gave a similar chat yesterday about this, but how do we actually do the verification?

5:53:34How do we architecturally build a system that does not hallucinate numerically?

5:53:39Let's talk about it.

5:53:41Now, wrong numbers or wrong facts come from three sources.

5:53:45Either one, you retrieved the wrong document.

5:53:48So I pulled a document, some random thing from somewhere else.

5:53:52How do you fix this?

5:53:53Well, by retrieving the right document.

5:53:56But that in itself is complicated.

5:53:58Is the right document my own firm's internal analysis of what this stock is going to be worth?

5:54:03Is it, let's say, some analyst who I really trust more than anyone else?

5:54:08That's piece one.

5:54:09Now, failure two.

5:54:11We get the right source, and we pull the wrong number out of that source.

5:54:14Let's say we're trying to figure out what the revenue for, I don't know, Palantir was

5:54:18back in 2023.

5:54:21Well, if I look at the 2025 10K that says Palantir's 2023 revenue was this, I better

5:54:26make sure that that number corresponds to 2023 and not 2025.

5:54:31So the fix here is really we have a filter that actually checks each citation.

5:54:35But this is still a problem because that filter only applies after the fact.

5:54:40And formal verification doesn't actually help here because the thing has already been produced.

5:54:45Three is the mental math.

5:54:47Models don't do math.

5:54:48They predict the next token.

5:54:51For those of you who are going to say we have deterministic models, great, we do.

5:54:54We also have one CPU cycle that's good at adding two numbers together.

5:54:58Why don't I use that CPU cycle?

5:55:00So third failure is let's use deterministic tools that we already have to actually compute

5:55:06numbers and entities rather than relying on some external tool.

5:55:11So here's what we do.

5:55:12This is the magic behind Kepler, at least for piece one.

5:55:15There's a whole bunch of other stuff.

5:55:16We are architected fundamentally differently.

5:55:19Code writes every number, and what code does and preprocessing does is we assign pointers

5:55:24to unique identifiers, meaning facts, meaning something like a number in a 10K.

5:55:30This operates in a giant preprocessing and contextualization step,

5:55:34such that all of this exists, going from unstructured data to a structured data store.

5:55:39Then the model is effectively a smart analyst.

5:55:42It figures out how to go about solving the problem,

5:55:46but not actually being the thing to solve the problem itself.

5:55:49So it plans.

5:55:51It says I'm going to go here and retrieve this source and retrieve this entity and do

5:55:55this thing.

5:55:56Code and math do the retrieval.

5:55:58By actually pulling a number out of a 10k at search time, that's a hugely expensive

5:56:05token cost.

5:56:06And Anthropic and OpenAI should thank you for paying all those tokens and token maxing,

5:56:09but most of your firms don't like that, at least anymore.

5:56:12I know there were people getting bonuses from token maxing for a while.

5:56:16Now, the next piece of this is really, once the model is actually read both these pointers,

5:56:21it can't structurally generate numbers.

5:56:25Meaning, unless the model actually has a mechanism of dereferencing that pointer,

5:56:30that number or that fact cannot be generated in Kepler's output.

5:56:34Now, we do run a post-processing step, which is the verification step.

5:56:38And this is the piece that was kind of funny, where the last company just copied the verification piece,

5:56:43but all the structural stuff beforehand didn't make it.

5:56:46So what you as a consumer actually see

5:56:48is you see something like the revenue was this amount to this amount,

5:56:52and you physically can click on these chips

5:56:54and see exactly how we got the information.

5:56:57Now, in my past life, I had an opportunity.

5:56:59I was head of business engineering at Citadel.

5:57:01So I worked across the firm to figure out effectively

5:57:04what do we need to produce software that helps us generate alpha.

5:57:08You know the crazy thing with Citadel?

5:57:11PMs are so talented and so smart,

5:57:13but they work when they're paired

5:57:15with deterministic tools and technology.

5:57:17That's kind of the magical insight

5:57:19behind fundamental investing.

5:57:21Fundamental investors are so good at understanding data,

5:57:25but that data has to be right.

5:57:27And so when you build a system like Kepler,

5:57:30what you effectively have to do

5:57:31is look up the right information

5:57:33and then be clever about the information you don't have.

5:57:36So let me give you the parallel.

5:57:38Most folks and most buy-side researchers or buy-side investors

5:57:41try to use tooling or build DCFs on their own,

5:57:45and then they find and search for information they don't have.

5:57:49They schedule GLG or guidepoint calls.

5:57:51They find experts.

5:57:53They speak to management.

5:57:54The same system actually applies here.

5:57:57So what we do is we pick the path,

5:57:59and we store the information deterministically

5:58:01that we can actually store deterministically.

5:58:04When we have information we can't store deterministically,

5:58:06we run similar pre-processing steps to grab information,

5:58:10store that information in a hybrid storage mechanism,

5:58:13which is a combination of turbopuffer,

5:58:15who's awesome, by the way, and a bunch of other mechanisms,

5:58:18and then we ultimately use a combination of re-ranking

5:58:22with literally old-school pointer dereferencing dot get methods

5:58:27to pull things into our system.

5:58:29Now, why this matters is a lookup cannot get it wrong.

5:58:35Search can.

5:58:36If you're running the same 10 searches with the same query,

5:58:40the probabilistic nature of models means there's inherent entropy.

5:58:43That's actually an opportunity.

5:58:45So that's what we've changed here.

5:58:48Now, how we do this is we break this down,

5:58:51and this occurs across the SEC world as well.

5:58:54We are frequently throwing candidate documents away,

5:58:58meaning we consistently have to look at

5:59:00not only what source is the right source for what information,

5:59:03but also which documents should we stop looking at kind of globally.

5:59:08So we're on ANN plus BM25 to get back a set of documents,

5:59:12usually up to 200.

5:59:14We do reciprocal.

5:59:16We effectively get 60 documents back.

5:59:18It's probably the best way to think about this.

5:59:20Then we do cross encoders.

5:59:22We try to figure out exactly the query and the actual document

5:59:26chunked together and get those results that way.

5:59:30What that allows us to do is we can search really wide.

5:59:34You know what LLMs aren't good at doing?

5:59:36Searching really wide.

5:59:38What they try to do is create a plan

5:59:39and find either the fastest or easiest

5:59:42breadth-first search mechanism,

5:59:44actually maybe depth-first search mechanism,

5:59:46of actually getting the first document and moving forward.

5:59:49So we allow this to search really wide

5:59:50and then narrow from there.

5:59:53The reason LLMs don't like searching wide

5:59:56is because it's expensive.

5:59:57It's because looking across a bunch of

6:00:00different sources is significantly worse than getting the reward function back with your first hit and going from there.

6:00:08Okay. So I want to talk a little about security here because it's super important. Kepler was built with a security-first mindset and security-first mentality. Now, client documents, and this is specifically targeted towards the builders here, this is the thing that no one's chatting about.

6:00:25Everyone is talking about the security of what OAuth token is used and what user-scoped

6:00:30mechanism of retrieving documents.

6:00:32Which is actually pretty scary.

6:00:33So let's talk about how things go wrong in these systems that people are trying to build

6:00:37and how you can fix it.

6:00:39First and foremost, you forget to filter the tenant.

6:00:42All of a sudden Citadel can search for all of Millennium's documents.

6:00:44You will be in a lot of trouble.

6:00:46Second, a caller claims to be another firm.

6:00:49Meaning I can claim that I'm impersonating this other entity and querying documents that

6:00:53way.

6:00:54Third, search returns information that's out of date.

6:00:58We've had this problem kind of globally

6:00:59and even Google search results.

6:01:02Fourth, direct read skips the search rules,

6:01:04meaning you're not actually querying

6:01:05the full corpus of information,

6:01:07or there's not an allow list.

6:01:08You only get back the single document

6:01:10that you did the search.

6:01:11Five, you hit an index that isn't populated.

6:01:14The way to actually solve all these problems,

6:01:17and there's individual things listed here,

6:01:18is actually scoping searches with security built in.

6:01:23That's another critical piece that I think a lot of people miss when they're trying to

6:01:27build these systems themselves.

6:01:29Inevitably, people will start caring about the security associated with querying this

6:01:33information.

6:01:34Alpha is the most elusive thing out there, especially for folks on Wall Street.

6:01:38Making sure you have a good mechanism of constraining the set of documents that come

6:01:43back with each query is really important.

6:01:48Now let's talk about verification, which is the last piece here.

6:01:50This is probably what we're known most for, but we do the other stuff I mentioned as well.

6:01:56How we do this is by preprocessing information and storing it deterministically,

6:02:02we have systems like code that actually write individual pointers.

6:02:07The model can only then read those pointers and grab information back if they exist in the database.

6:02:13If I grab something out of a hash map that doesn't exist, I don't get anything back.

6:02:17And so this combination is what allows us

6:02:20to actually make sure the information that we retrieved

6:02:23actually came from the source that it came from.

6:02:25Now, this is a kind of hidden version

6:02:28of what our source IDs look like,

6:02:30but these are hashes,

6:02:32and these are very simple things that you can do

6:02:34in your own system and your own setup

6:02:35to ensure that you're pulling back facts

6:02:38that, in fact, do exist.

6:02:41Cool.

6:02:42So that's a little bit about how we do verification.

6:02:44Now, I want to chat a little bit about

6:02:46what this enables kind of globally.

6:02:50This enables us to verify facts

6:02:53that come out of our grounded corpus of data.

6:02:56Now, you as a builder, or you as a startup creator,

6:02:59or you as someone who is trying to figure out

6:03:01how do I trust my outputs,

6:03:03really just need to do a couple of things.

6:03:05You need to show people that as you're creating these agents

6:03:08that are theoretically looking for alpha

6:03:11or whatever they'd be looking for,

6:03:12you're using information that is actually relevant and concrete

6:03:15and, most importantly, accurate

6:03:18to the set of people that you're trying to service.

6:03:20So we end up with a contract

6:03:23where citations are either verified,

6:03:26corrected at search time,

6:03:28or flat-out refused.

6:03:30This is crazy if you think about it.

6:03:33If a model cannot de-resolve that pointer,

6:03:36it cannot print that number out.

6:03:40So that's kind of an insane thing.

6:03:42It means that the whole, and not just a number,

6:03:44let's talk about facts,

6:03:45Like, we see these court cases all over of precedents being hallucinated.

6:03:50Well, why can't we create a system that just has the precedents stored deterministically

6:03:54and allows us to search through that list and not have a random court case that never existed

6:03:59all of a sudden start existing?

6:04:01So this mechanism and this technology actually becomes fairly globally applicable.

6:04:06And the reason I'm on stage telling you how we do what we do

6:04:09is because I'm terrified that Wall Street never trusts this technology

6:04:14because of the fear that so many other companies

6:04:17or so many build-it-at-home folks

6:04:19have been instituting in these organizations.

6:04:23It's gotten to the point where

6:04:25the vast majority of finance AI tools right now

6:04:28are being used to format PowerPoint presentations.

6:04:31We still haven't actually built a DCF cradle-to-grave,

6:04:34despite what most people are saying.

6:04:35And if we had, every single company on Wall Street

6:04:38would have adopted that overnight.

6:04:40So this is my fear.

6:04:41My fear comes from a very simple fact.

6:04:43For us to actually get value out of this technology,

6:04:46we need to be able to build technology

6:04:48that people actually can trust and can verify.

6:04:52That isn't just true in finance.

6:04:53It's true in a bunch of different industries.

6:04:55So please, take what you need to from this presentation

6:04:57and get people using this technology.

6:05:00Otherwise, we're all going to be out of a job.

6:05:02Now, I want to chat through what happened when we saw this.

6:05:05So when we went through this whole process,

6:05:08this is actually some of our real production data here,

6:05:12refusals are when the model

6:05:14is not able to produce a number.

6:05:18Meaning the model will say,

6:05:19I couldn't dereference this pointer,

6:05:21therefore I could not produce this number.

6:05:24We saw that drop super drastically.

6:05:27Now the reason that it didn't drop to zero

6:05:29is because models are still probabilistic.

6:05:32Meaning it can still make up numbers

6:05:34after the fact during inference.

6:05:36So there is another post-processing step

6:05:39after this that we have as well.

6:05:41But my point with this slide is just by creating a system

6:05:45where the models have to dereference their own pointers,

6:05:47you can actually create a very powerful, very verifiable AI platform.

6:05:53And that to me is my ask to all of you.

6:05:55As you go through the building process,

6:05:57as you go through the scoping process,

6:05:58any tool that you use,

6:06:00ask them if you can actually verify the numbers.

6:06:02Ask them if you can see where the sources are,

6:06:05not in terms of some after-the-fact annotation,

6:06:08but click on the number, whether it's a calculation,

6:06:10whether it's an extraction or some combination of the two

6:06:14to make sure you trust the insight.

6:06:16And all of this ultimately is going to be the unlock.

6:06:20So you, as a vendor or you as a builder, ask these questions.

6:06:25Does the model actually write pointers?

6:06:27Does it actually create a mechanism for verifying the output?

6:06:30Is every citation source checked?

6:06:32Is arithmetic source checked?

6:06:34Do you have a mechanism for stopping files

6:06:37that reach clients or customers that it shouldn't reach?

6:06:40And most importantly, what happens to a number that came from nowhere?

6:06:44What happens when a fact comes from nowhere?

6:06:47And how do I actually handle these kinds of hallucinations?

6:06:51So this whole platform is actually to make a very simple statement, very obvious,

6:06:58which is we can have the smartest models in the world.

6:07:01We can hit some crazy cool piece of technology,

6:07:04but we still have the same database problems that we've had from the beginning.

6:07:10which are, I cannot, if I search through a row

6:07:15and that value doesn't exist, I won't get a retrieval back.

6:07:18We're now out of the search phase of AI.

6:07:21We need to be building infrastructure.

6:07:23We need to be building scaffolding and harnesses and substrates,

6:07:26or whatever the cool VC term is these days,

6:07:28that actually enable us to make use of this technology.

6:07:31So this is my challenge and my ask to all of you.

6:07:35I hope you go out there and build something compelling,

6:07:37but I hope you build something compelling that you can trust.

6:07:40Thank you.