Sep 14, 2026 · 7 min read
How to run an AI-native company: close the loop
YC’s advice for AI-native startups comes down to one idea: capture everything, and feed it back into the work. Most teams get the first half right and quietly break the second.
What YC means by an “AI-native” company
In April, YC Partner Diana Hu laid out what she calls the playbook for building an AI-native company. Her core argument is that AI shouldn’t be a tool your company uses. It should be the operating system your company runs on.
The distinction she draws is between two kinds of company.
An open-loop company makes decisions and moves on. Information lives in fragments: a call nobody wrote up, a support ticket that got closed, a decision made in a DM. Someone has to piece it together by hand, and most of it is simply lost.
A closed-loop company captures what happens, feeds it back into an intelligence layer, and uses what it learns to get better. Hu’s shorthand for this is a queryable company: every important process leaves behind a digital artifact that AI can read, connect, and learn from.
In practice, that means a few habits that sound mundane but add up:
• Record every meeting with an AI notetaker.
• Move work out of DMs and email and into channels where it’s captured.
• Collect the artifacts your company already produces: tickets, Slack threads, customer feedback, sales calls, standups, docs, and code.
• Put agents where people already work, so the system is fed as a side effect of doing the job.
YC runs this way too
This isn’t only advice for founders. On the Lightcone podcast, YC General Partner Pete Koomen walked through how YC rebuilt its own internal tooling around the same principle.
The details are instructive. YC pulled its organizational context into one place, gave its agents a shared set of tools and reusable skills, and then did the part most teams skip: it fed the results back in. An agent reviews how people used the system and improves the skills based on what it finds.
His clearest example was a skill that helps founders write a short, sharp description of their company. Partners fed transcripts of their office-hours coaching back into it, and the skill got noticeably better. Nobody rewrote the prompt by hand. The captured conversations did the work.
That’s the loop: capture, learn, improve, repeat.
Capturing everything is the easy half
Here’s the uncomfortable part. Most product teams have already done the capturing.
The sales call is in Gong. The customer interview is in Granola. The support ticket is in Zendesk or Intercom. The feature request is a Slack thread. The usage data is in Mixpanel. The work is in Linear or Jira. The spec is in Notion.
Every one of those is an artifact. The company is, technically, queryable.
And yet the loop is still open, because capturing isn’t the same as closing. The information is recorded, but it isn’t connected. Nothing links the quote from Tuesday’s call to the ticket it should have produced, to the metric that was supposed to move, to what actually happened after you shipped.
So someone still has to do that by hand. Usually a product manager, usually at night.
Why “paste it into a chatbot” isn’t a loop
The instinct is reasonable: export the transcripts, paste them into ChatGPT or Claude, and ask what customers want.
General-purpose assistants are genuinely good at that single conversation. You’ll get a useful summary. But look at what happens next:
• The answer evaporates. It lives in a chat thread, not in your roadmap, your tickets, or your specs.
• The evidence gets detached. The summary says “customers want faster onboarding,” but the eleven calls and forty tickets behind it are gone. When someone asks why you built it, there’s nothing to point to.
• Context resets. Next week’s analysis starts from scratch. It doesn’t remember last month’s signal, the decision you made, or whether it worked.
• Nothing gets measured. The chat has no idea you shipped the change, or whether activation moved.
That’s still an open loop. You’ve just put a smarter step in the middle of it.
A closed loop for product work needs something more specific: a system that holds your context persistently, keeps every conclusion attached to the evidence behind it, turns that evidence into real product work, and checks the result after release.
What a closed product loop looks like
For a product team, closing the loop means five connected steps:
1. Capture. Customer calls, meetings, support tickets, Slack, analytics, docs, and code flow in from the tools you already use.
2. Connect. Scattered inputs become signals, each one traceable back to the conversations and data that produced it.
3. Decide. You can see what matters, how signals relate, and what deserves attention first, based on evidence rather than whoever spoke loudest.
4. Act. Briefs, tickets, and specs are drafted from that evidence, with the sources still attached.
5. Learn. After you ship, outcomes are measured against the goal and fed back in, so the next decision starts smarter than the last.
Skip any one of them and the loop opens back up.
Where Fijord fits
This is the gap we’re building Fijord to close.
Fijord doesn’t replace the tools you capture with. It works alongside them: your meeting notetaker, your support desk, Slack, Linear or Jira, Notion, GitHub, and Mixpanel. What it adds is the part in the middle and the part at the end.
• Everything stays connected to its evidence. Every insight, brief, ticket, and metric links back to the conversations, research, and data behind it.
• You can work with it from different angles. Explore relationships on a canvas, keep delivery moving on a board, plan on a roadmap, and weigh effort against impact on a matrix, all from the same underlying context.
• The busywork gets drafted for you. Briefs and tickets are generated from the evidence, not typed from memory.
• The loop actually closes. Every release feeds back into what Fijord understands, recommends, and prioritizes.
The goal isn’t to add another place to paste things. It’s to make the capturing your team already does finally pay off as product work.
Fijord is in early access now.
Where to start this week
You don’t need a new stack to begin closing the loop. Start with the habits:
1. Record every customer conversation. If it isn’t captured, it can’t feed anything.
2. Get support tickets into one place where they can be read alongside everything else.
3. Move product decisions out of DMs and into channels or docs.
4. Write down what each launch was supposed to change, so you can check whether it did.
5. Stop letting conclusions live in chat windows. Put them somewhere they stay attached to the evidence.
Do those, and you’ll have the raw material of a closed loop. Connect it, and you’ll have a company that gets smarter every time it ships.