What the AI Agents Conversation Gets Wrong About Data (And What Small Business Owners Should Do Instead)
The AI agents conversation has a data integrity problem. Not a technical one — a framing one.
Most of the content out there about AI agents is written for product managers, startup founders, and developers with engineering teams behind them. The advice is real, but it's aimed at people who have infrastructure. Most small business owners don't. And when you drop agent logic on top of messy, inconsistent, or incomplete data, you don't get a smart automation. You get a confident machine that produces wrong outputs at scale.
Here's what that actually looks like in practice, and what you can do about it before you build anything.
The Real Problem With AI Agents Isn't the AI
When a small business owner sets up an AI agent — whether it's in n8n, Make, or a tool like Relay — the assumption is that the agent will figure out what to do with whatever data it touches. And to a point, that's true. Modern LLMs are remarkably good at pattern-matching and filling in gaps.
The problem is that "filling in gaps" is exactly what you don't want when money, client relationships, or decisions are involved.
If your CRM has contacts where some have full names, some have first names only, and some have company names in the name field, your agent will process all of them — and it will do so confidently. It won't pause and say "hey, this looks inconsistent." It will just keep going. The errors don't announce themselves.
This is the data integrity problem. It's not dramatic. It's slow and quiet, and by the time you notice it, you've sent personalised emails to "Johnson Plumbing" or generated reports that are off because the source records were duplicated.
Clean Your Data Before You Automate It
The most valuable thing you can do before building any AI agent workflow is spend two hours auditing the data the agent will touch.
Start with your CRM. Export your contacts and look at the fields your agent will read: names, email addresses, tags, company fields, custom attributes. Check for inconsistencies, duplicates, and blanks. In HubSpot, for example, you can filter contacts by a specific property being empty and batch-update them in minutes. In Notion, you can filter database entries where a field is empty and fix them in a focused session.
The same applies to whatever triggers your agent. If it's reading from a Google Sheet, check that your column headers are consistent and that every row follows the same format. If it's reading emails, check that the emails it's parsing are actually formatted the way you assume they are.
This isn't glamorous. It's the kind of thing that doesn't feel like "using AI." But it's the difference between an agent that runs reliably and one that produces plausible-sounding garbage.
Build in a Human Checkpoint Before You Remove It
There's a natural temptation when building automations to fully remove yourself from the loop as quickly as possible. That's the dream — the thing runs while you're asleep. But the fastest way to break trust in your own systems is to let a flawed agent run unchecked for three weeks and then discover the damage.
The smarter approach is to build the agent with a human checkpoint first. In n8n, this looks like routing the agent's output to a Slack message or a Notion page for review before any action is taken. You watch it for a week. You see what it gets right and what it gets wrong. Then you tighten the logic, fix the edge cases, and only then do you let it run autonomously.
This isn't a lack of confidence in the technology. It's how you build confidence in your specific implementation, with your specific data, in your specific context.
Warren's rule: never automate a decision you haven't made manually at least ten times and understood every variation of. If you haven't done it manually enough to know the edge cases, the agent definitely doesn't know them either.
The Vibe-Coding Trap and Why It Matters for Agents
There's a term floating around right now — "vibe coding." It refers to building software by describing what you want to an AI and shipping whatever it produces without fully understanding it. It's fast. It's often impressive-looking. And when it breaks, it breaks in ways you can't diagnose because you never understood the foundation.
The same risk applies to AI agents. If you build a workflow by stringing together nodes without understanding what each one does, you'll hit a wall the first time something breaks — and you won't know where to start.
The fix isn't to slow down to a crawl. It's to build one piece at a time and verify each step before connecting the next one. Build the trigger. Confirm it fires correctly. Add the first action. Confirm it produces the right output. Then add the next action.
This modular approach means your agent is debuggable. It means you understand it. And it means when something goes wrong, you know exactly where to look.
What to Do Today
Pick one workflow you've been thinking about automating — something you currently do manually at least once a week. Before you touch any tool, write down every step you take manually, including what data you look at and what decisions you make along the way.
Then look at the data you'd feed to an agent. Is it clean? Is it consistent? Are there edge cases you handle intuitively that a machine would get wrong?
Answer those questions first. Build second.
That's the sequence most people get backwards. Getting it right saves you from a confident machine making confident mistakes, and it means the automation you eventually build actually does what you need it to do.