AI Engineer

Closing Keynote: Garry Tan, Y Combinator

2227 summary words 10 min summary Watch video

Start with the signal

10 min read

Summary

At-a-Glance

  • Verdict: Watch fully
  • Core thesis: AI-native companies achieve extreme leverage not merely by using better models, but by encoding organizational capabilities as reusable agent skills, routing work deliberately, separating probabilistic judgment from deterministic computation, and maintaining a curated company brain.
  • Why it matters: The talk directly supports Ken's OpenClaw, agent-orchestration, context-engineering, and control-plane work with a practical organizational model, concrete failure modes, and an investment thesis around persistent memory infrastructure.
  • Best use: Use it as an architecture checklist for AI-native operations and as a rubric for identifying startups that compound proprietary workflows and context rather than simply wrapping foundation models.

Executive Summary

Garry Tan argues that the productivity gap between ordinary and exceptional AI users is primarily an orchestration gap, not a model gap. He says people producing 2x and 100x gains often use the same models, APIs, context windows, and cloud infrastructure; the difference is whether they treat AI as autocomplete or as a managed workforce. His own benchmark moves from roughly 14 usable logical lines of code per day in 2013 to a claimed 400x raw increase today, which he estimates remains 8x to 80x after aggressive adjustments.

His central operating model maps agent infrastructure directly onto organizational design: a skill file is an employee with a defined capability, a resolver table is an org chart that routes tasks, filing rules are internal controls, and trigger evaluations are performance reviews. An AI-native company therefore keeps a thin human team, encodes repeatable work as skills, and assigns engineers to maintain and improve those skills rather than repeatedly performing the underlying tasks.

Tan separates agent computation into latent space and deterministic space. Models should handle taste, judgment, ambiguity, and human intent, while code and structured systems should hold state, enforce constraints, and execute computations that must be reliable. Above both sits the company brain: a curated library plus a librarian that retrieves the right context for each task. Retrieval alone is insufficient because stale facts, contradictions, weak provenance, and bad procedures can make agents confidently wrong.

The compounding discipline is to never leave successful work as a one-off interaction: once an agent produces a satisfactory result, convert the process into a reusable skill. Tan sees company brains, personal context systems, and the librarian layer that selects relevant knowledge as open startup territory. He presents G-Brain as an open-source example, while emphasizing that the operating concepts are portable across OpenClaw, Codex, Hermes, or other agent harnesses.

Key Takeaways

  • Claim: Extreme agent productivity comes from how work is wired and managed, not simply from access to superior model weights. | Evidence: Tan compares his approximately 14 usable logical lines of code per day in 2013 with a claimed 400x raw output increase today; after discounting generated code for verbosity, scaffolding, and self-flattery, he estimates a floor of 8x and a midpoint of 80x. He also says one-quarter of YC's Winter 2025 companies had codebases that were 95% AI-generated. | Implication: Ken should evaluate agent systems by workflow architecture, delegation quality, and completed outcomes rather than model choice or token throughput alone. | Caveat: The productivity calculation is self-reported and based heavily on code volume, which does not directly measure correctness or business value. Tan explicitly says he cannot prove that AI-generated code caused the batch's growth or profitability.
  • Claim: Agent infrastructure should be designed as an organization with explicit roles, routing, controls, and evaluation. | Evidence: Tan maps a skill file to an employee, a resolver table to an org chart, filing rules to internal process, and trigger evaluations to performance reviews—for example, testing whether tests.md is loaded whenever an agent needs to alter a test file. | Implication: OpenClaw and related systems should expose organizational primitives such as capability definitions, task routing, policy enforcement, and routing-compliance evaluations rather than functioning only as general-purpose chat interfaces.
  • Claim: Reliable agents require an explicit boundary between probabilistic reasoning and deterministic execution. | Evidence: Tan assigns taste, judgment, vague human intent, and other nondeterministic decisions to the LLM's latent space, while placing state, constraints, and exact computation in code. His example is clustering and seating 800 Startup School attendees: the model can make human-style matching judgments, but the multidimensional seating arrangement should not live only in the context window. | Implication: Ken should treat latent-versus-deterministic placement as a first-class architecture review: judgment belongs in models, while durable state, validation, permissions, and hard constraints belong in software and databases. | Caveat: The talk provides the design principle but not a detailed implementation for resolving conflicts between model judgments and deterministic constraints.
  • Claim: The decisive context-engineering problem is selecting the right subset of organizational knowledge for each task. | Evidence: Tan contrasts human working memory of roughly seven items with an agent context window of about one million tokens or approximately 1,000 pages, likened to three Harry Potter books. Because a company is a library rather than three books, he defines the company brain as both the library and the librarian that chooses which material enters context. His personal G-Brain reportedly contains about 220,000 pages drawn from email, meetings, 20 years of notes, and agent-generated material. | Implication: For Ken's systems, retrieval quality should be evaluated as a context-selection and knowledge-governance product, not treated as a commodity RAG component. | Caveat: The size of the corpus does not establish retrieval quality; Tan's own argument is that a large uncurated repository can become a garbage dump with good search.
  • Claim: Persistent memory is useful only when paired with hygiene, provenance, contradiction handling, and active curation. | Evidence: Tan identifies three failure modes: retrieval can surface stale information with confidence, bad skill files can preserve bad processes indefinitely, and an uncurated brain can become untraceable institutional garbage. He calls for provenance on every fact, contradiction checks when new information conflicts with old information, and a human-plus-agent librarian responsible for pruning. | Implication: Any production company-brain deployment needs lifecycle controls for freshness, source lineage, conflict resolution, deletion, and skill versioning before it can safely become operational memory.
  • Claim: The core compounding practice is to convert every successful agent interaction into a reusable organizational capability. | Evidence: Tan's rule is, "If you have to ask for something twice, you failed." After iterating with an agent until the output is satisfactory, he says to "skillify" the task by converting the procedure into a skill file that can be loaded and executed again. | Implication: Ken should measure agent maturity by the rate at which validated one-off work becomes reusable, tested, governed automation—not merely by daily agent usage. | Caveat: Automating a flawed or poorly reviewed process compounds error just as effectively as it compounds good practice.
  • Claim: Company brains and personal-context librarian layers are a major startup opportunity, while the underlying operating model should remain tool-agnostic. | Evidence: Tan describes G-Brain as an MIT-licensed, open-source retrieval layer that works with multiple harnesses and calls it effectively "Postgres for agents." He recommends OpenClaw as the "Ferrari" but says Codex is a capable "Honda" that can perform about 90% of the job, emphasizing that skills, context selection, and reusable work travel across stacks. | Implication: The defensible opportunity is less likely to be a thin harness wrapper and more likely to reside in memory governance, context arbitration, workflow assets, evaluations, integrations, or proprietary organizational knowledge. | Caveat: The 90% comparison is rhetorical and no benchmark or capability breakdown is supplied.

Detailed Brief

AI-native operations extend beyond software engineering

  • Claims: Tan says the organizational transition applies to media, events, finance, support, sales, and operations—not only to engineers.; In this model, nontechnical employees become managers of agents, while technical staff maintain skills and handle work the encoded procedures cannot yet perform.
  • Evidence: A YC finance employee who had never been a programmer reportedly collapsed roughly 100 Excel workbooks into one application using YC's internal OpenClaw and company brain.; Tan says YC staff who had never opened a terminal are now creating skill files and cron jobs.
  • Caveats: The talk does not address access control, segregation of duties, auditability, or data-security requirements for finance and other sensitive functions.; No before-and-after accuracy, labor, or cycle-time measurements are provided for the finance example.
  • Implications: The highest-leverage deployment surface may be operational knowledge workers with fragmented spreadsheets and repetitive procedures, but these functions also require stronger governance than coding demos typically show.; Agent adoption changes job design: domain experts increasingly specify, supervise, test, and improve automated procedures rather than execute every procedural step themselves.

Revenue-per-head examples support the thesis but remain directional

  • Claims: Tan argues that the first AI-native startups are demonstrating revenue per employee that was previously unavailable because they encode functions instead of scaling each function through headcount.; He presents these companies as early examples of a new operating model rather than isolated outliers.
  • Evidence: He says Emergence, described as an AI app builder from Summer 2024, reached nine figures of ARR within eight months of public launch and had only 15 employees when it crossed $15 million in ARR.; He says Retail, from Winter 2024, reached $60 million with approximately 40 employees.; He states that 94 YC companies have crossed $100 million in revenue after beginning with a YC seed check.
  • Caveats: The transcript does not define whether the figures refer to booked, run-rate, or recognized revenue, and it supplies no independent verification.; The examples do not isolate how much of the performance came from agent-native operations versus market timing, product demand, capital, pricing, or other factors.
  • Implications: Revenue per employee is a useful screening signal for AI-native organizational leverage, but diligence should inspect the actual workflow architecture and revenue quality before attributing performance to agents.

Memory as owned infrastructure rather than rented intelligence

  • Claims: Tan distinguishes foundation-model capability, which every customer effectively rents, from accumulated organizational memory and procedures, which a company can own and compound.; He argues that nearly every historical institution was designed around limited human working memory, leaving greenfield room for organizations built around much larger machine context.
  • Evidence: For founder-crisis emails, Tan says his agent retrieves prior conversations with that founder, comparable crises from three portfolio companies, and what worked before he finishes reading the incoming message.; He cites a father who assembled approximately 80,000 markdown files about his son's rare epilepsy as an example of a domain-specific library paired with focused retrieval.
  • Caveats: The keynote does not discuss consent, privacy, licensing, retention, or the risks of using sensitive email, meeting, medical, and portfolio-company data in persistent agent memory.
  • Implications: The long-term asset is the governed combination of context, procedures, corrections, and decision history, not the interchangeable model endpoint beneath it.; Sensitive-domain memory products will require policy and trust infrastructure to be as central as retrieval performance.

Notable Concepts & Terms

  • Skill file: A written, reusable capability that functions like an employee with one clearly defined job; it is the basic unit of Tan's agent-native organizational model.
  • Resolver table: A routing mechanism that decides which skill or context handles an incoming task; Tan treats it as the agent equivalent of an org chart.
  • Trigger evaluations: Tests that verify whether the correct skill or context is loaded under the intended conditions, analogous to performance reviews and process-compliance checks.
  • Latent space: The probabilistic model layer used for judgment, taste, interpretation, ambiguity, and understanding human intent.
  • Deterministic space: Code, databases, and structured systems used for persistent state, exact computation, validation, and hard constraints.
  • Company brain: A persistent organizational knowledge library plus the retrieval and governance systems needed to make that knowledge useful to agents.
  • Librarian: The human-plus-agent function that selects task-relevant context, resolves contradictions, tracks provenance, and prunes stale information.
  • Skillify: The practice of converting a successfully completed one-off agent task into a reusable, testable skill so the organization retains what it learned.

Operator Notes / Why Ken Should Care

  • Create an architecture review template that forces every agent step to be classified as latent judgment, deterministic execution, state storage, or policy enforcement.
  • Instrument resolver behavior: record which skills and documents were loaded, whether routing was correct, and which failures came from missing context versus faulty execution.
  • Define a production memory schema with source provenance, timestamps, confidence, supersession rules, contradiction flags, retention policy, and deletion support.
  • Assign explicit owners and review cadences to high-impact skill files; do not allow finance, security, customer communication, or deployment skills to become ownerless automation.
  • Pilot skill capture in one repetitive, spreadsheet-heavy internal workflow and measure cycle time, correction rate, human review time, and reuse frequency before scaling.
  • Compare G-Brain with other memory layers on retrieval precision, freshness, permission filtering, traceability, and harness portability rather than corpus size alone.
  • For investment diligence, ask founders to demonstrate their resolver, skill library, evaluation suite, memory hygiene, and revenue per employee rather than accepting an 'AI-native' label.
  • Treat the keynote's productivity and revenue figures as thesis-generating claims that require independent verification before they become operating benchmarks.

Source/Metadata

  • Title: Closing Keynote: Garry Tan, Y Combinator
  • Transcript words: 3942
  • Duration seconds: 1268
  • Timestamp note: No timestamps or chapters were present in the supplied transcript. The provided duration is 21:08, and several passages are duplicated in the transcript extraction.
Full transcript 3359 words · 17 min read
0:00

[SPEAKER_00] Okay, great.

0:12

SPEAKER_00

Hey everyone, how's everyone doing? All right, are we ready for the revolution? Okay, Theo just asked the right question. What do we build now? I'm going to answer it from the other side of the table. I'm a founder, I'm an investor, and I run a 20 year old institution that is becoming AI native right now, which is a strange and wonderful thing to do to a 20 year old institution. And I'll spend about 20 minutes talking about what YC is. We're trying to build companies where one person does what it took one person to do what used to take a thousand people. And I don't mean that as a metaphor. I mean that mechanically this year. The people in this room will do this.

0:43

SPEAKER_00

In about an hour, some of you will walk into the startup battlefield, and I want you to walk in knowing what's actually possible right now. Because what is possible now is much, much bigger than what people believe. So let me start with a number, and I got torn apart on the internet for this, but I'm going to say it again in front of all of you anyway. This is the one room in the world that will stress test it, and I'd rather stress test it with you myself. In 2013, I was a YC partner building the internal social network at YC. I was also investing in companies, but I was also a near full-time engineer.

1:02

SPEAKER_00

And when I was doing that, I could do about 14 usable logical lines of code a day. Take out the comments, take out all the bullshit, and that's how many lines of code I was writing. And if you look at the literature from that era, that's normal. Some people write 15, some people write 50. It was not the thousands of lines of code that I know a lot of you in this room are actually writing now per day. That's about median 15. That was me at full effort at that time. This year I run YC full-time, same person, same hours, actually way less hours, weirdly. But I have a 5 p.m. kid pickup now, and I did the math on my output, and it's about 400x.

1:26

SPEAKER_00

Now before the skeptic in the third row right there deflates the number for me, let me deflate it myself. If you don't trust the raw code, well fine. Take the most pathological verbosity penalty you can stomach, and assume the agent writes bloated code. Assume half of it is scaffolding. Assume I'm flattering myself. It's still 8x at the floor and 80x in the middle. That number is large, no matter how you torture it. And here's the part that matters, the part that I tattoo on the inside of everyone's eyelids if I could. It's not the model. The 2x people and the 100x people are using the exact same cloud, same weights, same context window, same API.

1:55

SPEAKER_00

So the leverage is not in the weights. It's in how you wire the work. And it's not just me at YC. We see this all the time. In the winter 25 batch, a quarter of the companies had code bases that were 95% AI generated, and that was a year ago. That batch has become the fastest growing, most profitable batch in the history of YC. 94 companies total have now crossed $100 million in revenue from a seed check in the history of YC. So I think we know what we're talking about here. And I can't prove that the AI generated code caused the growth, but what I can tell you is the fastest growing founders we fund are not treating AI as auto complete.

2:18

SPEAKER_00

They're treating it as a workforce. The companies that wired the work differently are the ones that are bending the curve. So what does wiring the work really mean? This is the heart of the talk. And this is what I most want you to steal. Everything we've learned building with agents maps to an organization. I have no slides. I'm sorry. A skill file is an employee. It has one capability, one job, written down clearly enough that someone can execute it. A resolver table, the thing that many of you, when you run into cloud code and it says your context is too big in cloud.md, you run off and create a resolver table.

2:50

SPEAKER_00

Well, whenever you need to alter a test, load tests.md, you have a whole table of these things. That's an org chart. A task comes in and the resolver decides who handles it and where it goes. Filing rules are your internal process. So whether or not the resolver is actually working and is it actually in compliance. And trigger evals. So going in and actually having a test that says when I need to alter a test file, does test.md actually get loaded? Those are performance reviews. What have we done? Every part of an organization, the organization that you used to have to hire a thousand people for, I just told you what those things are.

3:17

SPEAKER_00

They're markdown files and other types of markdown files. And maybe there's some TypeScript in there too. We've been building organizations this whole time, but we didn't have a management layer. But now that's what we have. We have a lot of work that we have. When you sit down with Cloud Code or Codex, you're not writing software. You're hiring, training, and managing a workforce made of markdown. And there are tons of companies at YC that are doing this. Emergence and AI App Builder out of summer 24. They went from public launch to nine figures of ARR in eight months. When they crossed 15 million dollars ARR, they were only 15 people.

3:48

SPEAKER_00

And maybe there's some TypeScript in there too. We've been building organizations this whole time, but we didn't have a management layer. But now that's what we have. We have a lot of work that we have. When you sit down with Cloud Code or Codex, you're not writing software. You're hiring, training, and managing a workforce made of markdown. And there are tons of companies at YC that are doing this.

4:11

SPEAKER_00

Emergence and AI App Builder out of summer 24. They went from public launch to nine figures of ARR in eight months. When they crossed 15 million dollars ARR, they were only 15 people.

4:22

SPEAKER_00

Retail out of winter 24, it's at 60 million dollars with about 40 people. That kind of revenue per head did not exist before. Not in software, not in oil, not in railroads, never.

4:31

SPEAKER_00

These are not freaks of nature. They're just the first companies built natively on the new physics. And so, how do companies like that actually run? Not by hiring hundreds of people for sales, support, ops, and finance. The AI native companies that I see inside YC encode all of that as skills, written procedures that their agents execute. And they hire engineers whose job it is to maintain those skills, to do the work the skills can't do yet. That is an AI native company. And it's not a thought experiment. It'll actually file your taxes if you have a skill file for it. Now, picture YC's batch room. It actually looks like this. 400 companies or 400 founders at long tables.

5:13

SPEAKER_00

And I can imagine every single one of you, each at a laptop, every single day, you're doing a former person's entire year worth of work in a single day. That's not the future. That's actually the bar right now. And if you're not doing it, your competitor is, and they will eat your lunch politely and thank you for it. So, here's the extension most engineering talks miss. It's not just the engineers. At YC, as we make our transformation, it's our media people, our event staff, our finance team. People have never opened a terminal in their lives are building skill files and cron jobs.

5:41

SPEAKER_00

One of our finance folks just collapsed about 100 Excel workbooks into a single app she built with our internal OpenClaw and company brain. She's not a programmer. She's a manager of agents now. And everyone at YC now is. So, that's why YC can run at the scale it does with a staff that would look like a rounding error at any other comparable firm. And that's not because we work harder. It's because we have a different type of org. And that's the whole game.

6:10

SPEAKER_00

It's not just 400X engineers. It's one company that operates at the level of 400X everyone else. And so, if you remember only one thing about this, this is one of the things I had to discover along the way. You actually have to be really careful about where the computation is actually happening. It's happening almost always in two different places. And all of the bugs, all of the AI engineering that we run into that's a problem, it's usually because something is happening in one side of the equation that should be in the other. The first area is latent space. So, the actual LLM. What do you use it for?

6:44

SPEAKER_00

Taste, judgment, understanding what a human actually wants when they say something vague. The non-deterministic calls, the computation that lives in the model and you steer it with the markdown file. And then deterministic space is what engineers know. Your code agents go off and write TypeScript or maybe they're writing Erlang if you're using Elixir. Deterministic space is the second place. This is a real problem that we have for startup school coming up. We have 6,000 people or we're going to try one of the experiments we're going to try is can we seat 800 people at a time, perfectly clustered.

7:12

SPEAKER_00

So, the person sitting to the left and the right of you is the perfect person for you to meet at startup school. We have to do that in deterministic space combined with latent space. This computation, this actual storage of where everyone is inside this multi-dimensional array of 800 seats, it actually must not live in the context window. The LLM has to do the human part and seat people. It's exactly what you would do if you were a human tasked with this thing. You would probably have to physically print out 800 pages and go into a big room and say, well, where does this person go?

7:35

SPEAKER_00

Only now it can all happen in your computer and it can, instead of taking a month, it might be able to happen with a couple hundred dollars worth of tokens and probably 10 minutes. And so, I would argue that's pretty remarkable. These are things that you couldn't do even six months ago. And so, which brings me to working memory and that's my favorite way to understand it. You and I, human beings, we only hold about seven things in our head at once. Seven plus or minus two. It's one of the most famous papers in cognitive psychology. And it's why local phone numbers are seven digits and why you forget the eighth item on your grocery list.

8:07

SPEAKER_00

And that's the entire working memory, generally, of a human being. And every institution humanity has ever built, every checklist, every org chart, every filing cabinet is a prosthetic for that limit. It's a wild thing to think about. But an AI agent holds a million tokens. That's about a thousand pages. I was trying to explain to my 10-year-old what G-Brain was recently. I said, the AI agent can keep about three Harry Potter books sitting open in its head all at once. And it can find a needle in any of them and synthesize across all three in seconds. And that's quite magical, actually. Three Harry Potter books versus seven digits. That's pretty awesome. Is that AGI?

8:43

SPEAKER_00

Maybe not. But it's already a very different operating regime. Almost every company on the earth is still running an org that's designed for the seven-digit brain. I said, there's the AI agent can keep about three Harry Potter books sitting open in its head all at once. And it can find a needle in any of them and synthesize across all three in seconds. And that's quite magical, actually. Three Harry Potter books versus seven digits. That's pretty awesome. Is that AGI? Maybe not. But it's already a very different operating regime. Almost every company on the earth is still running an org that's designed for the seven-digit brain. But notice what that also tells you.

9:37

SPEAKER_00

Three books is a lot, but it's also very little. Your company is not three books. Your company is a library. Every email, every meeting, every decision, it's reasoning, every customer conversation, every post-mortem. And it's not a good question. The question that determines whether your agents are geniuses or goldfish is who decides which three books are open on that desk. That's context engineering. And this is what a company brain is. It's the library plus the librarian. Now, some of you are already thinking, this is just rag. And you're right that retrieval is the primitive, the same way Postgres is just B-trees. The hard part is everything around it.

10:44

SPEAKER_00

What gets written down in the first place into the knowledge wiki. How it gets enriched and linked. What gets promoted to hot memory versus filed as cold reference. Who arbitrates when two facts disagree. Retrieval is easy. Being worth retrieving from is the product. So, I've been building mine in the open. It's called G-Brain. It works with any harness, but it loves OpenClaw and Hermes agent. It's effectively Postgres for agents. A retrieval layer whose job is to figure out for any task what three books should be loaded into the agent's head. My personal one started as a rooms full of books or so. Now, it's a warehouse, about 220,000 pages, written mostly by my agents.

11:43

SPEAKER_00

From my email, meetings, 20 years of notes, and the lived experience of me. And that's the point. It's my second brain. And when a founder emails me about a crisis, before I start reading this, before I even finish reading that email, my agent has already pulled every prior conversation with that founder, three portfolio companies that hit the same wall. And what actually worked for those people? When my agent does anything, it does everything knowing what I already know. And that's the difference between an assistant and a colleague. So, let me stress test my own pitch, because you would anyway. Company brains do have failure modes.

12:15

SPEAKER_00

A brain nobody curates becomes a garbage dump with great search. Retrieval will surface a stale fact with total confidence. A bad skill file encodes a bad process forever. That's bad. So, the primitive is not memory. It's memory plus hygiene, provenance on every fact, contradiction checks when new information collides with the old. And a librarian, human plus agent, whose actual job is pruning. Treat the brain like a production infrastructure and it compounds. Treat it like a dumping ground, and you get a very confident agent that is wrong in ways nobody can trace. And here's the discipline that I think personally makes our company brain and my personal AI compound.

12:54

SPEAKER_00

That's my signature move. And, it's what I say to every YC company and everyone inside YC, which is never do one-off work. You can open open claw. You can open your harness. You do some work. But then when you're happy, and it'll come back. It's a bad job. It's like an intern that's not that good. But the great thing is you can just say, hey, I didn't like that. Fix it, right? I'm sure all of you do this. But don't stop there. You actually need to, at the end of that task, skillify it. And so, I have a blog post on X about that.

13:35

SPEAKER_00

You can search for skillify it and go get that skill file and then just load it into your harness and it'll just turn whatever you just did into a skill that you can reuse. Because if you have to ask for something twice, you failed. So, if you remember only one thing, it's that. Use your AI agent and then when you're done with it and you're happy with the output, skillify it. It's going to be awesome. The organization that captures what it learns like this gets smarter every single day. The one that doesn't wakes up every morning with amnesia, no matter how good the model is. Model quality is rented, but if you build your brain, you own that brain.

14:12

SPEAKER_00

So, Theo's question head on. What do we build now? Build the AI native company, not a company that just uses AI. A company that is shaped like what I just described from day one. A thin team, skill files for everything, the founder still in the code, library, this library, this company brain, your personal AI. Use Gbrain if you'd like. It's open source and free, but you don't have to. There are a lot of really good ones. The library will compound from the first week and your whole org will be wired to run at about 400x.

14:47

SPEAKER_00

And if you want the green field, the thing that I'd build if I were 25 and sitting where you're sitting, every company on this earth is about to need a brain. The memory layer that means that you never have to re-ask what you knew. Personal AI that actually knows you. We're building Gbrain in the open and MIT open source. I'm not trying to make money from this because I think the layer should be open the way Linux is open. But the layer itself, company brains, personal context, the librarian that picks the three books, that's all wide open territory. I hope somebody builds the defining company here. And I'd like to fund you at YC if you do.

15:24

SPEAKER_00

Now let me be honest in a way that maybe undercuts my own pitch. You don't need my tools to start. OpenClaw is the Ferrari. I will always recommend it. But Codex is a really good Honda. It will do 90% of this. I'm not trying to make money from this because I think the layer should be open the way Linux is open. But the layer itself, company brains, personal context, the librarian that picks the three books, that's all wide open territory. I hope somebody builds the defining company here. And I'd like to fund you at YC if you do. Now let me be honest in a way that maybe undercuts my own pitch. You don't need my tools to start. OpenClaw is the Ferrari.

15:56

SPEAKER_00

I will always recommend it. But Codex is a really good Honda. It will do 90% of this. It will not blow your face off, but it will get you there. Use whatever. The concepts are the point, not my repos. Think about where the computation is. Use skill files as employees. Use the librarian. Never do one-off work. Those travel with you to any stack. So let me land this. A lot of people in the world right now are terrified about what happens to all the jobs. And I understand the fear. But I want to say it plainly. That is a failure of imagination. And the people in this room are the answer to it. What I just described, you're going to take to your startup.

17:04

SPEAKER_00

You will multiply yourself and every person in your company will multiply themselves. And you will go build the companies that become the beacon for how all of this works in society. Abundance is not a policy paper. It is shipped software. I have a friend who has a rare form of epilepsy. He built a repo of 80,000 markdown files, a company brain for one small boy. And he pushed himself to the absolute edge of what humanity knows about his son's exact condition. No lab, no grant, no permission. A father, a laptop, and a library. That's not a side story. That is the exact architecture I've been describing for the last 20 minutes.

17:48

SPEAKER_00

A library, the librarian, the right three books open at the right moment, pointed at the thing this man loves the most in the world. You can do that now. Every problem where you thought, I wish I had that person, but I can't get them. Every code base you thought was too buggy to fix, you can fix all of it. Every archive too big to read. Every data set too gnarly to clean. Every ocean you were told not to boil. We can boil the ocean now. And every single one of you can fly. Not metaphorically, mechanically. And you need to, to survive, to thrive, to win. Theo asked what we should build now. And here's the whole answer.

18:17

SPEAKER_00

Build that AI native company and build it, build the thing underneath it. The brain, the memory, the compounding library. That makes every company after yours easier to build. Go boil the ocean. Go write that test. Go ship that skill. Some of the companies you're about to watch in the battlefield are already doing this. Go build the one that does it best. Thank you. What I just described, you're going to take to your startup. You will multiply yourself and every person in your company will multiply themselves. And you will go build the companies that become the beacon for how all of this works in society. Abundance is not a policy paper. It is shipped software.

18:59

SPEAKER_00

I have a friend who has a rare form of epilepsy. He built a repo of 80,000 markdown files, a company brain for one small boy. And he pushed himself to the absolute edge of what humanity knows about his son's exact condition. No lab, no grant, no permission. A father, a laptop, and a library. That's not a side story. That is the exact architecture I've been describing for the last 20 minutes. A library, the librarian, the right three books open at the right moment, pointed at the thing this man loves the most in the world. You can do that now. Every problem where you thought, I wish I had that person, but I can't get them.

19:43

SPEAKER_00

Every code base you thought was too buggy to fix, you can fix all of it. Every archive too big to read. Every data set too gnarly to clean. Every ocean, you were told not to boil. We can boil the ocean now.

20:11

SPEAKER_00

And every single one of you can fly. Not metaphorically, mechanically. And you need to, to survive, to thrive, to win. Theo asked what we should build now. And here's the whole answer. Build that AI native company and build it, build the thing underneath it. The brain, the memory, the compounding library. That makes every company after yours easier to build. Go boil the ocean. Go write that test. Go ship that skill. Some of the companies you're about to watch in the battlefield are already doing this. Go build the one that does it best. Thank you. Thank you. Thank you. Thank you.

21:00

Thank you.

21:04

Thank you. Thank you. Thank you.

Reading tools

Type to find a passage

Appearance
Ask this transcript

Add a note