# AI Agents Will Upend Investing Even More Than Coding - Frank Long, Coatue

Frank Long, Coatue

[Talk page](https://ai.engineer/talks/AYFcmnQrZCg-ai-agents-will-upend-investing-even-more) · [Video](https://www.youtube.com/watch?v=AYFcmnQrZCg)

## How Korean Chip News Could Shape a Portfolio Decision at Coatue

Frank Long of Coatue makes his case for agents in investing by tracing one research task from collecting Korean-language semiconductor coverage to judging whether the firm should change what it owns.

### A hedge fund returns three things

[0:12](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=12s)

At Coatue, a technology investment firm active in public and private markets, an investor has to take a high-conviction bet on a theme and watch how it plays out. Frank Long thinks career decisions work much the same way. When he joined Coatue the previous year, his bet was that agents would have an even bigger impact on investing than they had on coding. To see where that impact might come from, he starts with what an investment firm actually produces.

Long writes a hedge fund as a function of two parameters, external context and internal context. It returns one tuple, `(selection, size, timing)`. Which stock? How much? When? A correct call on a company leaves two of those questions open. The firm has to compress everything it knows about the world and its own circumstances into all three answers. Its product, in this formulation, is a time series of those tuples. Successive decisions construct the portfolio.

### Give agents access to the evidence investors use

[1:31](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=91s)

Long’s access principle starts with the investor’s screen. Anything a person at the firm can see in pixels, an agent inside the firm should be able to retrieve through an API. Imagine hiring the greatest investors alive and giving them computers without logins to 75 percent of the services they need. Their intelligence would do little to remedy the missing access. The same limitation applies to an agent that depends on somebody dragging in a filing or copying and pasting a news story. News, prices and filings should all be directly accessible.

![A monitor displays a line chart and a table. A dotted line connects it to three API calls for Samsung news, historical prices and filings, each paired with its output fields.](https://ai.engineer/api/talk-essay-media/7f6e8693c93d3fe5f11d4137f33611f5c658aaea57b494d1198bd8d204b646ec)

Everything a human can see in pixels, a model can see via API

The second input is specific to the firm. What position does it already hold? What liquidity or risk requirements apply to that name? What has the firm learned from earlier investments in the sector, the stock or the management team? Two investors can read the same external report and have different reasons to act. Even within one firm, the implications of a report depend on what the portfolio already contains.

Long credits a foundation that predates his arrival. Coatue’s data science team, processes and systems have brought information together for over a decade. A separate discipline made the internal record worth retrieving. For decades, people filed notes on trades, on decisions they made and opportunities they passed on, and on what went well or poorly. A holdings list can tell an agent that the firm owns no shares. A note on a decision to pass can tell an investor which earlier judgment to revisit.

### Gather evidence, form a view, then decide

[3:20](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=200s)

Access still leaves the compression problem. Long breaks the function into three steps. Gathering takes external and internal context and filters for relevant evidence. Analysis takes that evidence and forms a view about what it means for public or private markets. The decision step takes the view and produces the object with selection, size and timing. Each output becomes the input to the next step. This gives an engineer a place to look when a sound piece of evidence fails to influence a decision.

![Five rows pair investment-fund pseudocode with explanations. The function gathers information, analyzes it and returns selection, size and timing. Red annotations assign the decision and investment judgment to people.](https://ai.engineer/api/talk-essay-media/ab1b38809a1fbee0394394571d2f8773f01b2af2610e04d1bc04fe568bea3e32)

Break it down until each piece can be checked

Consider the judgment already embedded in gathering. An NBA story probably has little bearing on the stocks the firm follows. A local permitting story might matter considerably if the permit affects data centers. A filter that discards local coverage can lose the relevant fact before the analysis step gets a chance to interpret it. Long narrows the problem further to see what implementing even this first step entails.

### What reaches the model from a Korean news article?

[4:51](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=291s)

Semiconductors and AI had become major market themes, making Korean media coverage particularly valuable to a team Long describes as entirely non-Korean-speaking. Reading that coverage gives an LLM a concrete job. The first engineering decisions come before translation. The team could collect articles through MCP, use a CLI, or license a data feed and clean it. Whichever route supplies the article, someone still has to decide how to chunk it for the model and how to represent its images. Passing an image directly and converting it to text give the model different material to interpret.

Long treats those choices like hyperparameters in a traditional machine learning system. Each can be varied and evaluated. Filtration adds another choice. Korean outlets cover basketball too, so selecting sources by language gets the team only partway to the names and themes in its portfolio. Then comes the choice of what to hand over. A translation lets an investor read the article. A summary condenses it. Structured extraction pulls particular information into a form another step can process.

The team can cross-reference that output with its own notes, existing views, conversations or meeting recordings. That changes the question from what the article says to how it bears on something the firm already believes. Updating the view is conditional. Checking the evidence may give the investor reason to keep the existing view.

![Seven rows trace a research question through the gather function. Code collects articles and checks quotes. An LLM filters articles, extracts observations in English and proposes an update. A person accepts, revises or rejects it.](https://ai.engineer/api/talk-essay-media/3ba7ecdd1f2f0cf57df129daab58abf5d3889fa55ee01b7d0f50bb0a6f53591b)

Interpreting news from Korean media outlets

### Four kinds of runner, from a comparison to a management meeting

[7:15](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=435s)

Long calls whoever or whatever executes a step its “runner.” His example assigns a sequence of steps to code, LLM, LLM, code and person. The broader menu has four entries. The first is deterministic code. Given a price-to-earnings ratio and a rule requiring it to be below 15, a comparison implements the rule exactly. It is fast, cheap and reliable. The second is statistics or classical machine learning. Fitting a regression line to observations lets the team estimate a relationship whose shape it would otherwise have to specify in code.

The third runner is an LLM or AI agent. Summarization is Long’s example of a task where a modern model can handle variation in language that would defeat an attempt to enumerate cases with `if` statements. The fourth runner is a person. For a meeting with a company’s management team, Long would send someone who can exercise judgment and navigate the encounter as it develops. He chooses each runner to maximize the absolute quality of that piece of work. The share of steps assigned to LLMs tells him little about that result.

![Four columns pair a price-to-earnings rule with a black square labeled CODE, model fitting with a green diamond labeled ML, transcript summarization with a gray oval labeled LLM, and a CEO meeting with a red circle labeled PERSON.](https://ai.engineer/api/talk-essay-media/25daa1781d5680c9a2bf9c96a94fb1222aa379e84e7a0f1e01a7294a9febb4d9)

You need a runner

### Three routes through the same coverage

[9:26](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=566s)

The research question can change how the workflow branches as well as the order of its steps. If the investor needs to know exactly what someone said, one route is to collect the articles, translate them, extract quotations and check each quotation against its source. A fluent translation alone leaves an important question open. Did the person actually say what the extraction credits to them?

A second route begins by deduplicating coverage, then filters the remaining articles and pulls external figures. Its intermediate result is a set of figures from relevant coverage. A third route reverses the starting point. The investor supplies an internal note first and asks the system to find corroborating data points. The investor could also red-team the note, looking for evidence that challenges its reasoning. Long treats control flow itself as tunable. A change in the investor’s question can justify a different first input, a different sequence and a different test of the output.

### Evaluate a bounded task before changing its runner

[10:16](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=616s)

Some assignments are straightforward. Pulling the last 24 hours of articles from a given source is a well-specified collection job for deterministic code. Filtering that collection might use a decision model, an LLM, a statistical method or a combination. Long expects much of the real work to involve multiple runners. A person judging portfolio impact, for example, can use a deterministic system to search for and retrieve the evidence.

Even choosing an LLM leaves decisions about a small, medium or large model, the thinking effort, the harness, which skills the harness loads and which hooks load with those skills. Long’s way into that search space is to isolate a piece of work the team can understand and evaluate. Quote extraction has a source to check. Translating a statement into portfolio impact asks for a different judgment. If an LLM does the first job well and struggles with the second, the team can keep its extraction and put the impact decision with an investor. Without a criterion at that boundary, replacing an LLM with a trained filter or an `if` statement offers no way to tell whether the change helped.

### The research graph extends beyond investing

[12:15](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=735s)

Korean news is one source, and each source may need more than three transformations just to produce an intermediate result. Long sketches the scale as at least ten tunable choices per node, each with at least twenty plausible values. For engineers, the challenge is to lay out that graph so they can understand how the fund reaches a decision. For the firm, there is also the question of how to organize the work. Someone has to decide which judgments investors should make themselves and where a combination of people and software produces a better result.

![A flowchart combines Korean news, filings, call transcripts and internal notes into a proposal for review. Dashed arrows send mismatched quotes back for extraction, revisions back to the proposal, and review feedback back to internal notes.](https://ai.engineer/api/talk-essay-media/e9907a7a9ba00e56df1f4992022839705f39329e2f539dcb09ca1074ff88d563)

Investment research workflow from collection to review

Long sees the same design problem in policy, nonprofits, drug discovery and corporate strategy. In his terms, each is building a state machine that takes information from the world, interprets it in light of what the organization knows and uses it to make coherent decisions. Investing supplies an unusually compact expression of the final decision. Much of the work lies in deciding what evidence gets there.

## Key takeaways

- Expose external sources and internal decision records through APIs. Notes on investments the firm passed on can identify the original objection that new evidence needs to address.
- Specify what a research step must return. A source-checked quotation, a set of external figures and evidence that challenges an internal note each require a different route through the coverage.
- Choose runners against a test the team understands. Code can retrieve a day’s articles, an LLM can extract a statement, and an investor can judge its implications for position size and timing.

## Slides

### Everything a human can see in pixels, a model can see via API

[1:33](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=93s) [A monitor displays a line chart and a table. A dotted line connects it to three API calls for Samsung news, historical prices and filings, each paired with its output fields.](https://assets.ai.engineer/sites/aiecode2025/sha256/7f6e8693c93d3fe5f11d4137f33611f5c658aaea57b494d1198bd8d204b646ec.webp)

COATUE

Everything a human can see in pixels,
a model can see via API

A PERSON LOOKS AT

c_external
>>> news.search("Samsung", lang="ko")     [{title, source, time}, …]
>>> prices.history("005930.KS")           [{date, close}, …]
>>> filings.get("005930.KS", "Q3")        {revenue, op_margin, …}

### Break it down until each piece can be checked

[4:03](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=243s) [Five rows pair investment-fund pseudocode with explanations. The function gathers information, analyzes it and returns selection, size and timing. Red annotations assign the decision and investment judgment to people.](https://assets.ai.engineer/sites/aiecode2025/sha256/ab1b38809a1fbee0394394571d2f8773f01b2af2610e04d1bc04fe568bea3e32.webp)

COATUE
AI ENGINEER / NEW YORK

Break it down until each
piece can be checked

01  def fund(c_external, c_internal):               Takes external and internal context
02      info = gather(c_external, c_internal)       Gather information
03      view = analyze(info)                        Analyze it
04      selection, size, timing = decide(view)      Make the decision: a person
05      return selection, size, timing              People own the investment judgment

COATUE / AN INVESTMENT FUND AS A FUNCTION
03

### Interpreting news from Korean media outlets

[7:29](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=449s) [Seven rows trace a research question through the gather function. Code collects articles and checks quotes. An LLM filters articles, extracts observations in English and proposes an update. A person accepts, revises or rejects it.](https://assets.ai.engineer/sites/aiecode2025/sha256/3ba7ecdd1f2f0cf57df129daab58abf5d3889fa55ee01b7d0f50bb0a6f53591b.webp)

COATUE
AI ENGINEER / NEW YORK

Interpreting news from Korean media outlets
fund › gather

01  def gather(question, korean_news):                       One research question, one source
02      articles = collect(korean_news)              CODE    Originals, with source and time
03      relevant = filter(articles, question)        LLM     Against the question, with reasons
04      notes = translate_extract(relevant)          LLM     Sourced observations, in English
05      check(notes, against=articles)               CODE    Every quote matches its source
06      update = propose(notes)                      LLM     A new data point, or no change
07      return update                                PERSON  Accepts, revises or rejects it

COATUE / AN INVESTMENT FUND AS A FUNCTION
04

### You need a runner

[7:35](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=455s) [Four columns pair a price-to-earnings rule with a black square labeled CODE, model fitting with a green diamond labeled ML, transcript summarization with a gray oval labeled LLM, and a CEO meeting with a red circle labeled PERSON.](https://assets.ai.engineer/sites/aiecode2025/sha256/25daa1781d5680c9a2bf9c96a94fb1222aa379e84e7a0f1e01a7294a9febb4d9.webp)

COATUE

You need a runner

if pe < 15:
    keep()
CODE

model.fit(x, y)
ML

summarize(transcript)
LLM

meet(ceo)
PERSON

### Investment research workflow from collection to review

[10:28](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=628s) [A flowchart combines Korean news, filings, call transcripts and internal notes into a proposal for review. Dashed arrows send mismatched quotes back for extraction, revisions back to the proposal, and review feedback back to internal notes.](https://assets.ai.engineer/sites/aiecode2025/sha256/e9907a7a9ba00e56df1f4992022839705f39329e2f539dcb09ca1074ff88d563.webp)

COATUE
AI ENGINEER / NEW YORK

korean_news
dart_filings
call_transcripts

c_internal
our_notes

collect()
dedupe()     rank()
filter()     translate()
extract_quotes()     extract_figures()     entity_link()
check_sources()     compare_to_last_view()     key_stock_drivers()     compare_to_holdings()
propose()     review()

QUOTE DOESN’T MATCH
REVISE

COATUE / AN INVESTMENT FUND AS A FUNCTION
05

## Full transcript

[0:12](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=12s) My name's Frank. I work at Coatue, which is a technology investment firm across public and private markets. So, in our business, what you really need to do is be able to take high conviction bets on big themes and watch those play out. I think honestly a career is the same way, and last year when I joined Coatue, the bet that I wanted to make was I think that agents will have an even bigger impact in investing than they did at coding. I know that's a big statement. We're all here because of the transforma- transformative

[0:42](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=42s) impact that AI has had in coding, but I really believe it strongly, and today I wanna talk a little bit about the framework that we use to actually realize that impact. So at a high level, you can think about a hedge fund as a function that takes in two parameters, context external and context internal, and spits out one tuple, selection, size, timing. What stock, how much, when, right? And I think this is a

[1:12](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=72s) good framework to actually f- f- to ground our work, which is we're trying to solve this compression problem of how do you take all the information in the world and spit out this one simple tuple? And the product that we s- that we provide is essentially a time series of this tuple that constructs a portfolio. So let's start from the top, which is the inputs. Very simple philosophy. We use our screens, we look at stuff, we do work. Every single thing that a human can see in

[1:42](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=102s) pixels on the screen, an agent in your building should be able to see via API. Uh, the analogy I use is imagine you brought the smartest people ever, the greatest investors alive, and you brought them into your company, but you gave them a computer without logins to seventy-five percent of your services. It, it's almost immaterial how smart the system is if it doesn't have the tools to actually action that. So the two parts, external context, right? No surprises here. Think the news,

[2:11](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=131s) prices, filings, all of that should be easily accessible and not via dragging and dropping, copy and pasting, like directly via API. Internal context is just as important, right? So this is your own firm situation. So that might be our current positions, potential liquidity and risk requirements we have around certain names, and past case studies or, um, you know, history with a certain sector or

[2:41](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=161s) stock or management team. That stuff's all super important. So this is the foundation, and I think, uh, no credit to me, Coatue has been an amazing leader on this for over a decade. It's both technological and cultural. We have an amazing data science team, amazing, amazing processes, amazing, amazing systems that bring all this in. And just as importantly, we have a culture that is super, super rigorous and built from the ground up to capture all this insight. For decades, we filed every single note about every single

[3:11](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=191s) trade, about every single decision we made or didn't make, about what went well and what didn't go well, and that's poised us to expose this to AI.

[3:20](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=200s) So if you think about it, I probably can't just take all of those things, jam them into a context window, and get my magic three numbers and go home, right? It can't be that easy. You probably have to break down this function a bit further, right? So maybe the first step is I take in that external and internal context, and I gather it, right? I wanna gather it. I wanna filter out what's relevant and not relevant. Okay, well, I pulled some news articles about

[3:50](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=230s) the NBA. That probably isn't material to stocks. But, oh, well, this is actually related to some local permitting that might actually impact data centers. Like, there's a lot of nuance in this gather step. Um, then you'll see probably the next step is I need to analyze that information and form a view, right? I actually need to think about what that means for the markets, public and private. Uh, and then I need to take that view and turn it into a decision. A

[4:20](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=260s) decision object has these three parameters, right? These three sort of sub- sub pieces. So you can see every single step has an input and an output, and the input for the subsequent step is the output that the previous function generated. I think as an engineer, this is a way for me to conceptualize the problem in a way that makes a lot of sense. But even this, it, it really can't be as simple as writing three functions, right? So let's just--

[4:51](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=291s) to, uh, really appreciate the scope and understand the full complexity of the problem, let's look into the first step, a tiny sub-piece of a tiny sub-piece of just gathering information, and let's do a case study on interpreting the news, right? So it's probably no secret to you guys that, you know, news from Asia and Korean me- Korean media outlets has been super important this year because semis, AI have been a huge, huge theme in the

[5:21](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=321s) market. Huge theme. And I think this is an area where AI is poised to have a lot of impact is reading, uh, Korean language news better than our completely non-Korean-speaking staff, right? Uh, I think I have a good thesis that this might be a good use case. So you can imagine the first step is I have, uh, articles. I need to collect the articles, right? So this could be an MCP, this could be a CLI, license the data feeds, clean the

[5:51](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=351s) data feeds. There's actually a lot of ways to do this and a lot of dimensions of freedom for how you can even just write this simple piece. How do I chunk it? When I pass it to the LLM, do I want to pull the images as images? Do I want to pull the images and then turn the images into text? There's actually a lot of knobs here, and I almost think about those knobs as like hyperparameters in a traditional machine learning system, right? I think about each of these knobs as something for me to tune and optimize against.

[6:23](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=383s) Obviously, filtration, we talked about it. Um, Korean-- There are probably Korean NBA fans, right? There's probably a bunch of stuff that's not necessarily material to the, the names and themes and stocks in our portfolio that really, really matter, right? So I wanna make sure that I filter those out.

[6:45](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=405s) There's this, like, translate slash ex-extract slash should I summarize? Should I extract this into some sort of structured form? Again, so, so many ways to do this. So many ways to experiment how to expose information to the model, and one of the reasons this is hard is it keeps changing. And obviously checking. Checking, like, our own internal notes, our own, own internal views, potential conversations we've had, meeting recordings against these things. We actually need to cross-reference those things.

[7:15](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=435s) Actually, the idea of pulling information from disparate sources and cross-referencing them, that's super powerful. So you'll see on, on the right here, I have code, LLM, LLM, code, person. Uh, there's many, many ways to run these functions. I think about, uh... Oh, yeah, and finally, update. Potentially, we update, uh, our views. So there's many ways to run these functions. I think of each line as having, uh, a runner, and, uh, the most obvious one is

[7:44](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=464s) code. Code is very good. It's fast, it's cheap, it's reliable. So for something like if the prices to earnings ratio is less than fifteen, I should just use deterministic code for that. Runner number two is s-statistics, classical machine learning, and you can imagine fitting a line to a regression for a specific pattern. This is very powerful because you can model much more complex relationships than just pure deterministic code, right?

[8:15](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=495s) And for even more complex relationships, the reason we're all here, LLMs, AI agents, that's another type of runner, right? So for something like summarization, that's the state-of-the-art, right? Uh, it's probably totally impossible to build a d-- bunch of if statements that can summarize better than a model-- modern LLM. And of course, uh, people. People are important runners in the system, right? So, uh, imagine a function meetings the management team of a company. I probably don't

[8:46](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=526s) wanna send-- I mean, I like the new unitary robots, but I probably don't wanna s-send an LLM or an AI agent in to do that. I probably don't wanna send an if statement into that meeting. I think there's many cases where, because of judgment and the ability to navigate the real world and all of these things, a person is the best runner for a given piece of the function. And I think this is, like, a super, super important point. There is no glory in automating things for the sake of automating things. The goal is not to take as many things and make them LLM as

[9:16](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=556s) possible for us. The goal is, for any given piece of this function, what can I do to maximize absolute quality?

[9:26](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=566s) And if you actually think about the function, it probably looks something like this. It's probably not just a linear statement of a bunch of different things. There's probably all kinds of branching logic and all kinds of ways to actually fork this. So maybe I wanna collect the information and then translate it, and my main goal is to extract quotes and check those against sources to make sure that these are actually the p-- things that people said, and, and that's my approach. But that might be totally wrong. Maybe actually what I wanna do is I wanna dedupe, and then I wanna filter, and then I want to

[9:56](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=596s) pull external figures, or maybe I wanna do something totally different. I actually want to-- I'm passing in a note first, and I actually just wanna find other confirmatory data points, or maybe I'm trying to red team. Uh, there's a million different ways to configure this. So yet again, more hyperparameters within the control flow, right?

[10:16](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=616s) So, so many ways to think about just this very simple problem of pulling, filtering, summarizing, aggregating the news for LLMs. And each of these boxes probably has an optimal runner, right? So, um, the optimal runner might be deterministic code for collection, right? I'm pulling last twenty-four hours for a given source. That's deterministic code. Filtration,

[10:46](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=646s) decision models, maybe LLMs, statistical methods, a combination, right? So this probably understates the complexity. The reality is most things are multi-runner. Most things have deterministic code plus LLM plus statistical method or a human with LLM in conjunction. Um, the reality is this-- it's probably combinatorics between my four buckets, and there's even more buckets than that because within the LLM category, I can tune the model. I can

[11:16](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=676s) choose big model, small model, medium model. I can tune thinking effort, X high, high, medium. I can tune harness. I can choose the harness. I can choose which skills load with the harness. I can choose which hooks load with the skills. So yet again, more hyperparameters within my search space. I have an absolutely enormous amount of hyperparameters within my search space. And this is just for this one tiny problem, right? Of just filtering the news. So the way, uh, to think about breaking down these problems is what can I

[11:45](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=705s) actually compartmentalize in a way that we can understand and evaluate? 'Cause that's what I'm hill climbing against, right? Otherwise, I'm just tuning these things. I'm, "Okay, well, that should actually be a machine learning system instead of an LLM. That should be a little model that we train. Oh, no, that sh-- actually shouldn't be a model at all. That should be an if statement or-" Oh man, LMs are really, really bad at translating that to portfolio impact. It should really be a human on that step, but they're using a deterministic system to help them search and pull the information. It could be all different things,

[12:15](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=735s) right? And if you don't have a North Star to hill climb against, you're just kind of, uh, you're just fidgeting around. And I think I cannot convey enough that this is just one tiny thing we do. Imagine every single data source that we pull in, there's probably more than just three transformations to get them to the intermediate output. So the actual graph of Coatue and funds like Coatue, it actually probably looks... Oh, not like this. Uh, this is my screensaver.

[12:46](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=766s) The actual graph probably looks something like this, right? It's probably massively complex. In each of those nodes, we just talked about at least 10 hyperparameters with at least 20 different valid values for them. So the search space is, is basically infinite. And figuring out how to actually lay this out in a way that you can comprehend, both from technical perspective, but also absorb culturally, organizationally, that is the great challenge of applying AI in

[13:15](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=795s) investing. And beyond investing, what we're really talking about is creating a state machine that can take information from the world and understand it well enough to make coherent decisions. There's use cases for this far and above, uh, wider than just investment firms, in policy, in nonprofits, in drug discovery, in corporate strategy. I think one of the most exciting things for me about being in forums like this is talking to other people in dis- different

[13:45](https://www.youtube.com/watch?v=AYFcmnQrZCg&t=825s) spaces with different problems that kind of congeal on the same problem space. I'd love to keep talking about this. I'll hang out in the hallway afterwards. Here are my socials, and thank you everyone for your time.
