Video summary

The New Physics of Business — Garry Tan, Y Combinator

Main summary

Key takeaways

Business

Core thesis (business/execution focus)

Garry Tan argues that the main leverage of AI in business isn’t model quality—since many teams have access to similar models, weights, or APIs.

Instead, leverage comes from how you “wire the work”: turning company functions into an AI-native operating system.

The “new physics” of business

A thin team using agent-based org design can achieve ~hundreds-of-times output per person, because agentized workflows replace many layers typically handled by large org structures (e.g., sales, ops, support, finance, compliance).

Key frameworks / playbooks mentioned

1) Skill files = employees

A skill file encodes a single capability/job clearly enough to execute. In effect, it turns hiring/training outcomes into reusable workforce modules.

2) Resolver table = org chart / routing

Incoming tasks are routed to the right skill and workflow path.

3) Filing rules = internal processes

Defines how work is handled for compliance and standardization, including:

  • Whether results require compliance checks
  • Where outputs are stored
  • How outputs are standardized

4) Trigger evals = performance reviews / tests

Automated checks in the form: “When X happens, does Y get loaded?” Used to ensure process correctness.

5) No one-off work rule → “skillify it”

If an agent solves something, convert the outcome into a reusable skill file. Mantra: “If you have to ask for something twice, you failed.”

6) Company brain = (library + librarian)

Not just retrieval (RAG), but includes:

  • What gets written into the knowledge base
  • Enrichment and linking
  • “Hot vs cold” memory promotion
  • Arbitration when facts conflict
  • Pruning/curation to prevent stale “garbage” with high-confidence errors

7) Context engineering / working memory

Humans can hold about 7±2 items; agents can hold millions of tokens. Business implication: decide which “three books” (retrieved context) get loaded at decision time.

Concrete examples / case studies

YC Winter 25 batch

  • ~25% of companies had codebases that were 95% AI-generated
  • Claim: the batch became YC’s fastest-growing and most profitable (causality not proven, but a strong observed correlation)

Revenue scale examples

  • 94 YC companies have crossed $100M+ revenue (seed-check origin referenced)

Examples of AI-native builders:

  • Emergence (Summer 24): Public launch → nine figures ARR in 8 months with ~15 people by $15M ARR

  • Retail (Winter 24): ~$60M with ~40 people

YC internal transformation (ops + finance)

  • Staff previously dependent on spreadsheets/terminal work now:
    • build skills + cron jobs
    • use internal tools to collapse manual processes
  • Example: one finance person collapsed ~100 Excel workbooks into a single app (agent/assistant-built), shifting from manual operator to manager of agents

Key metrics / KPIs and quantitative claims

Founder productivity / output leverage

  • 2013: Garry produced about 14 usable logical lines of code/day
  • Present: ~400x output with similar person/hours (with less time lost to personal constraints)
  • Even with conservative assumptions (e.g., bloated code/scaffolding), claims range:
    • 8x (floor) to 80x (middle)

Batch coding automation

  • Winter 25: 25% of companies had 95% AI-generated codebases

ARR / revenue-per-head (indicative)

  • Emergence: 9-figure ARR in 8 months; 15 people at $15M ARR
  • Retail: $60M with ~40 people

Working memory concept (capacity KPI)

  • Human working memory: ~7±2 items
  • Agent working capacity: million-token scale (roughly “a thousand pages”)
  • KPI implication: the decision determinant becomes which subset is loaded at each moment

Actionable recommendations (what to do next)

Build an AI-native org from day one

Shape the company around:

  • skills + resolver + processes + evals + company brain

Convert agent work into reusable assets

After each successful agent task:

  • skillify it so it becomes part of the workforce
  • avoid one-off work that doesn’t compound

Engineer the “where computation happens”

Split responsibilities:

  • Latent space: LLM judgment, ambiguity resolution
  • Deterministic space: structured compute, exact routing/scheduling, assignment/storage logic outside the LLM context

Example: clustering/seating should use the LLM for human-like judgment, while deterministic compute handles assignment/storage outside the context window.

Treat memory/knowledge as production infrastructure

Prevent failure modes such as:

  • stale/incorrect facts with high confidence
  • “fossilized” skill/process errors

Add:

  • provenance for each fact
  • contradiction checks
  • a human+agent librarian that prunes and curates

Focus retrieval on value

The differentiator isn’t just retrieval speed, but how knowledge is produced, curated, and arbitration-managed.

High-level investing/markets mention (minimal)

Tan frames this as a platform for funding and building the next generation of companies (YC), highlighting the “battlefield” where teams show which can operationalize AI-native architectures fastest.

Presenters / sources

  • Garry Tan (Y Combinator)

Original video