Everyone overcomplicates GTM.
MQLs, SQLs, SALs, recycled leads, nurture tracks, scoring models with 47 variables. It's a mess. And honestly? Most of it doesn't matter.
Here's what actually matters: Is this company in-market right now, or not?
If yes, route to reps immediately. Swarm them.
If no, nurture until they show signal.
That's the entire funnel. Two buckets. That's it.
The hard part isn't the framework. It's execution:
- How do you know who's in-market?
- How do you get that list daily without manual work?
- How do you avoid wasting rep capacity on companies that already got outreach?
We build the tools that solve this. I also use these tools to run our own GTM. Every day.
Right now I have 3-10 agents running in the background. Building lead lists. Sending contacts to ad audiences. Debugging production issues. Writing content. Analyzing attribution. Not in sequence. In parallel.
This is exactly how I do it.
You Need a Context Store (Not More API Calls)
Before any agent can do useful work, it needs context. Not scattered across 12 SaaS tools. Queryable. Structured. Already saved.
Here's the key insight most people miss: you want agents to reason on primitives, not spend time gathering them.
Think about it this way. If your agent has to call 5 APIs, parse the responses, normalize the data, and then figure out what to do... you've already lost. That's expensive, slow, and honestly kind of fragile.
And here's the thing nobody warns you about: API limits will kill you.
You can't continuously call the HubSpot API every time you want to know what happened with a company. You can't hit LinkedIn's API for every contact enrichment. You can't query Salesforce for every deal update. You'll hit rate limits within hours. And even if you don't, you're wasting tokens and time on data that hasn't changed since yesterday.
So you build a context graph instead. Pull the data once. Store it locally. Create relationships between entities. Now your agents query your graph, not a dozen external APIs.
This does three things:
- Reduces tokens. Agents aren't wasting context window on API parsing and error handling.
- Reduces vendor dependence. When HubSpot's API goes down (and it will), your agents keep working.
- Faster queries. Local database beats network round-trips every time.
Instead, build the paper trail first. Save everything in structures your agent can query later:
- Intent signals (who visited, which pages, how long, when)
- CRM data (deals, contacts, lifecycle stage, last activity)
- Slack conversations (what are reps saying about accounts?)
- Call recordings (what did prospects actually say?)
- Enrichment data (company size, tech stack, ICP fit)
- Ad impressions (who's seen which campaigns?)
- Outreach history (who already got a message, and when?)
This is basically a Postgres database with all my systems feeding into it. The magic isn't the database. It's having primitives pre-structured so agents can go straight to reasoning.
Here's an example query an agent can run:
"Find ICP companies that visited pricing this week, haven't received outreach in 30 days, aren't in an active deal, and have a buying committee identified."
That touches 4 systems. But because primitives are already saved, the agent gets the answer in seconds and moves straight to the decision: who gets routed where?
Two Buckets, Every Single Day
Every morning, agents categorize my TAM into two buckets.
In-Market
These companies are showing buying signals right now:
- Multiple people on the website (especially pricing, case studies, integrations)
- High intent scores (Bombora surge topics, G2 research)
- Recent engagement (replied to email, watched a demo video, chatted with our bot)
- ICP fit plus recency (visited in last 7 days)
These go to reps. Immediately. However many reps I have, that's how many accounts get worked today.
Not In-Market (Yet)
Everyone else in my TAM. They're not ready for a sales conversation. But I don't ignore them.
These get:
- LinkedIn ads (like this video about our Marketing Ops Agent)
- Retargeting (stay top of mind)
- Content (blog posts like this one)
- Automated nurture (email sequences, but thoughtful)
The goal is simple: keep them aware and engaged until they ARE in-market. Then we're already on their radar.
Here's what the daily loop looks like:
1. Agent queries context store for in-market signals
2. Filters for ICP fit, buying committee identified, not already contacted
3. Routes to reps with full context (why they're in-market, who to contact, what they looked at)
4. Everyone else goes to ads and nurture
Run this every day. Lists are always fresh because agents rebuild them from real-time signals.
Agents Need to Act, Not Just Report
Here's what separates useful agents from expensive toys: they close the loop.
An agent that tells you "hey, this account looks interesting" is barely better than a dashboard. You still have to do something with that information.
But an agent that identifies the account, adds their buying committee to a LinkedIn audience, updates the CRM, and notifies the rep? That's actually useful.
Every agent I build has to answer one question: what action does this trigger?
- Found high-intent accounts? Route to CRM for rep assignment.
- Identified buying committee? Add to LinkedIn ad audience.
- Deal about to close, missing attribution? Query all sources and build the buyer journey.
- Bug in production? Check logs, find root cause, draft the fix.
- Content performing well? Extract the hook, draft variations for social.
If an agent can't act on what it finds, it's not done yet. An insight without an action is just noise.
I Run 3-10 Agents in Parallel
Right now, as I write this, I have multiple agents running in the background. Let me walk you through what each one does.
Lead List Builder
Queries the context store for today's high-intent accounts. Filters by ICP tier, checks outreach history, identifies buying committee. Outputs a prioritized list for my SDR with full context on each account.
LinkedIn Audience Manager
Takes the buying committee contacts from high-intent accounts and adds them to our LinkedIn ad audiences. They'll start seeing our ads within 24-48 hours.
Attribution Analyst
For deals about to close, it builds the complete buyer journey. Scours CRM notes, call recordings, Slack notifications, chat messages. Answers the question everyone always asks: "Did our ads influence this? When did they first engage? What content did they consume?"
Content Writer
Takes everything I'm learning from running GTM and helps me write about it. It has access to the same context store, so it can pull real examples.
Bug Debugger
When something breaks in production, it checks Google Cloud logs, Temporal workflow history, error traces. Finds the root cause. Drafts a fix or at least tells me exactly where to look.
PRD Writer
Based on how I'm solving my own GTM problems, it helps me write product requirements for what we should build next. Dogfooding turns into product insights turns into PRDs.
These run in parallel. I don't wait for one to finish before starting another. The context store is the shared source of truth. Each agent queries what it needs and does its job.
How I Keep Agents From Going in Circles
Agents can get expensive fast if they're inefficient. They'll call the same API 10 times. They'll re-gather context they already had. They'll go in circles trying to figure out what to do.
I've built three things to prevent this.
Skills
Pre-defined capabilities the agent can invoke. Instead of figuring out how to query the database from scratch, it calls a skill that already knows the schema, the common queries, the output format. Consistent. Fast. No token waste on re-learning.
Traces
Everything the agent does gets logged. Decisions made, queries run, actions taken. When something goes wrong, I can replay exactly what happened. When something works, I can see why.
Playbooks
For common workflows (like "build today's lead list"), there's a playbook. The agent doesn't reason from first principles every time. It follows the playbook, which encodes what I've learned works. Deviation only when the situation is genuinely novel.
The result: agents that are predictable, efficient, and don't burn tokens on redundant work.
Rep Capacity is the Real Bottleneck
Rep capacity is the real constraint.
I have X reps. Each can meaningfully work Y accounts per day. That's X times Y accounts getting human attention.
Everything else? Agents and automation.
The mistake most teams make is they spray outreach at everyone and hope some stick. This wastes precious rep capacity on companies that:
- Already received a LinkedIn connection request
- Already saw our ads 50 times
- Aren't showing any intent
- Already said "not right now" 2 weeks ago
So here's what I do instead. Track everything. Who got what. When.
My context store tracks:
- LinkedIn connection requests sent (pending, connected, ignored)
- Ad impressions per company
- Emails sent and responses
- Last rep touchpoint date
- Current deal stage
Before any outreach, agents check: "Has this person already received this type of touch in the last 30 days?"
If yes, skip them. Save the slot for someone new.
If no, they're eligible for outreach.
I've audited GTM teams where 40% of outbound was going to accounts already in active deals or contacted that same week. That's pure waste.
Look, execution is easy now. LLMs can write emails. LinkedIn automation can send requests. The hard part is deciding WHO deserves limited human attention. Agents are really good at this.
Content Multiplies Everything
I spend a lot of time creating content. Posts like this. LinkedIn videos. Ads.
Why? Because content scales in ways reps don't.
One rep can have 20 meaningful conversations a day.
One blog post can reach 10,000 people.
One LinkedIn ad can get 100,000 impressions.
Content builds brand. Brand builds trust. Trust means when someone IS in-market, they already know who we are.
Here's how the funnel actually works:
1. Content drives awareness (SEO, social, ads)
2. Awareness drives site visits
3. Site visits get captured (we identify the company)
4. High intent gets routed to reps
5. Lower intent gets retargeting and nurture
6. Repeat
The content I create isn't random. I write about problems I'm actually solving. This post is literally about how I run my own GTM. The [Marketing Ops Agent video](https://www.linkedin.com/feed/update/urn:li:sponsoredContentV2:(urn:li:ugcPost:7383879192121073664,urn:li:sponsoredCreative:862512794))? It shows the product doing exactly what I described.
When you write about your actual workflow, it's authentic. People can tell.
What You Actually Need to Run This
To run this playbook, you need a few things.
Intent Layer
Who's visiting your site? What pages? How often? Are they ICP? This is the foundation. Without it, you're guessing.
CRM Data
Current deal status, contact history, lifecycle stage. Agents need this to avoid mistakes like prospecting existing customers.
Enrichment
Company size, tech stack, job postings, funding. Context that tells you IF they're ICP, not just that they visited.
Outreach History
What have they received? LinkedIn, email, ads, rep calls? Without this, you'll waste capacity on duplicate touches.
Action Layer
Routes to CRM for assignment. LinkedIn Ads API for audiences. Email for sequences. Agents need to DO things, not just analyze.
We built Warmly to provide these primitives. Intent, enrichment, CRM sync, outreach history, orchestration. I use it to run my own GTM every day.
Where This Is All Going
Right now, I kick off agents manually and review their output. 15 minutes in the morning, check the results, approve high-stakes actions.
But the direction is clear: fully autonomous, with human oversight only for exceptions.
The agent doesn't wait for me to ask "who's in-market today?" It runs at 6am, categorizes the TAM, routes to reps, updates ad audiences, and sends me a summary.
I review the summary. Flag anything weird. Approve edge cases.
We call this the GTM Brain. A system that:
- Ingests all signals (intent, CRM, engagement)
- Builds a daily picture of who matters
- Decides what to do (route, nurture, retarget)
- Executes through connected systems
- Learns from outcomes
Pieces of this run in production today. The full vision is close.
The companies building this infrastructure now will have a structural advantage for years. They're not buying SaaS tools that depreciate. They're building systems that compound.
What This Actually Feels Like
I want to be honest about something. This is all so new.
As I write this post, I have agents running in the background. One is building tomorrow's lead list. Another is analyzing attribution on a deal that's about to close. A third is helping me think through what our website should say.
And while all that's happening, I'm also thinking: what kind of company do we need to be in this new AI era? How do I pitch this during our next fundraise? What illustrations do I need to explain this?
So I prompt an agent to take all that context and figure it out. And its output leads me to a new idea. So I offload that to another agent. And that output sparks something else. And suddenly I'm not doing the work anymore. I'm reviewing it.
Here's the thing I've realized: context management is everything.
Context windows have limits. You can't keep everything in memory forever. So you have to compress. You serialize insights to disk. You create artifacts that become inputs for other agents. Skills, playbooks, traces. All of it is just context, packaged for later.
The loop looks like this:
1. Have an idea
2. Offload to agent with context
3. Agent produces output
4. Output sparks new idea
5. Offload that to another agent
6. Repeat until you're just reviewing
7. Save the traces so agents get better next time
Each review, I save the feedback. Each correction becomes training data. The agents learn. The playbooks improve. The context compounds.
I don't know exactly where this goes. But I know that the people figuring out context management right now, the people building the primitives and the graphs and the traces, they're going to have a massive head start.
We're at the very beginning of this. And honestly? It's the most exciting time I've had building software in years.
If you want to see it in action: Book a demo with us here.