The GTM Cortex described a pattern I was seeing among people building Claude systems for sales. The Cortex Thesis made the case that the pattern was general. BYOI pushed into what that means for how we buy software. All three came from a comfortable distance.

This one comes from inside. I built one. And the thing about building one is that it doesn't stop.

You start with something small. I needed to manage outreach for an agency my brother and I run. Fashion and luxury brands, image production, AI workflows. We have prospects scattered across email, LinkedIn, Instagram, each channel with its own norms and constraints. The list kept growing and the coordination was falling apart.

So I connected Claude to our CRM and our research tools and told it to help me manage the pipeline. That was the first week. Simple enough.

Then I needed it to draft messages. But drafting requires knowing how we talk. So I wrote a voice guide. Then I realized LinkedIn DMs and emails and Instagram messages all have their own registers, constraints, rhythms. So I wrote channel standards. Then I noticed the drafts still sounded like AI wrote them, that particular cadence everyone recognizes now. So I built a detection protocol, ten patterns to check against, with specific fixes.

Each thing I solved revealed three things I hadn't thought about. The structure wasn't designed. It grew. Like a root system finding water, it followed the need.

What emerged after a few months is something like a working brain for the business.

I type a company name and the system figures out where things stand. Has this prospect been researched? Is there a drafted campaign? Has anything been sent? Depending on the answer, it routes to the right work. Research if the company is new. Draft sequences when research exists. Present for review once drafts are ready. One command covers the full lifecycle because the system holds enough context to know what comes next.

The practical capabilities are what you'd expect. Outreach across four channels. Company research, finding the right contacts, maintaining the CRM. Messages get drafted against living knowledge files, voice guides and channel rules that compose at execution time rather than being hardcoded. A human stays in the loop for every send, the approval gate built inside the workflow rather than bolted on.

Someone in sales technology would call what I built account-based marketing. And it is. Individual research per prospect, messaging tailored to profile and channel, account-level tracking across every touchpoint. But I didn't buy an ABM platform and fill in the fields. I started from a coordination problem and what grew happened to look like ABM because that's what the logic demanded. Platforms give you containers someone else designed. A Cortex grows from your own decisions.

But listing features misses the point. Every piece of it reflects a decision I made about how our business works. How I define a qualified lead. The way I think about segmenting prospects and which channels fit which profiles. What makes a message worth sending. Someone else building a Cortex for the same domain would end up with something entirely different, because their logic is different. The architecture is personal. That's what makes it a Cortex and not a product.

Some of the improvement happens through use. Ending a session captures learnings. Running outreach updates account files. But a lot of it is deliberate, and that's part of the appeal. I've spent entire afternoons building frameworks for how skills should be structured, writing principles documents, defining naming conventions for things that could probably just be named whatever. The meta-architecture of the system, how skills compose, how knowledge files reference each other, where the line sits between a standard and an instruction. These are rabbit holes you enter voluntarily and emerge from hours later having produced something that maybe three future sessions will benefit from. Maybe.

The individual pieces are quite banal. A voice guide. A channel formatting spec. A CRM field called "next_step" with a vocabulary of seven values. None of this is explosive on its own. An MCP server that connects Claude to your CRM. A script that queries pipeline entries because the MCP returns too much data and you need markdown tables instead. You try one integration and it's broken, so you write an API wrapper. You try another and it works but the output format is wrong, so you parse it. You switch approaches, you hit walls, you work around them. The texture of it is unglamorous.

But you bolt on function by function, day by day, and at some point the compound effect becomes hard to ignore.

There's a natural graduation happening underneath. Something starts as ad-hoc. You figure out how to research a company, it works, you move on. By the third time you've done it, you write it down. By the fifth, it becomes a skill with its own structure, rules, and quality checks. Most things settle in the middle, where the system prepares everything and a human reviews before anything goes out. Full automation, removing the human checkpoint entirely, is earned through repetition and confidence. Almost nothing has gotten there yet. The approval step is where the quality lives.

And it sprawls. The Cortex doesn't stay in its lane.

Mine started as outreach management. Then it needed to do company research, so I connected web search tools. Then it needed to manage the CRM, so I connected that. Then I wanted Jacob, my brother and creative partner, to be able to use the outputs without touching the system. He works from his phone, from Notion, from Slack. He doesn't open a terminal. So the system mirrors account files to Notion, stages messages for his review, and pushes updates to the channels he actually uses. We built a skill for Desktop Claude where he can drop a screenshot of an Instagram profile, type "IM lead," and it files the person into a Notion inbox for later processing. Silver platter: research done, messages drafted, CRM staged. He reviews and sends. He doesn't build.

Then I started writing Substack dispatches about the Cortex pattern itself. Those live in the system too. Website copy for our ventures, strategy documents, session protocols for starting and ending a working day, a job search pipeline that tracks applications across Notion and manages referral outreach through a separate CRM workspace. The system manages the content about itself.

Each extension follows the same pattern. A need appears. You connect a tool. The tool needs context, so you write a knowledge file. The knowledge file needs structure, so you define a standard. The standard improves everything that references it. And now you have another layer, another set of rabbit holes, another surface where the fractal continues.

After a few months, the inventory looks something like this.

What runs today:

Outreach lifecycle across four channels with per-account research and custom messaging.

CRM integration with pipeline tracking, staleness detection, follow-up cadences.

A voice and standards system that composes messaging rules at execution time, mixing channel register, brand voice, prospect segment, and anti-AI checks.

Session protocols that capture learnings and maintain priorities. Pipeline health monitoring.

A job search pipeline that scouts VC portfolio boards, preps applications, and manages referral outreach through a separate CRM workspace.

Content management for dispatches and website copy.

Light client surfaces so Jacob can work from Notion, Slack, and his phone without opening a terminal. A skill that builds new skills.

What's forming next:

Ambient operations, where scheduled reports surface what matters without anyone asking.

Specialist agents, a dedicated researcher and copywriter, shared across domains instead of rebuilt per workflow.

Graduating proven zero-variance workflows from human-reviewed to fully automated.

More surfaces for teammates who don't live in the terminal.

The list will look different next month. It always does.

The part that surprised me is how satisfying it is to watch something get incrementally smarter. I mean this in the most mundane way. Fix a voice pattern and tomorrow's drafts are slightly better. Add a research angle and next week's prospect briefs catch something they would have missed. I defined a standard for pipeline stages once, and three separate workflows aligned without any of them knowing about each other.

There's a specific moment that keeps happening. The system drafts a message and it sounds more like me than what I would have written cold. The knowledge files encode decisions I made deliberately, and those decisions are more consistent than my improvisation. The Cortex remembers what I decided on a good day and applies it on a mediocre one.

And there's the other thing. Building a Cortex forces you to discover how much you actually know. Tacit knowledge, the stuff you do without thinking about, turns out to be substantial when you try to make it explicit. How you evaluate a prospect. Why you instinctively know that certain message structures work for luxury brands and collapse for startups, even though you've never articulated the reason. Where the line sits between useful research and a rabbit hole. You knew all of this. You just never wrote it down. Now it's a system, and the system is smarter than any individual session because it carries everything forward.

The fractal doesn't resolve. There is no final version of a Cortex, no shipped state where you stop iterating. The business changes. The tools change. Your understanding of what matters changes with them. A new channel opens up and needs its own standards. A workflow that made sense three months ago starts showing cracks. You rebuild it. You write a better knowledge file. The system absorbs the update and every downstream skill benefits.

The Cortex is never finished because your understanding of your own business isn't. And that is the point.