Personal AGI: Garry Tan on Owning Your Intelligence Instead of Renting It

Personal AGI is an AI agent that runs on infrastructure you control, reads a memory you own, and executes procedures you wrote. At Startup School 2026, Y Combinator CEO Garry Tan argued it already exists as markdown files and scheduled jobs, and put his own output at roughly 400x his 2013 baseline.

Video Summary and Key Insights

Garry Tan, President and CEO of Y Combinator, delivered a 42-minute keynote to roughly 7,000 people at Startup School 2026. He frames the talk around Baruch Spinoza, the 17th-century philosopher excommunicated at 23, who ground optical lenses by day and wrote The Ethics by night. Tan's argument: everyone is waiting for AGI as a single announcement, when the useful version already arrived quietly as a terminal window and a folder of markdown files. He walks through the system he runs his own life on, gives a five-step build guide, and closes on who legally and practically owns the skill files that encode your judgment. The core claim is that model weights are a rented commodity while your accumulated context is the only part nobody can copy.

Key Insights:

• Tan estimates his 2026 output at 400x his 2013 baseline, and pre-emptively deflates his own number. In 2013 he shipped about 14 useful lines of code a day building Bookface, YC's internal social network, which he notes is dead on the median for programmer productivity research. He then applies what he calls a pathological verbosity penalty and lands on 8x as the absolute floor.

Everyone is watching the sky, and the thing they're watching for is already in the room.

• A quarter of YC's Winter 2025 batch had codebases that were 95% AI generated. That batch is on track to be one of the fastest-growing and most profitable in YC history. Tan is careful here and says explicitly that he cannot prove causation, only that the fastest-growing founders treat AI as a workforce rather than autocomplete.

• The differentiator is context, not weights. Tan's claim is that the multiplier lives in which information reaches the model and whether it arrives at the right step, not in the model itself.

There are 2x people and there are 100x people using the same Claude, same weights, same context window size, same API.

• His personal knowledge base holds about 220,000 markdown pages covering 25 years. Email, meetings, notes, photos, drafts, and the things he got wrong, compiled and curated mostly by agents. His stated rule: never re-answer a question you've already answered.

• A skill file is one page of plain English, and the test for a good one is whether a smart intern could follow it. Tan showed a real SKILL.md on stage. Non-engineers at YC now write them, including a finance staffer who compiled roughly 100 Excel workbooks into a single internal app.

• Every agent failure Tan has seen comes from confusing latent-space work with deterministic work. Taste and judgment belong in the model. Arithmetic and scheduling belong in SQL and scripts that the markdown calls. Startup School's own 6,000-person session scheduling was built exactly this way.

• gstack, his open-source agent coding framework, passed 123,424 GitHub stars, putting it in the top 100 open-source projects in GitHub's history. Both it and gbrain are free and MIT licensed.

• The final third of the talk is explicitly political. Tan argues a skill file is a piece of your cognition made executable, and that the same file produces two opposite futures depending on whose repository it lives in.

Own your skills, because if you don't, your job becomes a skill file.

Why I Watched This Talk Twice

I build retrieval infrastructure for a living, so I came in expecting to disagree with a YC keynote about personal AGI. Most talks in this genre are a product pitch wearing a philosophy costume. This one isn't, mostly because Tan open-sourced the entire stack before giving it, which removes the usual incentive to overstate.

What kept me watching was the second half. The first 20 minutes are a well-produced argument that agents plus your own context beat agents alone, which is not news to anyone who has built a retrieval-augmented system. The last 15 minutes make a claim I hadn't heard framed this cleanly: that writing down how you work is now an act with property-rights consequences. I've pulled the parts that hold up under scrutiny and flagged the two places where I think the numbers deserve more skepticism than the room gave them.

This talk also pairs with Tan's CS153 lecture on AI-native companies. That one covers company structure. This one covers the individual operator.

What Is Personal AGI, and How Is It Different From an AI Subscription?

Personal AGI, as Tan defines it, is general intelligence for one person rather than artificial general intelligence for everyone at once. The distinguishing property is ownership: the agent runs on your infrastructure, reads memory you control, and executes procedures you wrote.

He is specific about what it is not, because the phrase "personal AI" has already been claimed by marketing departments. A chatbot you pay $20 a month for doesn't qualify. Neither does a better autocomplete, nor an assistant that knows your calendar and nothing else.

One of these is a product you consume. The other is an asset you build.

The distinction has teeth. A rented assistant improves when its vendor ships. A personal system improves every day you use it, because every day it holds more of your life. Tan's blunt version of the failure mode: when the company behind your assistant pivots, "your so-called assistant gets a lobotomy on someone else's schedule."

The idea isn't new, and Tan credits its origin properly. Vannevar Bush described the memex in his 1945 Atlantic essay "As We May Think" as a device holding all of an individual's books, records, and communications, consulted at speed. Eighty years later the storage and the retrieval are trivial. The part that stayed hard is deciding what deserves to be stored.

What's the Equation Behind a Personal AGI?

Tan reduces the architecture to three terms: a frontier model, your context, and a harness that wires them together. Only the middle term is yours.

The model is rented, commoditized, and getting cheaper every quarter. The harness is interchangeable, and he names four: OpenClaw, Hermes Agent, Claude Code, and Codex. Your context is the only term nobody else on earth has.

This is the part of the talk I'd underline for anyone building AI products. The commoditization argument cuts against most current positioning, where companies differentiate on which model they wired up. If Tan is right, that's the term with the shortest half-life. We see the same pattern in search infrastructure: the retrieval mechanism is table stakes, and what matters is whether the corpus is worth retrieving from.

Tan borrows Steve Jobs' framing of the computer as a bicycle for the mind, then pushes it: with the three terms assembled, you have a self-driving rocket. It's the one moment of hype in an otherwise carefully hedged talk, and he earns it back immediately by conceding that the whole thing degrades into noise without curation.

Why Is Your Library More Important Than Your Model?

Human working memory holds about seven items, a limit established by George Miller's 1956 paper in Psychological Review. A frontier model holds a million tokens, roughly a thousand pages. Tan's visual is three Harry Potter books open at once versus a seven-digit phone number.

Then he runs the number the other direction, which is the more interesting move. A thousand pages is a lot, but your life is not three books. Your life is a library: every email, every meeting, every decision and the reasoning behind it.

That reframes the engineering problem. The question stops being how big the context window is and becomes who decides which three books are open on the desk. Tan's answer is that the system needs both halves, the library and the librarian, which is what gbrain is meant to be.

His own instance runs a Karpathy-style knowledge wiki of roughly 220,000 markdown pages spanning 25 years. One caveat worth flagging: the public gbrain repository currently describes a smaller corpus than the figure quoted on stage, so treat 220,000 as his personal instance rather than anything you can verify from the open-source release.

The daily output is concrete. Overnight his agent processes the inbox rather than sorting it, separating founders in trouble from vendors from the 17 mailing lists he never unsubscribed from. He wakes to a briefing. Before each meeting there's a prep document covering who he's meeting, what was said last time, what changed, and what to ask.

The screenshot he showed is worth pausing on, because it's an unusually honest artifact for a keynote. It's a real briefing from an agent he calls Wintermute, and it includes the agent reminding him that he had committed to building these very slides the previous day. The system is visibly nagging its owner about the talk you're watching.

What Is a Skill File, and Why Does Tan Say Markdown Is Code?

A skill file is a single page of English describing one job precisely enough that someone new could execute it. Tan's test: if a smart intern could follow it, an agent can run it.

He put a real one on screen, lightly redacted. It's a meeting-ingestion pipeline triggered when a transcript arrives: save the raw transcript, create the meeting page, pull out every commitment with its owner and deadline, cross-check every person named against the library, and link their pages in both directions.

The step Tan skipped past verbally is the most useful one on the slide. Step 4.5 is a claim verification gate, and the reasoning written into the file is sharp: "Summaries are two lossy layers deep: transcription, then summary. Both layers confabulate. Never write a role change or a major life event without verbatim transcript support. If anything contradicts something we already believe, flag it, don't overwrite it."

That's a well-designed guard against a real failure mode. Anyone who has built a summarization pipeline has watched a model quietly promote someone to CTO because a transcript garbled a sentence. Encoding "flag, don't overwrite" as a hard step is the kind of detail that separates a working system from a demo. It's the same discipline that shows up in well-written Claude Code skills, where the constraints matter more than the capabilities.

If you can write clear instructions in English, you're a programmer. The compiler is a language model.

Tan acknowledges he caught flack for the "markdown is code" line before and doubles down. The supporting evidence is the non-engineers: YC's media, events, and finance staff now write skill files and scheduled jobs. One finance colleague folded about 100 Excel workbooks into a single app built with an internal agent. His description of her: not a programmer, a manager of agents.

On top of the library sits gstack, his agent coding framework.

At 123,424 stars, gstack sits in the top 100 most-starred repositories ever published on GitHub. Tan's summary of what's actually inside: skill files plus a browser the agents can drive. Pages of English, and a way to act on the world. His phrase for the design is "fat skills, thin harness," which is the opposite of how most agent frameworks are built.

Latent Space or Deterministic Code: Where Should Computation Happen?

Tan claims every agent failure he has seen traces back to one question: where is the computation happening? There are exactly two answers, and mixing them up is the bug.

His example is drawn from the event the audience was sitting in. Seating five people is a latent-space task. Building custom schedules for 6,000 attendees is not, and the agent has to write code to track it. Startup School's own scheduling ran as markdown files calling a SQL database.

The line I'd put on a wall: "The model fails where we fail. The fix is having the model compute the way humans compute." We reach for a calculator rather than doing long division in our heads, and agents need the same escape hatch. This is the practical core of the talk, and it generalizes past personal setups into any agent architecture where reliability matters.

Tan's own receipt for the combined system is the talk itself. Five days before the keynote he decided it needed Spinoza, so his agent acquired three biographies (by Nadler, Goldstein, and Stewart, about 1,500 pages), read all three overnight, and produced a dated chronology, every point where the biographers disagree, verbatim quotes with chapter citations, and the ten most tellable moments ranked with delivery notes. The knife attack, the bribe, and the desk all came out of that run. He calls it a compendium skill and uses it daily.

How Do You Build Your Own Personal AGI in Five Steps?

Tan's build guide takes six minutes of the talk and is the most immediately usable section. His framing: do these and you'll be ahead of 99% of people who watch the talk and just nod.

1. Tonight, pick a harness and run an agent on your own machine. He uses OpenClaw and Hermes Agent with gbrain, hosted free at gbrain.io. His own caveat is generous: "I always recommend the Ferrari, but the Honda is really good too." Codex or Claude Code will do 99% of this, with less roadside maintenance.
2. This weekend, start your library. Not an archive, one folder of markdown files. Export your notes and email. Write one page per project and per person, covering what you're building together, what they care about, what you owe them, and what they said last time.
3. Write your first skill file. Pick the weekly task you hate most. Explain it in plain English the way you'd brief a smart friend on their first day. Let it get things wrong, then correct it and put every exception back into the file.
4. Wire it up as a recurring job. Every morning at seven, do this. Every Friday, summarize that. Tan claims the first time you wake to finished work, the day stops being your unit of work.
5. Never do one-off work. At the end of every task, ask the agent to skillify what it just did into a reusable markdown file.

Step five is the one most people will skip, and it's the one Tan says separates compounders from dabblers. His YC formulation: "If you have to ask for something twice, you failed."

Nobody builds the warehouse first. First you build one shelf.

He's honest about the timeline, which I appreciated more than the 400x number.

Week one is a toy: the library is thin, the skills are clumsy, and you fix more than you save. Week four the flywheel catches. Week twelve you have a library that answers before you finish asking and a dozen skills running the parts of your week you used to dread. Most people quit in week two, which he says is exactly why the ones who don't feel like they're cheating by week twelve.

The caveat he volunteers before the how-to is the single most important sentence for anyone actually building this.

A brain nobody curates is a garbage dump with great search.

Retrieval will surface a stale fact with total confidence, and a bad skill file encodes a bad process forever. His prescription is memory plus hygiene: provenance on every fact, contradiction checks when new information collides with old, and a librarian whose actual job is pruning. Treat it like production infrastructure or accept a confident agent that's wrong in ways nobody can trace.

Who Owns Your Skill Files, You or Your Employer?

This is where the talk turns, and where it stops being a productivity keynote. Tan's argument: a skill file is not a document, it's a piece of your cognition extracted from your head, written down, and made executable.

His illustration is explicitly fictional, which he states plainly. A support engineer he calls Maya spends two years teaching her agents 40 skills: triaging a P0 at 2am, de-escalating a customer about to churn, writing a post-mortem that prevents the next incident. Forty files holding two years of judgment.

In version one the files live in Maya's repository. She changes jobs and they go with her, so day one at a new company she operates with years of compounded judgment on tap. In version two they live in the company's repository under company IT policy. She leaves with nothing, the company keeps running her judgment without her, and her name isn't in the commit history. Tan's phrase: "She didn't have a career. She had an extraction."

The historical parallel he draws is the sharpest thinking in the talk. Craftsmen owned their tools, and that ownership is what made them free. The factory broke that, because the loom belonged to the mill. Knowledge workers assumed they were safe because their tools lived in their heads where nobody could confiscate them. Skill files end that assumption. For the first time, cognition can be extracted, stored, versioned, and owned by someone else.

He ties it back to Spinoza's thousand guilders, the annual stipend the community offered the 23-year-old to show up occasionally and keep quiet. Tan's reading: that offer never went away, it just got rebranded as any comfortable arrangement where your judgment compounds in someone else's repository.

I think this is right, and I also think it's underspecified. Most employment contracts already assign work product to the employer, and a skill file written on company time describing a company process is not obviously yours to take. Tan's advice to keep your brain in a repository you control from day one is sound, but the legal question he raises is genuinely open rather than settled in the individual's favor. He doesn't claim otherwise, though the framing invites you to assume it.

What Are the Strongest Objections to Personal AGI?

Tan pre-empts three objections rather than waiting for them, and gives the third the most respect.

Retrieval is easy. Being worth retrieving from is the product.

The RAG answer is the one I'd defend hardest. Having built retrieval systems, the embedding and the vector search are the parts you can finish in a week. Deciding what enters the corpus, keeping provenance attached, and resolving contradictions is the multi-year problem. Calling retrieval a primitive rather than a product is accurate.

The security answer is the weakest of the three, and I say that as someone sympathetic to it. "Custody is the security model" is a good line, but custody assumes competence. Most people are worse at operational security than a well-funded vendor's security team, and Tan's rebuttal, that trusting someone else's terms of service isn't better, sidesteps rather than answers that. The honest position is that self-hosting shifts the risk rather than removing it, and whether that's an improvement depends entirely on the operator. This is the same trade-off that shows up whenever teams weigh self-hosted agents against managed platforms.

Why Did Garry Tan Open Source gstack and gbrain?

Tan says people keep asking because they assume there's a catch. His first answer is that being at YC means he doesn't need to monetize his own infrastructure. His second is the one he actually cares about: tools of the powerful should be given away.

His framing is that every era has a private technology of advantage. For a long stretch it was literacy, then it was capital, and right now it's the harness, the library, and the workforce made of markdown. The people who have it operate at a different scale than the people who don't, and he claims the gap widens monthly.

The structural point underneath the slide is that a resolver acts as an org chart. A task arrives and the resolver decides which markdown file handles it. Which means, as Tan puts it, that before you incorporate anything, before a co-founder or a logo or a deck, you can already run an organization of one plus your agents. It's a cleaner articulation of the same idea running through other agent orchestration systems.

When something that powerful stays private, you get a priesthood. When it gets given away, you get a renaissance.

For evidence that the new math produces different companies, he cites two from the YC portfolio. Emergent went from public launch to nine figures of revenue in eight months and was at 15 people when it crossed $15M annualized. Retell AI, from the Winter 2024 batch, reached roughly $60M annualized with about 40 people, a figure independent analysts also put near $60M in April 2026. His claim about that revenue-per-person ratio is that it didn't previously exist in software, oil, or railroads.

The talk ends where it started. Spinoza's estate inventory listed two pairs of pants, seven shirts, a lens lathe, 160 books, and The Ethics locked in a desk. Tan's reading: he owned almost nothing, and nobody ever controlled his skill files. The desk drawer was his repository.

All things excellent are as difficult as they are rare. The difficulty just collapsed. The rarity is now up to you.

Frequently Asked Questions

What is personal AGI?

Personal AGI is Garry Tan's term for general intelligence serving one person rather than artificial general intelligence arriving for everyone at once. It's an AI agent running on infrastructure you control, reading a memory you own, and executing procedures you wrote. Tan distinguishes it from a subscription chatbot on one property: a rented assistant improves only when its vendor ships, while a personal system compounds every day you use it.

Is Garry Tan's 400x productivity claim credible?

Tan estimates his 2026 output at about 400x his 2013 baseline of 14 useful lines of code per day, and he deflates the figure himself on stage. Applying what he calls a pathological verbosity penalty, assuming half the agent output is scaffolding, he lands on 8x as an absolute floor with the middle of the range around 80x. Lines of code is a weak productivity proxy in either direction, so treat the floor as the defensible number.

What is a skill file?

A skill file is a single markdown page describing one job in plain English, precisely enough that someone new could execute it. Tan's test is whether a smart intern could follow it. A real example he showed handles meeting ingestion: transcribe with speaker labels, extract every commitment with its owner and deadline, cross-check named people against the knowledge base, and flag contradictions rather than overwriting them.

What are gstack and gbrain?

Both are Garry Tan's open-source, MIT-licensed projects. gstack is his agent coding framework, at 123,424 GitHub stars as shown in the talk, placing it in the top 100 most-starred repositories in GitHub's history. gbrain is the knowledge layer, the library plus the librarian, designed to run behind OpenClaw and Hermes Agent deployments. A hosted version is available free at gbrain.io.

What's the difference between latent space and deterministic space in agent design?

Latent-space work is taste, judgment, and reading intent from a vague request, which lives in the model and is steered by a markdown file. Deterministic work is arithmetic, SQL queries, and constraint solving, which lives in tools and scripts the markdown calls. Tan says confusing the two causes every agent failure he has seen. Seating five people is latent; scheduling 6,000 people across an arena requires the agent to write code.

Why does Garry Tan say markdown is code?

Because the compiler is now a language model. If you can write clear instructions in English, Tan argues, you're programming. His supporting evidence is that non-engineers at YC, including media, events, and finance staff who never open a terminal, now write skill files and scheduled jobs. One finance colleague compiled roughly 100 Excel workbooks into a single app built with an internal agent.

Who owns skill files, the employee or the employer?

Tan's position is that they should belong to the individual, and his warning is that "if you don't own your skills, your job becomes a skill file." He illustrates it with a fictional support engineer whose 40 skill files represent two years of judgment: in her own repository they travel with her between jobs, in the company's repository she leaves with nothing. The legal reality is less settled than the framing suggests, since most employment contracts already assign work product to the employer.

How long does it take to build a useful personal AGI setup?

Tan's stated curve is 90 days. Week one is a toy where you fix more than you save. Week four the flywheel catches and the agent starts answering with your context. By week twelve he claims you have a library that answers before you finish asking, a dozen skill files handling the parts of your week you used to dread, and one or two tools other people ask to borrow. He notes most people quit in week two.

Key Takeaways

• Personal AGI is defined by ownership, not capability. The agent runs on your infrastructure, reads memory you control, and executes procedures you wrote. Tan's test for the difference: a product you consume versus an asset you build.
• The equation is a rented frontier model plus your owned context plus an interchangeable harness. Model quality is a commodity getting cheaper each quarter, and the context term is the only one nobody else can copy.
• Tan's 400x productivity claim has a self-imposed floor of 8x. He volunteers the deflation on stage, which makes the floor more useful than the headline. A quarter of YC's Winter 2025 batch had 95% AI-generated codebases, though he explicitly declines to claim causation.
• A skill file is one page of English that a smart intern could follow. The real example he showed included a claim-verification gate that flags contradictions rather than overwriting them, which is the detail that separates a working pipeline from a demo.
• Every agent failure Tan has seen comes from confusing latent-space work with deterministic work. Judgment belongs in the model; arithmetic and scheduling belong in SQL and scripts that the markdown calls.
• Curation is the binding constraint, not storage. "A brain nobody curates is a garbage dump with great search." Provenance on every fact, contradiction checks, and a librarian whose job is pruning.
• The ownership argument is the most original part and the least legally settled. Craftsmen owned their tools; skill files make cognition extractable for the first time. Tan's advice to keep your brain in a repository you control from day one is sound regardless of how the contract question resolves.
• gstack and gbrain are both free and MIT licensed. At 123,424 stars, gstack is in the top 100 most-starred projects in GitHub history, and Tan's stated reason for giving it away is that tools of the powerful should be given away.

This post is based on Garry Tan: Own Your Intelligence (42:08) by Y Combinator, recorded at Startup School 2026. An official transcript is published on the YC Startup Library.