The Gap YC Spent a Year Closing: Turning Individual AI Superpowers into Company-Wide Capability

Many people already use AI, and they use it well. But zoom out to the whole company and little has changed: individual productivity is up, while the organization still works the same way.

YC is Silicon Valley's best-known startup accelerator. It spent a year on a single problem. Today, the AI inside the company reads every conversation across the company each night and becomes more useful the next day. How was this system built? Pete, a YC partner, has now publicly explained the full structure for the first time. Broken down, it has five layers, and any company can copy them.

An Awkward Gap

Pete noticed an awkward gap.

When he uses Claude Code on his own laptop, it feels like having a superpower. But back at the company, finance still has to close the books and register funding rounds. To do that, they first explain the requirement to engineers, who build software and hand it back; then the cycle starts over.

His idea was simple: let finance write the process down in English, hand it to an agent, and take engineers out of the loop.

Behind that is a larger judgment: there is a big gap between how individuals use agents and how organizations use them, and no one has really mastered it yet. What YC did this year was close that gap.

The system they built is actually simple—just three things: an agent that can work on its own, a tool library, and multiple models underneath that can be swapped. The complexity lies in the five layers that grew around those three.

Layer One: Data—Let the Agent See It First

The first layer is data.

Jared, a YC partner, felt the available data wasn't enough, so late one night he quietly shipped two tools: one that runs read-only queries against the production database, and one that reads the database schema files. The results were surprisingly good.

The reason isn't complicated. Nearly all of YC's business runs on software it built itself, with data in a single database: every company it has invested in, every founder, every deal, and the notes partners leave in the CRM. As long as the agent knows the schema, it can answer anything.

Now you can ask offhand: which investors are behind the aerospace companies from the last four batches? Before, that meant writing SQL for hours and waiting in line for the data team.

Once the barrier dropped, people asked more questions and dared to ask harder ones. Even finance colleagues without a technical background could ask directly.

So what should a company do when its data is scattered across dozens of SaaS tools? Gary's approach: pour data from everywhere into one place and prepare a separate copy specifically for agents. Don't chase normalization; reorganize it in a way agents can retrieve well.

If your company is getting started, the first step is this: give the agent a read-only database account, plus a schema description. Read-only means it can query everything but change nothing.

Layer Two: Tools—Let the Agent Actually Act

Once data is queryable, the agent still needs to get things done.

A tool is an action an agent can execute, such as recording an expense or booking a meeting. YC built a tool library shared by every team: 20 tools at first, now more than 350, covering finance, recruiting, office hours, event management, and more. Each team turns its own work into tools and adds them.

The key is sharing. The same set of tools can be called by internal agents and by Claude Code on each person's laptop.

Pete says that if he moved to any company, the first two things he would do are these: unify the data and create a shared tool library.

You don't have to build it all at once. YC also started with one team: finance. Whenever a piece of work is worth handing to an agent, add one tool to the library.

Layer Three: Skills—Write Down "How" as an Instruction Manual

Tools answer whether something can be done; skills answer how to do it well.

You can think of a skill as an instruction manual layered on top of the tools. It is essentially a text file: for this kind of task, follow these steps and use these tools.

YC's usage evolved: at first everyone wrote their own prompts, then they became skills, and later agents were allowed to edit the skills themselves. When something works well, you say "skillify," save the approach, and anyone can use it next time.

Gary has his own habit: regularly check whether new skills duplicate old ones, and whether the whole set is complete without overlap. Ten skills that do the same thing are worse than one skill with parameters.

Your company's first skills should come from the people who actually do the work: write down how they approach a given task.

Layer Four: A Nightly Review So Skills Improve Themselves

Above that is making the skills themselves stronger.

YC has an agent that reads all employee-agent conversations every night and looks for two things: where the work could have been done better, and where having a piece of information from the start would have made it faster. Then it goes back and edits the corresponding skill.

Here's an example. YC asks founders to explain their company in two sentences: what you do and why it matters. It sounds simple, but many seasoned founders struggle to write it. A partner wrote a skill specifically to help revise it. Later, several partners ran a small group coaching session where every founder in that batch wrote on the spot and received feedback, and then fed the transcript of that session back into the skill so it could improve itself. Pete says it now writes better than he does.

Gary's summary: this is how superintelligence inside an organization emerges—turn a piece of work into a skill, keep a record of how it is used, then use that record to improve the skill. Do this for everything and there is nothing more complicated.

Start with one skill at your own company: keep its conversation logs and the transcripts of related meetings, and let it revise itself. Once it works, move on to the next one.

Layer Five: Organization—The Hardest Part Is Getting People to Open Up

The fifth layer is the hardest, and it has nothing to do with technology. It is about the organization.

First, conversations are public by default. Every employee-agent conversation at YC is visible company-wide and pushed to a Slack channel in real time. The decision was debated for a long time: everyone can see everything, but can everything really be shared? It stayed because people learned how to use agents by watching others. Publicness is also a constraint. In a high-trust environment like a VC firm, sensitive information actually doesn't get misused.

Second, record everything. Meetings, discussions, and documents are all raw material for the agent's review. Two years ago, recording meetings felt awkward; now it is almost the default.

Third, be willing to spend money. Gary says spending $10,000 to $100,000 a year on tokens is like living in 2028 early: what costs $100,000 today will cost $10,000 next year and a few hundred the year after. It is like the companies in the 1990s that gave employees computers early.

Their conclusion: such an organization must be equal enough and trust by default. Most organizations in the world cannot do either. Big companies lock down their data, citing security.

The returns are concrete. New hires used to take six months to get up to speed; now the agent carries the best partner's way of working, so a new hire can learn from day one. Questions too awkward to ask a colleague can go to the agent first.

You can also try this within one team first: make everyone's agent conversations public in a single group.

Think in Reverse: AI Is the Foundation, Not a Plugin

Pete wrote a widely shared essay called "The Five-Horse Carriage." He argues that most AI products simply stuff a little AI into old software. YC's approach is the opposite: AI is the foundation, and tools and processes grow on top of it.

Let's string the five layers together once more: put data in one place, share tools across teams, write methods as skills, review the records every night, and make conversations visible to everyone.

The model is the least of your worries. The hard parts are layers one and five: getting data together and getting people to use agents openly.

If you do only one thing, start with one team and one read-only database account. Save this episode, compare it with your own company, and see which layer you are stuck at.