Why You Should Run Agents Inside Your CRM

Clarify x The Signal

If you were forwarded this newsletter, join 9,163 weekly readers—some of the smartest GTM founders and operators—by subscribing here:

---

I’m co-hosting a live session with Clarify’s founders to talk through specific ways to run agents inside your CRM.

Join us one week from today (limited capacity) → Tuesday, June 30th:

---

Hey y’all! 👋

In May of last year, I argued that the future of CRM is autonomous. Then, in December, I followed up with The Autonomous CRM: 6 Months Later, after Clarify shipped Rep and AI Fields and the “autonomous CRM” moved from an idea for an investor pitch deck to core infrastructure that founders run their business on top of. Today, that story continues to evolve, as Clarify shipped its agent builder!

It lets you spin up autonomous agents directly inside your CRM. You tell it what you want in plain English, and under 5 seconds it’s built (literally; I know because I built one live—video later in this post, it’s magic). I think Clarify should be part of the conversation for any early-stage founder or GTM hire at a Seed-Series B company. I’m excited to walk you through everything in today’s sponsored deep dive on Clarify’s agent launch!

Here’s what we cover:

• The context arms race (and the layer you already own)

• Why the CRM failed us

• Agents fix the input problem

• From system of record to system of action

• I built an agent live (in 5 seconds)

• A starter list of agents to run inside your CRM

• Bring more data in, not less

• How SaaS UI evolves from here

• Looking forward

Alright, let’s get into it.

---

The context arms race (and the layer you already own)

You’ve heard it by now: your agents are only as smart as the context they can see. A sequencing agent that can’t see the prospect already replied “circle back in Q3” is worse than no agent at all. So the market has gotten obsessed with context, and a land grab is underway to be the context layer across GTM teams.

It has become commonplace to think the CRM is no longer the best place for context. But, in a world where agents are constantly working on your behalf to populate your CRM with context (eg: when every call, email thread, meeting, deal, stage change, contact is actually populated correctly)… I would argue the CRM can be the best place to house your context. The CRM was always supposed to be the brain. And now that you can keep it updated correctly, building agents on top of the place where the rest of your customer information lives is the obvious move.

Why the CRM failed us

If your CRM requires humans to update it, it will always be out of date.

And every GTM function downstream (forecasting, territory planning, attribution, scoring, and now every AI tool you bolt on top) inherits that staleness.

Everyone nods along that context should live in the CRM. The honest follow-up is that it usually doesn’t, because the data gets entered by reps at 8pm from the scribbles on their notepad (I lived this as a founder and AE), or it doesn’t get entered at all. Revenue slips through the cracks not because the system of record is poorly designed, but because nobody has the time to feed it. The container was right. The contents were garbage.

Agents fix the input problem

This is the unlock, and it challenges my thinking over the last few years around the CRM as the false ‘source of truth’.

When agents handle capture, the rep stops being the bottleneck. Calls get transcribed and summarized. Emails get parsed. Contacts get enriched. Stages move based on what actually happened in the activity, not what someone claims happened in a Friday pipe review. The system of record becomes self-maintaining.

The second-order effect is what’s interesting to me. Once the CRM is actually current, you can start building agents on top of it that are incredibly powerful. Most CRM automation has historically been mediocre because it was reasoning over stale, incomplete data. Garbage in, (consistently) wrong agent-output out. Fix the input, and everything downstream gets sharper at once.

That’s the case for running agents inside the CRM rather than in a tool floating above it. The capture loop and the action loop share the same source of truth, and that source of truth is finally trustworthy.

From system of record to system of action

In my piece last year, I described Clarify moving the CRM from a “system of record that takes from reps” to a “system of intelligence that gives them leverage.” The agent builder is the next step in that arc. The CRM becomes a system of action: a place where things happen, not just where you store what happened.

This is the same Assistant-versus-Executive distinction I keep coming back to. An Assistant waits for you to ask (”summarize this call”). An Executive acts on your behalf (”this deal went single-threaded after the champion stopped replying, I drafted a multi-thread email to the VP, want to send it?”). Agents inside the CRM are the most natural home for Executive behavior, because that’s where the full deal context already sits.

I built an agent live (in 5 seconds)

I recorded a Loom the first time I opened Clarify’s agent builder. No prep, no second take, just me describing an agent in plain English and watching it build.

I asked it to scan every call, pull action items tagged to each person, surface objections to follow up on, write the next step, and post it all to Slack. It built in about five seconds, named the agent, wired the trigger, wrote the instructions, and set tool access (read call recordings, write to Slack) on its own. It even added the meeting title, which I never asked for.

Here’s a real example of a Slack message the agent sent me:

This is what I said out loud in the video, and I still believe: my imagination is the limit now, not the tooling. The constraint used to be “can I build this.” Now it’s “what’s worth building.”

A starter list of agents to run inside your CRM

Here’s a tiered list to get the gears turning, from hygiene to autonomous action. Some of these are pre-built templates you can use in Clarify. Others, you can fork an existing agent or create one from scratch.

Tier 1: Capture and hygiene.

• Post-call summary to Slack with action items tagged per attendee, objections raised, and the next step. (The one I built live.)

• Stage updater that advances or flags a deal based on real activity, not on what a rep remembers to click.

• Competitor-mention tracker that scans calls and emails and keeps a “competitors in play” field current.

Tier 2: Proactive alerts.

• At-risk deal flag to Slack that watches for stalled momentum (no next meeting, champion gone quiet, single-threaded) and surfaces it before you check.

• Missing-persona alert that notices the economic buyer was never on a call and drafts the multi-threading email.

• Inbound ICP scorer that reads the company, scores fit, and routes accordingly.

Tier 3: Autonomous action.

• Signal-triggered outbound off a competitor outage, funding round, or relevant exec hire, drafted for you to approve.

• Win/loss post-mortem pushed to Slack and CRM written from the actual final calls and emails (AI Fields doing the analyst’s job).

• Lookalike sourcing that identifies the use case that closed a deal and goes finds more companies like it.

• Product feedback across entire GTM org. Every day, scan Sales/CSM call transcripts for any mentions of product bugs, feature requests, customer praise, etc. Check in linear to see if there are any matching tickets for a bug mentioned (if not, add one), add a Task in Linear for a PM about the feature request, check Stripe about their subscription, and notify their Account Manager in Slack.

Tier 1 makes the data trustworthy, Tier 2 turns it into nudges, Tier 3 turns nudges into actions. You can’t do Tier 3 well until Tier 1 is solved, which is the whole argument for why this belongs inside the CRM.

Bring more data in, not less

There’s a deeper unlock here that data and RevOps people will appreciate.

I felt this pain firsthand when I was building Groundswell, a company helping teams operationalize product-led sales. Getting first-party event/behavioral data out of the warehouse and into the systems where GTM teams live was brutal: reverse ETL, custom scoring models, PLG tools on top of the warehouse. The overhead was high enough that most companies didn’t bother, so the data stayed locked up where reps never saw it.

Agents change the calculus. An LLM can read raw activity and reason about what it means without it being pre-modeled, scored, and cleaned first. Stream the events in (product events, support tickets, first-party signals), let the agent reason over them, and act. So flip the old instinct: bring more data in, not less. The agent can use messy, raw, unmodeled data that would have been useless to a rule-based workflow. That lowers the bar for real automation for everyone, not just teams with a data engineer to spare.

How SaaS UI evolves from here

The cool, contrarian, new thing to say is that software is “going headless,” or that “UI doesn’t matter in a world of agents.” I think that’s a lazy take. I have a different prediction about how SaaS UI will evolve.

As agents get good, the GUI collapses from the console you operate all day into the console you open only to make decisions that carry real risk. The CRM is a great example. Historically, the GUI was the work, which is the source of the decades-old adoption problem: reps avoid the CRM because data entry is friction, so the record is always stale. With agents, capture stops being the rep’s job, and the (system of) record becomes self-maintaining.

What’s left for the human GUI is narrow and high-stakes. Approve the agent’s proposed stage change on a seven-figure opp. Override its territory routing. Inspect the branching history of everything it did to a strategic account before a QBR. Set the ICP and guardrails the fleet runs under. Step in on the relationship-sensitive moment (an exec escalation, an at-risk renewal). Plus, a read-mostly forecast you increasingly query in plain language (”why did Q3 slip?”) instead of clicking through.

So the rep’s relationship to the CRM moves from operating it to supervising a sales-agent fleet through a thin cockpit. They go from living in it all day to approving exceptions and reading the roll-up.

Two implications for anyone building or buying GTM software.

1. The adoption problem doesn’t get solved by better UI. It gets solved by taking the human out of the data-entry loop. The GUI doesn’t improve, it shrinks and moves up the stakes ladder.

2. Pricing decomposes rather than collapses. Humans still get seats (for access, and increasingly for governing the agent estate), and those seats may even multiply. But the agent’s work is usage-shaped, so it gets metered: actions, messages, resolutions, outcomes. As agents do more and the human-seat base shrinks, the revenue mix tilts from seats toward meters. The model that wins is seat plus meter, not one instead of the other. (This is the same shift I wrote about in The $100B+ Winner in GTM Tech Will Sell Labor, Not Software: budget moves from SaaS spend to labor spend.)

One bet sits under all of it. The GUI a human needs shrinks in direct proportion to how much they trust the agents. And the CRM is the first system where that gets obvious.

Looking forward

18 months ago Clarify had a vision. In December they had Rep. This week they have a way for you to build your own agents on top of the cleanest customer context you own. The trajectory has been consistent: take work off the rep’s plate, keep the record honest without anyone babysitting it, and let humans spend their time on the decisions that actually need one.

If you’ve ever lost a deal to a stale field, or watched your team drown in CRM admin, this is the version worth trying. Sign up for Clarify, connect your email, calendar, and Slack. And watch the CRM build itself, then build an agent and see how fast your imagination becomes the only constraint. It’s a magical new world we’re living in. Have fun!

---

That’s it for today. Thank you for your continued attention and trust. I do not take it for granted.

See you next time,
Brendan 🫡

PS: Patrick writes an awesome newsletter about “the honest reflections on the ups, downs, and in-betweens of startup and founder life,” called Founder Therapy.