The GTM Cortex started as a sales thing. But the pattern is general.

What Jordan Crawford and Eric Nowoslawski are building — Claude Code systems that hold institutional knowledge and orchestrate across tools — happens to be pointed at pipelines and outreach. That's where the energy is right now, where the ROI is clearest, where the decision volume justifies the investment. But the architecture doesn't care about domain.

Encode your business logic. Connect to everything. Let it orchestrate.

This works for operations. For product. For creative. For strategy. For any function where context matters and coordination is expensive.

---

The evidence is already showing up outside GTM.

Cursor's support team built an internal AI agent that now handles 80% of their tickets. Not a chatbot with canned responses — an intelligence layer that understands their product, their edge cases, their documentation, their customers. It reasons through problems rather than pattern-matching keywords to FAQ entries.

Iwo Szapar wrote that he's "replaced 99% of his AI tools with Claude Code." Not Claude the chatbot — Claude Code specifically. The terminal. The context window. The ability to connect it to everything and let it orchestrate. He's not talking about sales. He's talking about work.

Dan Shipper called it "your second brain." The framing is apt. It's not an assistant you talk to. It's an extension of how you think, externalized into a system that remembers, synthesizes, and acts.

The GTM Engineers got there first because their domain has clear metrics. Pipeline velocity. Response rates. Meeting bookings. Easy to measure, easy to sell. But the pattern they're discovering applies wherever knowledge work happens.

---

Two groups are converging on this need, from opposite directions.

**Enterprise** already has the business logic. Decades of it. Painfully accumulated in people's heads, buried in processes, scattered across legacy systems and documentation that nobody reads. The silos problem isn't just an org chart issue — it's that institutional knowledge is fragmented across tools that don't talk to each other and people who don't talk to each other.

No vendor can capture what they already know. Their logic is too specific, too nuanced, too embedded in history. They have to build custom. And their time horizon means they care about owning the intelligence layer rather than renting it from a vendor who might not exist in five years.

**Founding teams** face the opposite problem. They don't have too much logic — they're still discovering what it is.

Two or three people. Everyone wearing multiple hats. Everything in flux. Pricing strategy that changes with every deal. Positioning that evolves weekly based on what resonates. An ICP that sharpens with each conversation. A product roadmap that changes with every customer call. Hiring criteria still being learned. Decision-making patterns being invented as they go.

You can't configure Salesforce for a sales process that doesn't exist yet. You can't set up departmental tools for departments that haven't formed.

Founding teams need something that can hold context without requiring them to define the structure upfront. Something that grows with them, holds whatever understanding exists so far, and evolves as the company takes shape.

The encoding process is different for them. For enterprise, it's consolidation — surfacing what's scattered across silos. For founders, it's discovery — figuring out what you actually know.

The middle — growth-stage companies with established processes — might be fine with full-package AI SaaS. "How to run sales" as a product. But the edges are building their own.

---

What the current tools actually miss.

The fundamental limitation isn't capability — it's architecture. Current tools operate on triggers. They execute atomic operations when conditions match. A Zapier workflow fires when a form is submitted. A Notion automation runs when a status changes. A Clay enrichment triggers when a row is added.

Each operation executes without awareness of everything else happening.

The Cortex operates on context. It reasons with accumulated understanding. It knows what happened yesterday and last quarter. It understands relationships between people, between projects, between conversations. It synthesizes across sources and generates judgment, not just output.

Consider customer support beyond GTM. Current approach: ticket comes in, gets routed based on keywords, agent reads the history, manually looks up the customer's account, searches the knowledge base, writes a response.

The Cortex approach: the system already knows this customer. Understands their context. Knows they've asked similar questions before. Knows their subscription tier and feature usage. Has read the documentation and understands the edge cases. It doesn't just route the ticket — it synthesizes everything relevant and surfaces a draft response that the agent can approve, modify, or override. This is what Cursor built internally. 80% of tickets, automated. Not because support is simple, but because the context was encoded.

Consider product decisions. Current approach: feature requests scattered across support tickets, sales calls, user interviews, analytics dashboards. Product manager manually pieces it together, writes PRDs, makes prioritization calls based on incomplete synthesis.

The Cortex approach: every signal feeds the same brain. When someone asks "what are users struggling with?", the system reasons across support tickets, churned customer exit interviews, sales objection patterns, usage data. It doesn't give you a dashboard — it gives you a perspective, with evidence, that you can interrogate.

Consider hiring. Current approach: job posting, applications in an ATS, screening questions, resume reviews, interview notes in different docs, scorecards that nobody standardizes.

The Cortex approach: the system understands what you're actually looking for — not the job description, but the pattern from your successful hires. It reads applications with that understanding. It surfaces candidates who match the pattern, even if their resume keywords don't. It remembers what you've learned from past hires about what predicts success.

The examples keep multiplying. The architecture is the same: encode understanding, connect surfaces, let it orchestrate.

---

The ambient version is starting to appear.

Not a tool you open, but a presence where you already work.

This is what people are discovering through use. You start with Claude in the terminal. Then you notice you can talk to it in Slack. Then you realize it can read your email and draft responses. Then you connect it to your calendar and get briefings before meetings. Then you pipe meeting transcripts back in and it updates its understanding of every project.

The surfaces keep expanding. The brain is the same.

Iwo Szapar replaced 99% of his AI tools with one. Not because Claude is better at each individual task — because the unified context makes the whole greater than the sum of isolated tools. When your email assistant and your calendar assistant and your document assistant are the same brain, they can synthesize in ways that separate tools never could.

This is the direction: ambient intelligence. Not something you log into. Something that's present wherever you work, in whatever mode you need, drawing from accumulated understanding.

---

The infrastructure question is forming alongside the intelligence question.

Where does the brain actually live? Some run it locally — a folder on a laptop, Claude Code in the terminal, context on disk. Some host pieces in the cloud — workflow engines, persistent APIs, always-on bots. Some are stitching together whatever works, mixing local and hosted, adapting as the requirements become clearer.

The platforms are racing to be the layer that enables this. The builders are figuring it out faster than the platforms are forming.

This is probably the nature of the thing. The Cortex isn't a product you buy or a platform you subscribe to. It's a pattern you discover through building.

---

I'm exploring this territory myself.

The interesting thing is that the Cortex reveals itself as you build it. It's not a specification you implement. It's something you discover through the process of encoding.

When you try to teach a machine how your business thinks, you learn what you actually know versus what you thought you knew. You discover which patterns keep recurring. Which decisions get made the same way every time. Which knowledge is tacit and has never been written down. You find where the real logic lives — which is often different from where the org chart suggests it should be.

The encoding process is clarifying in a way that's hard to anticipate. For founding teams, this is how you discover what your business logic actually is. For enterprise, this is how you surface and consolidate what you already know but have scattered across silos.

Maybe the value isn't just the Cortex itself. Maybe it's the act of building it — the mirror it holds up, the understanding it forces, the clarity that emerges from making the implicit explicit.

The GTM Engineers got here first. The rest of knowledge work is following.