Zac Sheffer · September 10, 2026 · 9 min read
Every CRM pitch for twenty years has promised less data entry, and mostly the industry has delivered by relocating it: to an admin, to an integration, to a Tuesday-afternoon hygiene ritual. So when we moved our own go-to-market onto Zero, an AI-native CRM, we tracked one question with more discipline than fairness: for each piece of admin, where did it actually go?
Disclosure first, because it colors everything below: we ran our own pipeline on Zero for months before any partnership existed. Zero is now an Introzy partner, and we ship an integration. We were a customer first. Judge the rest of this post with that in view.
Why we cared enough to keep score: we sell a referral layer that sits next to your CRM, which means we spend an unusual amount of time inside other people's CRMs, and we are a small team. Every hour spent updating a record is an hour not spent on the product or with a customer, and the alternative to updating the record is worse: a pipeline you can't trust.
The problem we were testing against is well documented. Salesforce's State of Sales research found that sales reps spend only about 28% of their workweek on active selling; the remaining 72% goes to planning, research, CRM entry, meetings, email, and other overhead. HubSpot's sales research puts a finer point on the data-entry piece: 32% of reps spend at least one hour every day on manual CRM data entry alone. That is a quarter of your selling week lost to typing into fields, and the output of all that typing is still a pipeline nobody fully trusts. We wanted to know if an agent-run CRM actually moves any of those hours, or just relocates them again.
Months in, the admin sorted itself into three lists.
Activity logging. Calls, emails, and meetings land on the record without anyone transcribing their own calendar. It is the least glamorous agent work and the most valuable, because it is the work nobody ever did reliably by hand. Pipeline reviews got shorter because the argument about whether the record was current went away.
Enrichment at record creation. Zero fills in companies and contacts against its 20M+ company database, so a new deal starts with a real company record instead of a name and a prayer. We used to do this by hand at exactly the moment we were least inclined to, right after a good first call.
Notice what both have in common: internal, reversible, and verifiable against a source the agent can read. That is not an accident. It is the shape of work agents are currently good at.
Stage hygiene went from typing to approving. Deals that moved get flagged with a proposed stage change instead of waiting for someone to remember. The keystrokes are gone; the decision is still yours, now with the evidence attached.
Report building became question asking. Somewhere along the way "build a report" became "ask which deals went quiet after the pricing conversation." The construction work vanished; knowing which question matters did not. It is the difference between a database you operate and a colleague you ask.
The discipline moved from the record to the queue. Everything the agents do lands in an activity log, and anything customer-facing waits at an approval gate. As people who build agent products for a living, we went looking for the audit trail first, because agent autonomy without one is how trust dies. It held up, and it changed where the vigilance lives: the old failure mode was a stale record, the new failure mode is a stale queue. That is a better failure mode, because a queue is visible and a quietly wrong record is not. But nobody should adopt an agent-run system expecting to stop paying attention. The vigilance is conserved; it just gets a better interface.
"Did it work" is the wrong question to ask when reviewing what an agent did. The right question is: "Would I have done the same thing, and can I see why the agent did what it did?"
Those are two separate checks. The first is a judgment call. The agent proposed moving a deal from "pricing sent" to "verbal commit" because the prospect replied with "looks good, let's move forward." Fine. But sometimes the agent proposes the same stage change based on "looks good, I will share this with my team." That is not a verbal commit; that is a hand-off to an internal champion with no timeline. The words are similar enough that the agent treats them the same way, and the difference matters.
The second check is transparency. When the agent makes a decision you disagree with, can you see the reasoning? Not "the model thought X" in the abstract, but the specific inputs: which emails it read, which fields it compared, which rule triggered the action. If you cannot reconstruct the path from input to output, you cannot correct it.
We learned to look for three things in the audit trail: the trigger (what changed), the evidence (what the agent read), and the rule (which automation or threshold applied). When all three are visible, reviewing a decision takes seconds. When any one is missing, you are guessing, and guessing is worse than doing the work yourself.
The practical habit: spend 10 minutes every morning scanning the overnight queue to spot the one decision that looks right but feels wrong. That decision teaches you something about the agent's blind spots, and the rule adjustment that follows prevents the next ten versions of the same mistake.
Final drafts. Agent-drafted follow-ups are good scaffolding and mediocre finals. Zero says this themselves, and our experience matches: the draft gets the facts and the thread right, and the founder voice still has to come from a founder.
The agent is good at assembling the relevant context: the last conversation, the open questions, the promised next steps. What it produces is competent and generic. The prospect can tell. Not because the writing is bad, but because it lacks the specific callbacks, the humor, and the word choices that signal "a person who remembers our conversation wrote this." Good follow-ups are an act of memory and personality, not information delivery, and both remain stubbornly human.
Judgment calls on identity. When two companies share a domain, or a contact spans organizations, the match is a judgment call, and judgment calls get routed to review. That is correct behavior, and it means a human is in the loop more than the phrase "zero-click" might suggest.
Two records might be technically distinct but practically the same person (someone who changed jobs), or technically the same but practically distinct (a shared info@ address). Resolving these requires knowledge the database does not contain: your relationship history, your memory of conversations, your sense of whether this person is the decision-maker at both companies or just happens to be copied on emails from both.
Knowing what the pipeline is for. No agent proposes that a deal is strategically wrong, only that it is stale. The taste stays with the operators. The decision to pursue or abandon an opportunity based on fit, timing, strategic value, or gut feeling is not a data problem. It is a business problem, and the agent has no opinion on business problems. This is the correct boundary, and teams that try to push agents past it end up with a pipeline full of deals the agent thinks are healthy because the numbers look right, while the human knows the deal is dead because the champion left the company two weeks ago and nobody updated the record.
Here is the part nobody puts in the case study: the admin did not disappear. It moved.
The old admin was data entry, field updates, and report construction. The new admin is reviewing AI suggestions, maintaining automation rules, scanning the audit trail, and adjusting thresholds when the agent's behavior drifts from what you want. Some of the old admin was genuinely eliminated (activity logging, enrichment). The rest was transformed into a different kind of work.
The new work is higher-leverage. Reviewing an AI-proposed stage change is faster than remembering to update the stage yourself, and the pipeline data is better because the agent does not forget. But it is still admin, and it still feels like overhead when you would rather be selling.
The honest accounting: we spend roughly the same total minutes per week on pipeline management as before. The composition changed. Less data entry, more review and rule maintenance. The pipeline is more accurate and the stale-record problem is largely gone. But the promise of "AI does the admin so you can focus on selling" is better stated as "AI does the mechanical admin so your remaining admin is judgment work instead of typing."
Teams expecting admin to vanish will be disappointed. Teams expecting admin to improve will find that the trade is worth it.
For context on how fast this category is moving: HubSpot's 2025 sales research reported that only 8% of surveyed reps said they were not using AI at all, while 84% said AI saves time and optimizes processes. Salesforce reports that 97% of senior sales leaders say AI is changing their organization's approach to sales. The question is no longer whether AI belongs in the CRM. It is whether the CRM was designed around it or bolted it on afterward. Zero was designed around it, and the difference is felt in the audit trail, the approval gates, and the enrichment that happens without asking.
We build MCP tools for Introzy, so we connected to Zero's MCP surface the way our own customers connect to ours. When a CRM exposes itself as a tool surface, it stops being a tab: the record becomes something your assistant can consult mid-thought, in whatever window you were already in. Being on the consuming end of the pattern, after months of building the producing end, was clarifying about what makes a tool surface good: predictable shapes, honest errors, and no surprises in what a tool call will touch.
Running on Zero sharpened the reason Introzy exists. An AI-native CRM keeps the customer record current: the deal, the contacts, the activity. What no CRM tracks, agent-run or not, is who introduced whom, what that introduction became, and what is owed to the person who made it. The deal record gets ever better; the story of where the deal came from still needs its own home.
That is why we built the integration, and the build turned out to be a story of its own: one referral record mapping onto a different pipeline model, sync that refuses to guess at stages, idempotency against replayed jobs. That post is here.
Strip the vendor out and the test travels. For any agentic tool, list every piece of admin it claims to remove and ask where each one goes: disappeared, moved, or still yours. Disappeared should be internal, reversible, verifiable work. Moved should come back with a better interface than it left. Still yours should be the judgment you wanted to keep anyway. Over our months on Zero, the lists sorted that way. We stayed.
If you run on Zero and track referrals, the integration puts the introducer on your deal records. And if you are curious what an agent doing the partner-side admin looks like, that is Kai, the part of this stack we build ourselves.
Free up to 5 referrals a month. Every feature included. No card to start.
Zac Sheffer · September 11, 2026 · 8 min
Kevin Chern · August 5, 2026 · 5 min
Kevin Chern · September 4, 2026 · 8 min