CHAPTERS
- 0:00 – 2:15
Building “super intelligence” at YC: the goal and the people behind it
The episode opens with a big question—how to build super intelligence inside a company—and introduces the core idea: AI shouldn’t just assist individuals, it should become a shared layer that captures and compounds organizational knowledge. The hosts set up Pete Koomen’s role as the architect of YC’s internal agent infrastructure and why YC is sharing this publicly now.
- •AI as a foundational “building layer,” not just a copilot
- •Recording artifacts as the prerequisite for compounding intelligence
- •The vision of a shared organizational brain
- •Pete’s background and mandate: building YC’s internal AI/agent infrastructure
- 2:15 – 5:04
The finance workflow bottleneck that sparked YC’s internal agents
Pete traces the origin of YC’s agent infrastructure to a concrete internal pain: finance workflows that required engineers to repeatedly translate complex processes into deterministic software. The team’s insight was to give domain experts (like finance) a way to encode workflows in natural language rather than depending on engineering cycles.
- •Classic inefficiency loop: finance explains → engineers implement → iterate
- •Agentic tooling (and agentic coding) made the old approach feel obsolete
- •Goal: shift software control toward non-technical domain experts
- •Prompts/English as a new interface for encoding workflows
- 5:04 – 7:31
SQL access as the first real unlock (and the “break the rules” moment)
They describe the first “magic moment”: giving agents the ability to run read-only SQL and inspect model/schema files. What started as narrowly-scoped tools became dramatically more powerful once the agents could query real production data, revealing how capability jumps when constraints loosen.
- •Early internal tools evolved from single-purpose to general agent loops
- •Tool registry as the backbone for work-specific capability
- •Read-only SQL + model file access enabled meaningful business Q&A
- •Security caution vs. real-world effectiveness: ‘it worked extremely well’
- 7:31 – 10:03
One database to rule them all: why unified context changes everything
YC’s biggest structural advantage is that key operational knowledge lives in one Postgres database spanning companies, founders, finances, and internal notes. With this centralized context, agents can answer broad, arbitrary questions about YC—making it easy to explore data without specialized BI workflows.
- •YC runs much of its business on internal software, not scattered SaaS
- •A single schema enables agents to reason across the whole organization
- •Agents can answer questions that used to require hours of SQL/BI work
- •Unified context increases not just speed, but the ambition of questions asked
- 10:03 – 13:18
Jevons paradox for analytics—and why legacy orgs need agent-optimized context
The discussion connects easier querying to Jevons paradox: reducing the cost of asking questions causes the volume and complexity of questions to explode. They then address how legacy companies can move faster—often by consolidating and reshaping data into forms optimized for retrieval and agent use.
- •Reduced friction leads to dramatically more curiosity and exploration
- •Removing cross-team backlogs changes organizational behavior
- •“Bigtable” analogy: consolidating context can beat brittle integrations
- •Denormalization for agents: reformatting data for retrieval + reasoning
- 13:18 – 15:26
From single-player agents to multiplayer organizations: the missing harness
Pete argues we’re still in the “single-player era,” where agents are powerful on one person’s machine but not yet fully solved at team/org scale. The YC project focuses on building the organizational primitives that let many people safely share tools, context, and agent outputs.
- •Most popular harnesses are designed for individual use on a local machine
- •The hard unsolved problem: “multiplayer” agents for teams/orgs
- •Org-scale success requires shared context and shared primitives
- •Central context layer behaves like a monorepo for agent productivity
- 15:26 – 18:20
350+ tools and a shared registry: turning agents into real workplace systems
YC’s internal tool registry becomes the key scaling mechanism: teams continually add tools whenever they find workflows that can be improved. The result is a large, shared library of capabilities that can power internal agents and also be exposed to local agent harnesses.
- •Tool registry is where ‘YC-specific usefulness’ lives
- •Evolution from ~20 tools to 350+ as teams contribute organically
- •Tools span core operations: finance, events, scheduling, CRM-like tasks
- •Shared registry lets both internal agents and local harnesses reuse tools
- 18:20 – 20:02
Resolvers, Skillify, and keeping the system DRY/MECE as it grows
Garry connects YC’s tool registry concept to “resolvers” and “skills” across different ecosystems (Claude Code, OpenClaw, Hermes). The key organizational challenge becomes maintaining a clean, non-duplicative capability layer—one good tool with parameters beats many overlapping tools.
- •Skills as abstraction layers over tools; registries as resolvers
- •Meta-workflows: create a skill from successful work, then validate it
- •DRY + MECE as practical constraints for scaling a skill/tool library
- •Parallel discovery of shared primitives across agent ecosystems
- 20:02 – 25:07
The self-improving dream cycle: nightly learning from every conversation
They describe an autonomous feedback loop: a general agent reviews employee agent conversations nightly to identify improvements and missing context. This “dream cycle” turns everyday usage into training data for better prompts, better skills, and smarter organizational behavior.
- •Progression: manual prompts → skills → agents writing skills (meta-prompting)
- •Nightly review of conversations to find mistakes and missing context
- •Dream cycle turns organizational usage into continuous improvement input
- •Transcripts and artifacts become fuel for compounding capability
- 25:07 – 32:20
The two-sentence pitch skill: capturing partner intuition and compounding it
A concrete example of organizational skill capture: YC’s “two-sentence description” coaching becomes a shared agent skill. By feeding real meeting transcripts and feedback into the system, the skill improves beyond any single partner’s ability—illustrating how ‘super intelligence’ emerges from aggregation and iteration.
- •Two-sentence description: clarity (what is it?) + why it matters (why interesting?)
- •Encoding partner judgment into a reusable skill/prompt
- •Using group office-hours transcripts to improve the skill via meta-prompting
- •Superintelligence mechanism: many tiny skills improved continuously across the org
- 32:20 – 39:23
Recording everything → the shared organizational brain (and why trust is required)
They broaden from one skill to a general organizational strategy: record meetings, artifacts, and workflows so agents can help people learn and perform like the best “star players.” YC also made a bold cultural choice: agent conversations are broadly visible internally, which improves learning and acts as a social control layer in a high-trust environment.
- •Artifacts (meetings, docs, transcripts) become reusable building blocks
- •AI raises the floor for new employees by accelerating ramp-up and apprenticeship
- •Default internal transparency: conversations broadcast for collective learning
- •High-trust, egalitarian culture becomes a functional requirement for org-scale agents
- 39:23 – 40:45
“Horseless Carriages”: why AI-native software flips control to the user
Pete explains his essay’s critique: many products bolt AI onto deterministic software, keeping prompts and context hidden from users. The better future is the reverse—agents orchestrate deterministic tools, shifting power from developers to end users and enabling flexible, user-shaped workflows.
- •Most AI features are ‘AI-in-a-box’ inside traditional software
- •Hidden prompts/context keep user control artificially limited
- •AI-native pattern: agent wraps tools, not software wrapping an AI
- •Framing AI as empowerment rather than replacement
- 40:45 – 46:29
Chat as the best agent interface and the rise of just-in-time software
They argue chat wins because it’s closest to human language and thought, and it supports multimodal inputs (voice, images, files). This leads to “just-in-time software”: instead of building massive rigid apps, the agent can generate the exact UI/view/workflow needed in the moment, then turn it into a reusable skill.
- •Chat reduces UI overhead when users trust the agent’s decisions
- •Multimodality makes chat a flexible universal interface
- •Just-in-time software: generate purpose-built views/tools on demand
- •Minimal code scaffolding + strong models can replace large app complexity
