---
title: "How I Built an AI Agent Operating System in 90 Days"
episode: 75
podcast: "The LeanScale Podcast"
publisher: "LeanScale"
guest: "Yasin"
guest_title: "Head of AI (former), LeanScale"
date_published: 2026-05-15
date_modified: 2026-07-22
duration: 00:20:32
word_count: 4927
topics: ["ai-in-gtm", "revenue-operations", "gtm-strategy", "sales-enablement"]
canonical_url: https://leanscale-knowledge-hub.netlify.app/podcast/ai-agent-operating-system-90-days/
source: "LeanScale Podcast Knowledge Hub — https://leanscale-knowledge-hub.netlify.app"
license: "Free to quote and cite with attribution to The LeanScale Podcast."
---

# How I Built an AI Agent Operating System in 90 Days

_Yasin's build-along on the folder-and-file architecture behind LeanScale's agentic operating system_

**Episode 75 · The LeanScale Podcast**  
Yasin, Head of AI (former), LeanScale  
Published May 15, 2026 · Updated July 22, 2026 · 00:20:32  
Canonical: https://leanscale-knowledge-hub.netlify.app/podcast/ai-agent-operating-system-90-days/

**Topics:** AI in GTM · Revenue Operations · GTM Strategy · Sales Enablement


## Executive summary

Twelve weeks ago, LeanScale used ChatGPT the way everyone else does: open a tab, ask a question, copy the answer, close it. In this build-along episode, Yasin — LeanScale's Head of AI — walks through what replaced that: a full agentic operating system that reads the team's call transcripts, enriches a self-updating customer warehouse, and drafts customized delivery documents on command. The kicker, and the thesis of the episode, is that the team didn't build the system by hand. They used AI agents to build the operating system for other AI agents.

The whole thing is deliberately demystified. Yasin's core move is to strip the jargon: a 'repository' is just a folder, and an 'agent' is just a folder with a set of instructions written as a file. There is no code and no traditional developer paradigm — you program an agent by writing its SOP in natural language and kicking it off with an automation. Four folders form the backbone: a transcript warehouse (raw call input), a customer warehouse (per-account intel), a GTM library (the in-depth playbooks the team runs on), and a company context repo (brand guidelines, customer avatars, pain points).

The mechanism that makes it work is agent-to-agent handoff. A transcript-processing agent reads every call that lands in the warehouse, annotates it (Is this discovery? A renewal? Did they mention a competitor or push back on pricing?), and routes it to the right customer folder. A second agent enriches that customer's context files — tech stack, stakeholder map, priorities, pain points, ICP. Because every agent has a finite context window (roughly 200,000 to 1,000,000 tokens, about 400–500 pages), you can't just dump a hundred transcripts on it. So the agents pre-process the data for each other, building a context memory layer that documents are written for agents to read, not humans. Yasin frames it bluntly: an ecosystem made by agents, for agents, used by agents.

He then runs a live example: to produce a sales-territory-design scoping document for a demo customer, he feeds an agent the customer's context file, the territory-design playbook, the kickoff-call transcript, and the LeanScale brand tone — and it returns an extensive, diagram-rich, on-brand scoping doc dropped straight into the project folder. The payoff argument is architectural: the agent platform (Claude Code, Claude Cowork, OpenAI Codex, Google Antigravity) is the new workspace precisely because it is tool-agnostic. Via MCP — Model Context Protocol, which Yasin credits Anthropic with introducing in 2024 — it pulls from HubSpot, Salesforce, Google Drive, Snowflake, and Intercom, something a Notion wiki or a CRM-native tool like Agentforce can't do. And because agents can write back into the files, the system compounds: every implementation teaches the playbook something new.

Who should listen: RevOps, sales, marketing, and CS operators, and any founder building an AI-first company, who want a concrete, no-code blueprint for turning scattered tribal knowledge into an organized context layer that agents can actually work from. This is part of a series — a prior episode covers the consumer-app-vs-agent-platform distinction and GTM use cases, and a follow-up covers the from-scratch setup.


## Key takeaways

1. **Agents built the agent system — the real leverage is meta** — The most striking claim isn't that AI wrote a 15-page scoping doc or a 50-page playbook; it's that LeanScale used AI agents to build the operating system that other AI agents now run on. The team didn't hand-assemble the context files — a different agent created them.
   _Why it matters:_ The highest-leverage AI project isn't automating one task; it's using agents to organize your context so every future agent starts from a rich, ready-made data layer. Point agents at the plumbing, not just the output.
   _For:_ Founders, RevOps Leaders

2. **An 'agent' is just a folder with an instruction file — and a repo is just a folder** — Yasin deliberately deflates the jargon. When you hear 'agent,' picture a folder containing a set of instructions saved as a file; when you hear 'repository,' picture a folder. You 'code' the agent by writing its SOP in plain natural language, then trigger it with an automation.
   _Why it matters:_ The barrier to building this is conceptual, not technical. Non-engineers in RevOps, sales, and marketing can author agents by writing good SOPs — no traditional coding required.
   _For:_ RevOps Leaders, Sales Leaders, Marketing Leaders, Founders

3. **Four folders form the backbone of the operating system** — The system rests on a transcript warehouse (raw call input), a customer warehouse (per-account intel and context), a GTM library of in-depth playbooks, and a company context repo (brand guidelines, customer avatars, pain points). Everything else is agents moving between them.
   _Why it matters:_ Before you build agents, build the folder architecture. A clean separation of raw input, enriched account context, reusable IP, and company memory is what lets agents mix and match reliably.
   _For:_ RevOps Leaders, Founders

4. **Agent-to-agent handoffs replace team handoffs** — A transcript agent annotates and routes each call; a customer-warehouse agent enriches account files from those notes; a third agent uses that pre-built context to do real work like territory design or lead routing. Each agent preps the ground for the next, exactly like teammates passing off a project.
   _Why it matters:_ Design your agents as a relay, not as solo bots. The value compounds when one agent's output is deliberately structured to be another agent's clean input.
   _For:_ RevOps Leaders, Customer Success

5. **Context windows are why you pre-process — you can't just dump 100 transcripts** — Every agent has a finite context window (roughly 200K–1M tokens, about 400–500 pages). You can't hand it a hundred raw transcripts and expect quality. So earlier agents distill the 'nuggets' into context files that later agents consume.
   _Why it matters:_ Treat data preparation as a first-class agent job. The reason the final output is good is that the raw material was already extracted, annotated, and enriched before the working agent ever saw it.
   _For:_ RevOps Leaders, Founders

6. **Build a context memory layer that agents read, not humans** — The enriched customer files, brand guidelines, and playbooks aren't meant for a person to read end-to-end. They exist so any agent can inherit memory — the context for each customer, each rep, each playbook, and the company itself. Yasin calls it an ecosystem made by agents, for agents, used by agents.
   _Why it matters:_ Stop optimizing internal docs purely for human readability. A parallel, agent-optimized memory layer is what gives every new agent instant organizational context.
   _For:_ RevOps Leaders, Marketing Leaders, Founders

7. **Output quality is contingent on the input and context you give it** — The territory-design scoping doc was strong because the agent had three things: the enriched customer context, the full playbook, and the actual kickoff-call transcript. Garbage or thin context in, thin output out — which is exactly why the agents constantly prep and maintain the data.
   _Why it matters:_ Invest in evergreen data hygiene maintained by agents. The differentiator between a mediocre and an excellent agent output is the quality and specificity of the context assembled for it.
   _For:_ RevOps Leaders, Sales Leaders, Founders

8. **The agent platform is tool-agnostic via MCP — that's why it's the new workspace** — The reason to use an agent platform instead of a Notion wiki or Google Drive is that it connects everything. Via MCP (Model Context Protocol), agents pull from HubSpot, Salesforce, Google Drive, Snowflake, and Intercom, so the platform becomes the single interface across the whole stack.
   _Why it matters:_ Knowledge siloed in individual tools stays inert. Position the agent platform as the connective layer that sits on top of the CRM and the rest of the stack, not as one more app.
   _For:_ RevOps Leaders, Revenue Executives, Founders

9. **The system compounds because agents write back into the files** — Because an agent can edit files, every implementation can update the underlying playbook: tell the agent to fold in what it learned from a customer, and the playbook improves. Every prospect and customer interaction can make the system better rather than just consuming it.
   _Why it matters:_ Design for a flywheel, not a static library. The most valuable AI systems improve themselves with use — capture the learning in the source files, not in one-off outputs.
   _For:_ RevOps Leaders, Founders

10. **CRM-native AI like Agentforce isn't a substitute for a tool-agnostic platform** — Yasin's pushback on 'why not just use Agentforce?' is that it isn't platform- or tool-agnostic — it can't mix and match across every source the way an agent platform (Claude Code/Cowork, OpenAI Codex, Google Antigravity) can. Even if it gained the capability, it would still be bounded to its own ecosystem.
   _Why it matters:_ Don't assume your CRM's embedded AI is the answer. The strategic bet is the layer that sits above all tools and orchestrates across them, not the AI locked inside any single platform.
   _For:_ RevOps Leaders, Revenue Executives, Founders


## Frameworks

### Agents Are Just Folders + Instruction Files (00:59)

**Definition:** Demystification of the vocabulary: a 'repository' is a folder, and an 'agent' is a folder containing a set of instructions saved as a file. You 'program' or 'train' the agent by writing its SOP in natural language and triggering it with an automation.

This reframing removes the developer mystique and makes the whole system approachable to non-engineers. Building an agent means authoring a clear instruction file the model can follow, then giving it reasoning compute to execute the SOP — no traditional coding paradigm required.

### The Four-Folder Backbone (01:30)

**Definition:** The operating system is built on four repos/folders: (1) transcript warehouse (raw call input), (2) customer warehouse (per-account intel and context), (3) GTM library (in-depth playbooks), and (4) company context (brand guidelines, customer avatars, pain points).

Each folder plays a distinct role — raw input, enriched account memory, reusable IP, and company memory — and agents move between them. The architecture is what lets the platform mix and match files to assemble exactly the context a task needs.

### The Agent Handoff Chain (04:30)

**Definition:** A relay where each agent prepares data for the next: a transcript agent annotates and routes calls, a customer-warehouse agent enriches account files from those notes, and a working agent (e.g., territory design) consumes the pre-built context to do real GTM work.

It mirrors how human teammates hand off a project. Because each agent structures its output as clean input for the next, the working agent never has to parse hundreds of raw transcripts — the preparation is already done upstream.

### The Context (Memory) Layer (06:28)

**Definition:** A body of enriched files — per-customer context, playbooks, company avatars and brand — authored so agents can inherit memory. The documents are written for agents to read, not humans: 'made by agents, for agents, used by agents.'

It solves the token-window constraint by distilling raw material into reusable nuggets, so any newly launched agent starts with organizational memory about the customer, the reps, the playbooks, and the company itself.

### The Agent Platform as the New Tool-Agnostic Workspace (15:45)

**Definition:** The agent platform (Claude Code, Claude Cowork, OpenAI Codex, Google Antigravity) becomes the central interface for the whole organization because, via MCP, it is tool-agnostic — pulling from and writing to HubSpot, Salesforce, Google Drive, Snowflake, and Intercom.

Unlike a Notion wiki or a CRM-native tool, the platform sits on top of the entire stack and mixes and matches across sources. Yasin argues this connective layer is 'what has been missing in AI all along' — one workspace that connects everything.

### The Compounding (Self-Improving) System (13:15)

**Definition:** Because agents can write back into files, every implementation can update the source playbook with new learnings, so the system improves itself with each customer and prospect rather than staying static.

This is the difference between knowledge siloed in disconnected tools and a living ecosystem. The agents don't just consume the context layer — they maintain and upgrade it, creating a flywheel where usage makes the system better.


## Quotes

_Speakers inferred from an undiarized transcript — verify before attributing._

> "We used AI agents in order to build it for other AI agents. How crazy is that?"
>
> — Yasin, The LeanScale Podcast Ep. 75 (00:32)

> "When you hear about, 'Oh, it's an agent,' all you've got to think about is a folder that has a set of instructions listed as a file."
>
> — Yasin, The LeanScale Podcast Ep. 75 (00:59)

> "A repository is really just a folder. When you hear me talk about a transcript warehouse repo, your head should just convert that into a transcript warehouse folder. That's really all it is."
>
> — Yasin, The LeanScale Podcast Ep. 75 (00:59)

> "You can literally code an entire agent in natural language and then feed it that SOP, and it can literally follow that instruction. It's not like you've got to learn how to code."
>
> — Yasin, The LeanScale Podcast Ep. 75 (03:34)

> "When we talk about training the agent, this is what we're talking about. It's literally just creating an instruction file for the agent to follow, and then you kick-start it off of an automation."
>
> — Yasin, The LeanScale Podcast Ep. 75 (04:01)

> "Are you starting to see how this is kind of like replacing team members? It's literally a handoff that you're having from one agent to the next in order to do their job."
>
> — Yasin, The LeanScale Podcast Ep. 75 (05:00)

> "These documents are not read by humans. They're read by other agents. It's really an ecosystem made by agents, for agents, used by agents."
>
> — Yasin, The LeanScale Podcast Ep. 75 (06:28)

> "The agent platform is tool agnostic. Notion isn't going to connect to your CRM."
>
> — Yasin, The LeanScale Podcast Ep. 75 (11:48)

> "The entire system becomes something that compounds on top of itself. The agents are actually making the system better."
>
> — Yasin, The LeanScale Podcast Ep. 75 (13:15)

> "The output quality is contingent upon the input and the context that you give it."
>
> — Yasin, The LeanScale Podcast Ep. 75 (15:16)

> "This has been what is missing in AI all along. It's one central workspace that connects everything together."
>
> — Yasin, The LeanScale Podcast Ep. 75 (16:47)

> "You can just use agents in order to organize that context for the other agents to do work."
>
> — Yasin, The LeanScale Podcast Ep. 75 (19:46)


## Practical advice by role

### Founders

- Don't start by automating a single task — use agents to organize your context first, so every future agent inherits a rich, ready-made data layer.
- Stand up the four-folder backbone (transcript warehouse, customer warehouse, GTM library, company context) before building agents; the architecture is what makes mix-and-match reliable.
- Bet on a tool-agnostic agent platform as the connective layer over your stack, not on the AI embedded inside any single tool.

### RevOps Leaders

- Author agents by writing clear SOPs in natural language — no code — and trigger them with automations when new data lands.
- Make data preparation a first-class agent job: have upstream agents annotate and enrich raw transcripts so working agents never parse hundreds of files.
- Capture learnings back into the source playbooks. Let agents edit the files so the system compounds instead of staying static.

### Sales Leaders

- Feed working agents three things for a strong output — enriched account context, the relevant playbook, and the actual call transcript — because output quality tracks input quality.
- Use a morning-prep agent that checks recent Salesforce activity, reads the last few call transcripts, researches public news, and drops a one-pager per call into Slack.

### Marketing Leaders

- Keep brand guidelines, customer avatars, and pain points in a company-context repo so any agent can produce on-brand, on-voice output on demand.
- Think of your knowledge as an agent-readable memory layer, not just human-readable docs — that's what lets a thin team scale content and context across every account.

### Customer Success

- Route every call transcript into a self-enriching customer warehouse so stakeholder maps, priorities, and pain points stay current without manual note-keeping.
- Design agents as a relay so account context is always pre-built and ready when a champion leaves or a renewal conversation starts.


## AI takeaways

**Thesis:** The durable AI advantage isn't a clever prompt — it's an organized context/memory layer that agents can read, maintain, and build on. And the fastest way to build that layer is to use agents to organize context for other agents, all on a tool-agnostic platform connected through MCP.

- **Agents are folders + SOPs** — An 'agent' is a folder with a natural-language instruction file; a 'repo' is a folder. You build agents by writing SOPs and triggering them with automations — no code, no developer paradigm.
- **Handoffs beat mega-prompts** — Because each agent has a finite context window, the system chains agents that annotate, route, and enrich data so a working agent inherits clean, pre-built context instead of raw transcripts.
- **Context is the product** — The enriched files are written for agents, not humans — 'made by agents, for agents, used by agents.' Output quality tracks the quality and specificity of the assembled context.
- **Tool-agnostic wins** — MCP makes the agent platform the connective layer across HubSpot, Salesforce, Drive, Snowflake, and Intercom — something a Notion wiki or CRM-native tool like Agentforce can't match.
- **The system compounds** — Agents write back into the playbooks, so every implementation improves the source of truth. Usage makes the system better, turning a static library into a flywheel.

**Agent & automation ideas**

- Transcript-processing agent that annotates each call (discovery vs. renewal, competitor mentions, pricing pushback, urgency) and routes it to the correct customer folder.
- Customer-enrichment agent that distills transcript 'nuggets' into per-account context files — tech stack, stakeholder map, priorities, pain points, ICP.
- Playbook-driven delivery agent that combines a customer's context file, the relevant GTM playbook, the kickoff transcript, and brand tone to draft a customized scoping document into the project folder.
- Self-updating playbook agent that folds new learnings from each implementation back into the source playbook so the IP compounds.
- Morning-prep agent that reads recent Salesforce activity and call transcripts, researches public company news, and posts a one-pager per call to Slack.
- Stakeholder-map / champion-change agent that surfaces the current buying committee and gaps the moment a champion leaves an account.


## Operations takeaways

### Revenue operations

- **Architecture before agents.** Stand up the four-folder backbone first — raw transcripts, enriched customer intel, reusable playbooks, and company context — so agents can reliably mix and match.
- **SOPs are the new code.** You configure agents by writing natural-language instruction files, which puts agent-building in reach of RevOps and GTM teams, not just engineers.
- **Own the data layer.** Agents keep the context evergreen by annotating and enriching every call, so the systems decisions rest on maintained, high-quality data.
- **Platform over point tools.** Position the tool-agnostic agent platform as the layer above the CRM and the rest of the stack, connected via MCP — not as one more siloed app.

### Pipeline & marketing ops

- **Morning prep, automated.** An agent can pull recent Salesforce activity, read the latest transcripts, research public news, and hand a rep a one-pager per call before the day starts.
- **Forecast vs. reality.** Agents can cross-reference call transcripts (via a Gong MCP) against pipeline data in the CRM to surface why deals aren't closing.
- **Resilient buying committees.** A stakeholder-map agent can rebuild the picture instantly when a champion leaves, so pipeline risk is caught early.

### Customer operations

- **Self-enriching customer warehouse.** Every transcript is annotated and routed so each account's context — stakeholders, priorities, pain points, tech stack — stays current without manual upkeep.
- **Context ready on demand.** Because context is pre-built by upstream agents, a working agent can start a territory-design or lead-routing project immediately with full account memory.
- **On-brand delivery.** Pulling brand tone from the company-context repo means customer-facing documents come out in the company's language automatically.


## Metrics mentioned

| Value | Metric | Context |
| --- | --- | --- |
| 90 days (12 weeks) | Build time | How long it took LeanScale to go from using ChatGPT like a search engine to a full agentic operating system. |
| 200K–1M tokens (~400–500 pages) | Agent context window | The focus limit of each agent — why you can't dump 100 transcripts on it and why earlier agents must pre-process the data. |
| 15 pages | Scoping document | The AI-generated sales-territory-design scoping document for a customer, produced by an agent rather than written by a person. |
| 50 pages | Team playbook | The depth of the in-house playbooks the entire team runs on — also authored by an agent. |
| 2024 | MCP introduced | When Anthropic introduced Model Context Protocol, which has since become the standard connective layer in the LLM/AI world. |


## Entities mentioned

- **LeanScale** (company) — The company whose agentic operating system Yasin walks through; four repos power delivery for its investor-backed B2B tech startup customers. · https://leanscale-knowledge-hub.netlify.app/company/leanscale/
- **Anthropic** (company) — Credited (as 'Entropic' in the ASR) with introducing MCP — Model Context Protocol — in 2024, which Yasin calls the now-standard way agent platforms connect to any tool. · https://leanscale-knowledge-hub.netlify.app/company/anthropic/
- **OpenAI** (company) — OpenAI Codex cited as an example of a true, tool-capable agent platform (contrasted with CRM-native AI). · https://leanscale-knowledge-hub.netlify.app/company/openai/
- **Google** (company) — Google Antigravity named as another agent platform alongside Claude Code/Cowork and OpenAI Codex; Google Drive is also a data source pulled in via MCP. · https://leanscale-knowledge-hub.netlify.app/company/google/
- **Snowflake** (company) — Named as one of the data sources an agent platform can pull from via MCP connectors. · https://leanscale-knowledge-hub.netlify.app/company/snowflake/
- **Yasin** (person, narrator) — Former Head of AI at LeanScale; host of the AI-agent build-along episodes. · https://leanscale-knowledge-hub.netlify.app/guest/yasin/
- **ChatGPT** (tool, AI Assistant) — The 'search-engine' way most teams use AI (ask a question, copy the answer, close the tab) that Yasin contrasts with a persistent agentic operating system.
- **Model Context Protocol (MCP)** (tool, AI Integration Protocol) — Model Context Protocol — the plug-in/API-endpoint-like standard (from Anthropic, 2024) that lets the agent platform connect to HubSpot, Salesforce, Google Drive, Snowflake, and Intercom.
- **Claude Code** (tool, AI Dev Tool) — Cited ('Cloud Code') as an example agent platform that can mix and match repos and MCP connectors and write back into files.
- **Claude Cowork** (tool, AI Agent Platform) — Cited ('Cloud Cowork') alongside Claude Code as an agent platform / the new workspace for GTM teams.
- **Fireflies** (tool, AI Note Taker) — LeanScale's meeting recorder; transcripts auto-land in the transcript warehouse repo (Yasin notes Gong, Chorus, or Fathom would work too).
- **Gong** (tool, Revenue Intelligence) — Named as an interchangeable call-recording/conversation-intelligence source; its MCP can cross-reference transcripts against pipeline data in the CRM.
- **Wispr Flow** (tool, AI Dictation / Voice) — The voice-dictation platform Yasin fires up ('Whisper Flow') to talk to his agent and kick off the sales-territory-design task.
- **Salesforce** (tool, CRM) — CRM referenced both as the silo the operating system sits on top of and as an MCP data source you can read from and update through the agent platform.
- **HubSpot** (tool, CRM) — CRM named as one of the MCP connectors the agent platform pulls data from.
- **Slack** (tool, Team Messaging) — Where a morning-prep agent delivers a one-pager summarizing each of the day's customer calls.


## FAQ

**Q: What is an AI agent operating system?**

A: In this episode, it's a set of folders (repositories) and instruction files running on a tool-agnostic agent platform. LeanScale's version uses four folders — a transcript warehouse, a customer warehouse, a GTM playbook library, and a company context repo — with AI agents that read, annotate, enrich, and generate documents by moving between them. It took the team about 90 days to build with no code.

**Q: What is an AI agent, in simple terms?**

A: An agent is just a folder that contains a set of instructions saved as a file. You 'program' or 'train' it by writing its SOP in plain natural language, then trigger it with an automation. The model uses reasoning to follow the instructions. There is no traditional coding involved — the barrier is writing a clear instruction file, not software engineering.

**Q: Why store transcripts and customer data in repositories instead of a CRM?**

A: Because the agent platform is tool-agnostic and can write into files, a folder-based system lets agents read, edit, and hand off context to each other, and mix and match across sources. A CRM silos the information. The agent platform still connects to the CRM (and other tools) via MCP, but the folders are what give agents a persistent, editable memory layer.

**Q: What is MCP (Model Context Protocol)?**

A: MCP is a standard — introduced by Anthropic in 2024 — that works like an API endpoint or plug-in, letting an AI agent connect to third-party sources such as HubSpot, Salesforce, Google Drive, Snowflake, and Intercom. It's what makes the agent platform tool-agnostic, so one workspace can pull data from and push updates to your entire stack.

**Q: Why does context matter so much for AI agent output quality?**

A: Output quality is contingent on the input and context you provide. Each agent has a finite context window (roughly 200K–1M tokens, about 400–500 pages), so you can't dump a hundred raw transcripts on it. LeanScale uses upstream agents to distill transcripts into enriched context files, so the working agent starts with clean, specific, ready-made memory — which is why its output is strong.

**Q: How do AI agents hand work off to each other?**

A: They operate as a relay. A transcript agent reads each call, annotates it (discovery vs. renewal, competitor mentions, pricing pushback, urgency), and routes it to the right customer folder. A customer-warehouse agent then enriches that account's context files. A third, working agent uses that pre-built context to produce a deliverable like a territory-design scoping document — never having to parse the raw transcripts itself.

**Q: Is Salesforce Agentforce enough, or do you need a separate agent platform?**

A: Yasin argues Agentforce and other CRM-native AI aren't tool-agnostic or platform-agnostic — they can't mix and match across every source the way a dedicated agent platform (Claude Code, Claude Cowork, OpenAI Codex, Google Antigravity) can. Even if Agentforce gained the capability, it would still be bounded to its own ecosystem. The agent platform is the layer that sits on top of everything.

**Q: How does the system get better over time?**

A: Because agents can write back into files, every implementation can update the underlying playbook. After doing a project for a customer, you tell the agent to fold in what it learned, and the playbook improves. Every prospect and customer interaction can make the system better, turning a static library into a compounding, self-improving flywheel.


## Timeline

- **00:00** — The pitch: an agentic operating system built in 90 days
- **00:59** — Agents and repos are just folders and instruction files
- **01:30** — The four folders that form the backbone
- **02:01** — Transcript warehouse: agents that read every call
- **03:06** — Inside an agent's instruction file (the SOP)
- **04:01** — Token windows and why agents pre-process the data
- **04:30** — Customer warehouse: enriching account context
- **06:28** — The context memory layer, made for agents to read
- **07:56** — The GTM playbook library
- **08:58** — Live demo: generating a territory-design scoping doc
- **11:20** — Why an agent platform beats Notion or a wiki
- **12:15** — MCP: mixing and matching across your tech stack
- **13:15** — Agents write to files, so the system compounds
- **13:47** — The LeanScale company context repo
- **14:14** — Reviewing the agent's finished scoping document
- **15:45** — Why you still need this on top of your CRM
- **16:47** — MCP explained (Anthropic, 2024)
- **17:17** — Agentforce vs. tool-agnostic agent platforms
- **17:48** — GTM use cases: morning prep and stakeholder maps
- **18:45** — Scaling playbooks across every customer
- **19:46** — Early days, compounding value, and what's next


## Related episodes

- **Ep. 74: I Used AI Agents for Every Go-To-Market Role (Sales, Marketing, CS, RevOps)** (Yasin) — The companion episode in this build-along series — the 'previous video' Yasin refers to, covering consumer apps vs. agent platforms and GTM use cases. · https://leanscale-knowledge-hub.netlify.app/podcast/ai-agents-for-every-go-to-market-role/
- **Ep. 95: Why AI Means More RevOps Hires, Not Fewer** (Jimmy O'Halloran) — The operator's counterpart: AI as a productivity multiplier for RevOps, not a replacement — the human side of the leverage Yasin builds. · https://leanscale-knowledge-hub.netlify.app/podcast/jimmy-ohalloran-new-relic-revops-consumption-revenue/
- **Ep. 85: Why AI + GTM Engineers Can't Replace RevOps** (Tessa Whittaker) — Directly debates who and what an AI operating layer does and doesn't replace inside a revenue org. · https://leanscale-knowledge-hub.netlify.app/podcast/tessa-whittaker-ai-gtm-engineers-revops/
- **Ep. 92: Agents That Run Outbound While You Sleep** (Mica) — A production example of GTM agents doing real work, adjacent to the agent-handoff system Yasin demonstrates. · https://leanscale-knowledge-hub.netlify.app/podcast/mica-ample-market-outbound-agents/
- **Ep. 5: Using ChatGPT as a Salesforce Admin** (Christopher Martyen) — An earlier, single-tool take on AI-in-ops that this episode's tool-agnostic agent platform supersedes. · https://leanscale-knowledge-hub.netlify.app/podcast/christopher-martyen-chatgpt-salesforce-admin/
- **Ep. 65: AI Changed GTM Forever. Most Companies Haven't Caught Up** (LeanScale) — Sets the market context for why an agentic operating system is the shift most teams still haven't made. · https://leanscale-knowledge-hub.netlify.app/podcast/alex-shartsis-ai-changed-gtm/
- **Ep. 88: Why AI Won't Close Your Biggest Deals** (Michael Kiernan) — A CRO's view on the limits of AI in enterprise selling — a useful counterweight to the build-everything optimism here. · https://leanscale-knowledge-hub.netlify.app/podcast/michael-kiernan-nextdoor-ai-wont-close-deals/


## Full transcript

_Machine-transcribed and not diarized; speaker attribution is inferred._  
_Transcript only, as a separate file: https://leanscale-knowledge-hub.netlify.app/podcast/ai-agent-operating-system-90-days/transcript.md_

### 00:00 — The pitch: an agentic operating system built in 90 days

**[0:00]** This is a 15-page scoping document on how to implement sales territory design for one of our customers. And this is a diagnostic on a startup's entire go-to-market. And this is a 50-page playbook that our entire team runs on. I didn't write it, and AI agent did. So 12 weeks ago, we were using chat GPT like everyone else. You open it up, you ask a question, you copy the answer out, and you close it. And now we have an entire agentic operating system. A customer warehouse that enriches itself, agents that read our transcripts, update our files, and prep for our meetings. And here's the thing, we didn't build any of this.

**[0:32]** We used AI agents in order to build it for other AI agents. How crazy is that? And look, 12 weeks ago, I couldn't tell you how we were going to do this. And there's a lot of noise out there right now about, "Hey, train your AI agent in order to do that." And it's this amorphous understanding. And what we want to do today is I'm really going to break it down for you, step by step, on how we were able to go ahead and set up this entire LeanScale AI operating system. So the biggest thing that you have to know is that all of this is really just based off of folders and files.

### 00:59 — Agents and repos are just folders and instruction files

**[0:59]** And so when you hear about, "Oh, it's an agent," all you got to think about is a folder that has a set of instructions listed as a file. And I'll show you an example inside of this video. And then we have an AI platform that all of this runs through. So everything lives inside of repositories. And this is one of those words that if you hear about, it's like, "Oh, it's a developer talk." No, no, a repository is really just a folder. And so in a second, when you hear me talk about the idea of a transcript warehouse repo and your head just convert that into a transcript warehouse folder, that's really all it is, same thing.

### 01:30 — The four folders that form the backbone

**[1:30]** So we have four folders that really make up the backbone of this entire operating system. The first one is going to be our transcript warehouse folder. The second one is our customer warehouse folder where all of our customer intel is. The third one is going to be what we call our GTM library. It's pretty much all of the playbooks that we run in-house. And then the fourth one is our lean scale context folder that houses all of the context particular to us. Now, instead of actually just walking you through the folders, because that could be a little bit dry, what I want to do is I want to walk you through how the agents actually move through them

### 02:01 — Transcript warehouse: agents that read every call

**[2:01]** and how each of the agents is doing a handoff to the next agent in order to make the entire system work. So the first one is our transcript warehouse repo. And so what we have is that every single call, every single meeting, the transcript are actually automatically landing inside of this folder. And so we use fireflies, but it doesn't matter what you use. It could be gong, chorus, fathom, whatever it is, this is the raw input that is feeding the entire system. Now, you might be thinking, "Hey, doesn't all of this information already live inside of the CRM?" Now, there's a very important reason why we don't actually house this in a CRM

**[2:35]** and why we actually house it in repos instead. And there's an even bigger reason as to why you wouldn't want to be siloed inside of a CRM. And we'll get to that in just a second later on in the video. And so what we have is that we have two agents that are actually watching this transcript folder. And what it's doing is that every single transcript that lands inside of that folder, this agent is reading it, and then it goes ahead and actually annotates that transcript based off of what happened on the call. And then it's routing that to the right customer folder that is inside of the customer warehouse. Now, this isn't just a simple automation, okay?

### 03:06 — Inside an agent's instruction file (the SOP)

**[3:06]** Because what's really happening is that the agent is tagging it, and it's looking at the context in order to figure out. Is this a discovery call? Is this a renewal conversation? Did the customer mention a competitor? Did they push back on pricing? Did they have urgency on the call? And so all of that is being annotated inside of that transcript based off of the agent. Now, I know, again, that sounds super amorphous. So let me actually open up the agent's instruction file and show you exactly what that looks like. Okay, so what you're looking at is the actual transcript processing agent.

**[3:34]** And this is the really cool part about the way that AI and agentic AI is moving right now, is because you can literally code an entire agent in natural language and then feed it that SOP, and it can literally follow that instruction. It's not like you got to learn how to code or any of the other things from the traditional paradigm. And so you can see this transcript processing agent, it has the overview, and then it breaks down into the phases and the tasks of what it's doing. And so every single time a transcript is going ahead and landing inside of that folder, we do have an automation that is kick-starting that agent,

### 04:01 — Token windows and why agents pre-process the data

**[4:01]** but then that agent has reasoning compute in order to actually go through and figure things out based off of this SOP. And so when we say programming the agent, when we talk about training the agent, this is what we're talking about. It's literally just creating an instruction file for the agent to follow, and then you can go ahead and kick-start it off of an automation. So that's what that agent is doing. But now here's the key part, because remember, in a previous video, I've talked about this, we'll probably touch on it a little bit more in this video, is that in LLM world and in AI world, every single agent is going to have a 200,000 to

### 04:30 — Customer warehouse: enriching account context

**[4:30]** a million token window. That's about 400 to 500 pages effectively of what it can focus on. That means that you can't just dump 100 transcripts and expect you to parse through it. And so what happens is that this agent is now actually going ahead and setting up things for the next agent inside of the customer warehouse. And in the customer warehouse, we have another agent, which is now reading through the transcript and the notes that the previous agent left it and enriching each of the actual customer warehouse folders and the files within that. So for us, we look at the tech stack of our customers,

**[5:00]** we look at the context, the stakeholder map, all of the additional detail that is being teed up. And so that customer warehouse agent is taking that and looking at all of the notes that the transcript warehouse agent went ahead and left it. So that way it can do its job. Are you starting to see how this is kind of like replacing team members? It's literally a handoff that you're having from one agent to the next in order to go ahead and do their job. And so in our system, the next folder that we then have is this customer warehouse folder. And I'll show you what that looks like right over here. So you'll see we have our customer warehouse folder.

**[5:28]** Obviously, this is an anonymized demo version of it. But you'll see in here, we have all of our customer information. And I'll show you one ahead and put this example file together. So we have overall context. I'll show you this example enrichment on here. It'll go over, you know, Flowforge is a demo company we went ahead and put together for this video. But it's like company snapshot, stakeholders, current priorities, pain points, tech stack, verticals, and ICP. You'll see this is a very long document based off of the context of this customer. Now, here's the important part that you need to keep in mind because you might be thinking, okay, well, what?

**[5:57]** A human's going to go out and read this entire document? No, what we're doing is we're creating these context files by extracting the nuggets from the transcripts. And then these context files live in order for the next agent to be able to get that handoff. So that way, it can actually work on what it needs to work on. And so really, what this entire ecosystem that is being built is a context memory layer for the agent platform. So that way, every single agent can have memory as to what is the context for each customer? What is the context for you as a company? What is the context of what's going on overall with the playbooks?

### 06:28 — The context memory layer, made for agents to read

**[6:28]** What's going on with the sales reps? And this is the ecosystem. This is the platform that enables that memory layer. And so these documents are not read by humans. They're read by other agents. And so it's really an ecosystem made by agents, for agents, used by agents. How crazy is that? And so what we have is we have this agent right over here. And this agent, again, just like the last agent, really whenever you're here training an agent, it's just a file that gives it instructions. That's literally it. And as long as it's living within an agent platform, you're good to go and you just feed it that instruction set.

**[6:56]** And so you'll see, we have this instruction set right over here, which is the customer context enrichment SOP. And so what happens is that that agent is using this SOP in order to process these transcripts right over here. And what it's doing is it's figuring out what are the nuggets? What are the important pieces, the important things that it needs to go ahead and enrich all of the customer context. And that is what you're seeing right over here. And so what really that agent is doing is it's taking the hand off from the previous transcript agent, which went ahead and already left for it a bunch of notes.

**[7:27]** And then it's further going ahead and processing that. And then enriching the customer's information. So that way when the third agent comes and says, OK, we now need to do a sales territory design. We've got to do a lead routing project. We've got to go ahead and really map out the quotas for the sales reps. When that third agent comes in, it's not having to parse through hundreds of transcripts. All of this processing has already been done by other agents. And so that third agent can just get to work working on lead routing for the startup because it has all the context and it has that memory layer built in. OK, so that's our customer warehouse.

### 07:56 — The GTM playbook library

**[7:56]** We've talked about the transcript warehouse. We've talked about the customer warehouse. The third one is what we call our GTM library. This is really our playbook repo, our playbook folder. And I'll show you what that looks like in here. And so for us, what we have is we have all of the projects, obviously for us because we service startups in B2B tech, we have every single process in all of GoToMarket mapped out with individual playbooks. And here's the key. You're going to notice the theme here, OK? All of the playbooks on this are not like a couple page documents. We're talking about super in-depth documentation.

**[8:28]** This is just a sales territory design playbook, right? The methodology. I can open up the implementation process. Look at how long these documents are, OK? The reason is because when I say that for XYZ startup, we're going to do a sales territory design, that agent has all of the context it needs to understand what sales territory design best practices look like from our IP, from having done this dozens of times. We've trained the agent on that. How have we trained the agent? By putting these files together. How do we put these files together? By using a different agent in order to actually create the files in the first place.

### 08:58 — Live demo: generating a territory-design scoping doc

**[8:58]** Now, I know a lot of this sounds like really amorphous. It sounds really vague. Let's actually do a practical example so you can see how the agent platform is working with all of these context files and how the backbone of this entire operating system works. And so let's say, for example, we go over to our example customer. So we have flowforge over here. And what we have is we have their context file, which is right over here. And so what I'm going to do is I'm going to go ahead and copy the path of that context file. And then I'm going to go ahead and shoot up a different AI platform called Whisper Flow. So that way I can talk to my agent.

**[9:30]** And I'm just going to go ahead and say, I'm looking to go ahead and do a sales territory design for this customer called flowforge. So I'm going to go ahead and give you the context on this customer, which is a file I've gone ahead and given you. The next thing I'm going to do is I'm going to go ahead and give you the playbook for sales territory design. And then the third thing I'm going to go ahead and give you is I'm going to give you the kickoff call that we did with the customer flowforge on what the customer was saying that they needed for sales territory design. And then what I want you to do is I

**[9:56]** want you to actually create an entire end-to-end scoping document that is customized for this customer and go ahead and put it inside of that customer's project folder. And then what I want you to do is I want you to go ahead and save that scoping document inside of that customer's sales territory folder. OK. And then from there, what I'm going to do is I'm just going to go ahead and feed it. So I have the transcript right over here for the kickoff call. And then I'm going to go over to our warehouse right over here, which is our Playbooks warehouse. And I'm going to go ahead and feed it all of the sales territory design playbook.

**[10:27]** And you'll see that this is like a massive document. We've got overview, methodology, implementation, post-project support. How do you do a diagnostic report on it? How do we actually load that up inside of our project management software? All of that context, with the click of a button, I was able to go ahead and copy the entire folder's path right there. And then you know what? Just for fun, let's actually go ahead, and I haven't talked to you about it just yet, but we're going to talk about it in just a second, which is our LeanScale context repo. This repo actually has all of the context about us as a company, all of our brand guidelines,

**[10:54]** our customer avatars, our pain points for the customer avatars, et cetera. So I'm going to go ahead and go over to our brand guidelines, and I'm going to feed it our brand tone. And I'm going to go ahead and give it one more instruction. Oh, yeah, and just for fun, I actually want you to go ahead and use the LeanScale brand tone and make sure that that scoping document is inside of the wording and the language for that brand tone as well. And then just like that, I go ahead and send the agent on its way, and it's going to go ahead and read all of those files. It's going to understand the prompt.

### 11:20 — Why an agent platform beats Notion or a wiki

**[11:20]** You'll see it's going ahead and reading all the documentation, and it's going to create that scoping document for me. Now, obviously, this is just an example for us and what we're able to do for the customers that we work with. But you can start to get your gears turning of how this might actually be useful for your customers. And if you have agent platforms like this running inside of your organization in marketing, in sales, in CS, across your entire company, how powerful this would actually be. Now, when you see us talk about these repos and these folders, some of the questions I'm going to try to answer as they're coming up in your head is, hey, how

**[11:48]** is this, let's say, playbook library different from a wiki or saving something inside of Notion or saving something inside of a Google Drive folder? And the answer for that is going to be a key theme that I'm going to go ahead and come back to again and again, which is that the agent platform is tool agnostic. Notion isn't going to connect to your CRM. And so in the previous video, we did talk about the difference between consumer apps and agent platforms. So make sure you go ahead and refer to that for a deep dive. But that is the difference when we're talking about all of this living inside of an agent platform,

### 12:15 — MCP: mixing and matching across your tech stack

**[12:15]** is you're able to mix and match from different places. And so imagine what's happening here with the agent platform. We're able to go ahead and mix and match files from each of our different repos, which is all the context in the memory layer that it has. And then via MCP's, model context protocol, we can actually pull the data from HubSpot, from Salesforce, from Google Drive, from Snowflake, from Intercom. And so really, all of that becomes the central repository. Everything then becomes housed inside of what we call the new workspace for the future, which is the agent platform. So that way, Cloud Code, Cloud Cowork,

**[12:45]** whatever agent platform you decide to go ahead and use, is able to go ahead and mix and match and do work with that. And then here's the other big benefit of an agent platform, is because an agent platform is now able to actually write into the files. It means it can edit the files, right? And so now, every single time we do a sales territory design implementation with this massive document, let's say we learn something new when we're doing an implementation for a customer. All we have to do is we tell the agent, go ahead and look at that file, go into the actual playbook, and update based off of what you learn from implementing

### 13:15 — Agents write to files, so the system compounds

**[13:15]** this inside of this customer. So what you're noticing is that then the entire system becomes something that compounds on top of itself. And so now, the agents are actually making the system better. So that way, every single instance, every single prospect, every single customer that you talk to is actually making the system better. This is the difference between having your knowledge siloed in all of these different tools, as opposed to having it a part of this ecosystem that is what we call the agent platform. And last but not least, we have this repo, which is what we call our lean scale context. For you, it would be called your company's context.

### 13:47 — The LeanScale company context repo

**[13:47]** And inside of this repo is pretty much all of the context that is pertinent to you. So it's going to have your brand guidelines. It's going to have your customer avatar information, their pain points, everything that your team can come back to again and again that is going to be relevant information for them to know about you. So that way, whenever you're launching a new agent and you want to go ahead and tell it, hey, here's our customer avatar, I want you to go ahead and reference, how does this transcript with this prospect, if I'm a sales rep, if I'm an AE or an SDR, how does this actually compare to our typical avatar?

### 14:14 — Reviewing the agent's finished scoping document

**[14:14]** Boom, the agent can go ahead and give you that answer very quickly because you can just mix and match those files, transcript file mixed with the context file around the customer avatar. Now let's go ahead and look back at how our agent is doing. So remember, we went ahead and launched this agent for sales territory design. And it was going ahead and customizing everything based off of this demo customer that we have. And so remember, we had all of this in rich context. And we went ahead and fed it the kickoff call that we had with the customer in order to then design the scoping document for us. And so if we open that scoping document up,

**[14:46]** you'll see what we have here is we have the actual territory design, scoping doc with the executive summary, the current state, the data problem, the business objective. And so what you're seeing is this is a extensive document with diagrams that this agent has gone ahead and put together. And again, the reason why this is so powerful is because it had all of the context about what does it mean sales territory design for us at LeanScale with the entire playbook. What does it mean to be able to customize this for this customer because it had all of that enriched information? What does it mean to be able to kick off

**[15:16]** this project for this customer because they actually had the kickoff call transcript? And so that's the reason why the output quality is contingent upon the input and the context that you give it. This is the reason why I make such a big deal about what I was saying earlier is that the agents are actually prepping the data and making sure that the data quality is there. And so it's an evergreen process that is being upheld by the agents in every step. I know we went ahead and addressed it just a little bit earlier, but I want to really go ahead and emphasize this point. Because the question that the market's going to have

### 15:45 — Why you still need this on top of your CRM

**[15:45]** is, well, all of this is living inside of our current tech stack. We have our CRM. We have our sales engagement tool. We have Gong. We have Kors for recording my calls. We have all these enrichment tools. All of that information is living in the tech stack. Why do we actually need an operating system like this? Because here's the shift that you're going to have to make and understand about where the market is moving, is that the agent platform is becoming the new workspace. Why? Because the agent platform is tool agnostic via MCP connectors. It's able to go ahead and pull in the information that you need based off of whatever else

**[16:17]** is living inside of your tech stack. And so whenever you need to go ahead and update a deal inside of Salesforce, you can do it through your agent platform. Whenever you need to go ahead and pull in call transcripts and analyze those based off of information that's in your playbooks, you can actually go ahead and use the Gong MCP in order to cross-reference that with your pipeline information that's living inside of your CRM. And so your agent platform becomes the interface through which you're actually looking through all of the information throughout your entire organization. This has been what is missing in AI all along.

### 16:47 — MCP explained (Anthropic, 2024)

**[16:47]** It's one central workspace that connects everything together. And real quick, if you're not familiar, all of this is really made possible not only with the repos and the folders that I showed you earlier, but also through this thing called MCP model context protocol. This is something that Entropic came up with in 2024. It's since become the standard in the LLM and AI world. And it's really kind of like an API endpoint. You can kind of think about it like a plug-in that allows the agent, the AI, the LLM, to actually connect to all of these other third-party sources and really start to pull in all of that information.

### 17:17 — Agentforce vs. tool-agnostic agent platforms

**[17:17]** And so a lot of times when I'm explaining this, sometimes we get the question. It's like, OK, well, what about Salesforce's Agent Force? What about all of the AI tools that are living inside of each of the different platforms? The difference is that Agent Force is not going to be platform agnostic. Unless you're using some sort of agent platform, like OpenAI's codecs, you're using Google's anti-gravity, you're using Cloud's code or Cloud's co-work, the capability of the agents is not something that is built into Agent Force as of right now. But even if Agent Force was able to do some of this, it's not going to be tool agnostic

### 17:48 — GTM use cases: morning prep and stakeholder maps

**[17:48]** to be able to pull from all of the different sources that you need it to. And so the agent platform is that layer that is sitting on top of everything in order for you to be able to mix and match. That is the difference. And so then when you have this agent platform all set up, well, what can you actually do? Well, if you watched the last video, we talked a lot about those use cases. So let's say reps are struggling in order to find patterns as to why deals aren't closing. Being able to check the forecast and the reality of that. Being able to pull up a stakeholder map whenever a champion leaves. Those are just the tip of the iceberg use cases

**[18:16]** that you can have inside of GTM. Let's say, for example, you want to do morning prep. You can actually have an agent that checks the recent activity inside of Salesforce. It'll go ahead and read the last few transcripts of the calls that you had with the customers. It can then go ahead and research online if there's been any public activity about those companies in the last week or since the last time you talked to them. And they can go ahead and send you a one pager inside of Slack for all of the calls that you have on that day. Imagine how powerful that is. And that's just a small example of what you can do when you mix and match and create these agents.

### 18:45 — Scaling playbooks across every customer

**[18:45]** Now for us at LeanScale, because we service investor backed B2B tech startups, let me go ahead and show you a cool use case as to how we are using it, right? So we went ahead and showed you how we were able to go ahead and create the Sales territory scoping document based off of the playbook, as well as the transcripts for that. But the cool thing is that it doesn't just stop with Sales territory design. Inside of our playbook library, which I'm gonna go ahead and pull up right over here, you'll see that we have all of these playbooks built for every function in Go to Market that I can literally just right click, copy path,

**[19:17]** give it to the agent, pull in the context for every single customer, whatever the customer, whoever that might be, and then the agent can get to work actually going ahead and figuring out the implementation plan for every single one of those customers based off of the stakeholder map and then actually create who are the stakeholders from each of those companies that we work with in our customer base that needs to be on the calls and create the entire roadmap for that project and that implementation all done because you've gone ahead and trained the agent on our entire business. And so that's the shift that's happening here.

### 19:46 — Early days, compounding value, and what's next

**[19:46]** It's not just about how do you actually make the agents and the AI gets better. It's how are we contributing to making sure that the data layer and all the context that we're able to go ahead and give it across our entire organization is already organized. And the cool thing is you can just use agents in order to organize that context for the other agents to do work. This is still super early days. Like I said, just 12 weeks ago, we're really going ahead and experimenting with this. And so the compounding is real, the value is real. We wanna go ahead and show you every single step of the way that we're building this.

**[20:15]** And so if you wanna see how we actually set all of this up from scratch as well as the use cases in GoToMarket, that's actually gonna be in the last video. We talked about how to set up the platform, the repos, the automations, all of that. That's gonna be in the last video. You can go ahead and use the link below and follow along. And so with that being said, this is Yasin from Lean Scale. Check it out. Catch you in the next video.


---

_LeanScale Podcast Knowledge Hub. Free to quote and cite with attribution to The LeanScale Podcast (https://www.leanscale.team)._