AI Agents for Small Business: How to Build, Buy and Run Them

What an AI agent is in a small business

An AI agent is software that takes a messy input, such as an email, a form, a photo or a call, works out what needs to happen, and then does it through your existing systems. A chatbot only talks. A fixed automation only follows the rule you wrote. An agent reads, decides and acts, inside limits you set.

For an owner or operations lead, the useful test is simple: does the job need judgment on unstructured input, and does it end in an action in another system? If yes, an agent can help. If the job is a clear rule, a rule is cheaper and safer. Our own spam checks and case-study matching are plain code, not AI, for exactly that reason.

Most good agents are a mix. In our builds, code owns the facts (prices, links, categories, permissions and counts) and the model owns the judgment (wording, classification, which case applies). That split is the single biggest reason our agents stay reliable in production.

The jobs small businesses hand to AI agents first

The best first jobs for an AI agent are high-volume, repetitive tasks with a clear end state: replying to new leads, triaging incoming requests, turning photos or documents into structured records, and drafting first versions of routine writing. Each one should end in a draft or a queue that a person checks before anything irreversible happens.

Every row above is a workflow we have built. Some have public results and some do not yet; we say which in the examples section below. If you want a custom agent built for one workflow, that is our AI agent development work. If you want an agent built into your operations rather than a new tool to log into, see AI workflow automation. If the agent belongs inside your own product, see AI feature development.

Which workflow to start with

Start with one workflow, one owner and one metric that decides go or no-go. If you cannot name all three, you are not ready to build. The right first workflow is frequent, painful, measurable, and safe to run as drafts while the agent earns trust.

• Frequent: it happens daily or weekly, so a pilot sees enough real cases to judge.
• Measurable today: you can record median and slowest-case time per item, rework rate, queue depth and cost per case before the agent touches it.
• Reversible: the agent's output can be a draft, a suggestion or a queued action that a person approves.
• Inside tools you already pay for: CRM, Slack, email, help desk or WordPress, with API access available.
• Owned: one person will review the drafts and decide whether the pilot continues.

Avoid starting with anything customer-facing and irreversible, anything that moves money without approval, or a job nobody currently measures. Without a baseline you can prove nothing afterwards. Once the first agent works, expand to its neighbour in the same system rather than jumping to a new department. Owners weighing where AI fits can see how we scope AI workflow automation pilots.

Build vs buy: a decision rule

Buy an off-the-shelf agent when the job is standard and the data lives in one tool. Build a custom agent when it must read and write across several systems, follow your own rules, or produce output that has to match your categories, prices and templates exactly. Many businesses do both: buy for generic tasks, build for the workflow that makes them different.

When we build, we build on our own code stack rather than no-code automation tools, so the client owns a maintainable system. We hand over an in-repo knowledge base with dated decisions (and what each one rules out) and known gotchas written as symptom, cause and fix.

The tools and models behind an agent

An agent has three layers: a model that reasons, the tools it is allowed to call, and the code that checks and records what it did. No-code platforms such as n8n, Zapier and Make connect apps quickly and suit simple flows. Model APIs from Anthropic, OpenAI and Google give you the reasoning. Custom code is where your rules, checks and permissions live.

In practice we pick the cheapest model that passes the quality gate for each job. Claude does most of our reasoning and writing: Sonnet 5 for SEO briefs, page reviews and photo-to-product copy, Opus for job triage and proposal drafts, and Haiku for lead emails because it is cheap and good enough. Gemini and OpenAI image models handle images and photo checks, a small OpenAI model maps messy spreadsheet columns on import, and AssemblyAI handles live transcription.

• One strict tool schema. The model must call one strict tool or answer against a JSON schema. Free text never feeds another system.
• Your vocabulary as allowed values. Your real category list, tags and attributes go into the schema, so the model cannot invent a category.
• Structured context before vector search. Most of our retrieval is structured context: existing pages, search queries, keyword gaps and a do-not-duplicate list. We add vector memory (pgvector) only where an agent must remember a business across sessions.
• Explicit orchestration. One routing call picks who answers. In our experience, provider-managed multi-agent delegation never handed off once in weeks, while explicit routing worked.
• Frontier models via API. We use them under enterprise terms and fine-tune or self-host only when privacy, cost or domain clearly justify it.

One gotcha worth knowing: strict tool schemas reject minItems and maxItems. Adding them broke every production call for us, so counts are checked in code instead.

What AI agents cost to run

The running cost of an AI agent is mostly model tokens: how much text goes in, how much comes out, and which model processes it. Cheap models on short tasks cost very little per run; large models on long documents cost more. Caching, batching and choosing the smallest model that passes your quality gate are the main levers.

Model providers price input and output tokens separately, and output on a large model costs several times more than on a small one. Anthropic prices cache reads at a tenth of normal input, and its Batches API runs at half price, so both are worth designing for from the start.

For most single-step jobs, such as a short lead reply, a proposal draft or an SEO brief, the running cost per task is small. Multi-step agents that loop over long documents or call several tools cost more per task, and image generation is billed per image. We estimate the cost per task during the pilot, before anything goes live.

Treat cost per run as a requirement, not an afterthought. Every bulk run we ship reports cost per item, savings and cache hit rate.

We quote each engagement after a short call about your workflow. The real figure depends on how many systems the agent touches and how strict its checks need to be, and we confirm scope after the baseline is measured.

Connecting an agent to your tools safely

An agent should get exactly the access a trusted employee doing the same job would get, and no more. Grant scoped API access to the specific records it needs, keep destructive actions behind confirmation, and log every action. Plug into the tools your team already opens instead of adding a new one.

Our agents work through Slack, email, ClickUp, GoHighLevel CRM, the WhatsApp Cloud API, WordPress, WooCommerce, RankMath and Google Search Console, with data in Postgres with row-level security, or MySQL plus S3 where the client already runs it.

The clearest example of permission design is a remote MCP server we built into a SaaS product so its customers can run their business from Claude or ChatGPT:

• It exposes 113 tools, and only what the user can already do in the app.
• Each request mints a 5-minute token for that user, so the database's row-level security scopes every tool. Another customer's record simply returns "not found".
• Destructive tools need an explicit confirm flag, and the server tells the AI client to confirm before anything that creates, changes, deletes or sends to a customer.
• AI-written content has separate preview and save tools, URL uploads pass an SSRF guard, and OAuth with PKCE lets connectors attach without a pasted key.

Two more rules we hold: never automate around a platform's rules, and never route around a client's firewall. When a host blocks our requests, we ask the client to allowlist us.

What an AI agent should not do

An AI agent should not take customer-facing, irreversible actions on its own, invent facts that code can supply, or act where a simple rule would do. Autonomy is fine when the check is mechanical and a failure is cheap. Everything else stays a draft that a person approves.

• Publish or send without review when the output reaches customers and cannot be taken back. Our product-page agent only creates hidden drafts, and a test fails the build if any code could set a product live.
• Decide prices, links or categories. Price is calculated from size and technique and clamped to a band, links come from an allowlist, and human-entered values always win.
• Act where the platform forbids bots. Our proposal agent drafts, but a person submits every proposal because the platform does not allow automated submissions.
• Save memories nobody approved. In DejaThink the user approves or rejects each memory before it is saved.
• Replace a rule. Spam filtering and case-study matching are deterministic in our lead agent; the model only writes the reply.
• Report a partial result as success. Running out of tokens is a failure, never a partial result.

How AI agents fail and the controls that catch it

AI agents mostly fail in ordinary software ways: they succeed silently with nothing produced, retry the wrong thing, overspend, or break under load. Model mistakes matter too, but they are easier to catch when every output is structured and checked. These are failures we have hit ourselves and what we changed.

Two habits tie these together. Every manual fix during a live run becomes a code fix afterwards. And a retry sends the model the reasons it was rejected; without that, all three of our attempts once failed the same way.

A 30-day pilot plan for your first agent

A pilot proves an agent on real work before you trust it. In 30 days you can measure the current process, build the agent behind a feature flag, and run it in shadow mode where it drafts and people approve. A focused single-workflow pilot typically runs 2 to 6 weeks depending on access to data and how many systems are involved; we plan for 4 to 6, where the last two weeks add partial autonomy where safe and publish before and after numbers. We have shipped a working multi-agent prototype in two days, but production versions take weeks.

1. Days 1 to 7: pick the workflow and measure it

   Name the workflow, its owner and the one metric that decides go or no-go. Record median and slowest-case time per case, rework rate, queue depth and cost per case. Get API access and sample data.

2. Days 8 to 21: build the smallest version

   Write the context, prompts and one strict tool schema. Put the facts in code and the judgment in the prompt. Add a non-AI fallback. Deploy behind a feature flag to a small slice of real work.

3. Days 22 to 30: shadow mode

   The agent drafts and people approve every output. Track edits and rejections, tune on real traffic, and turn each manual fix into a code fix.

4. Weeks 5 to 6: earn autonomy and decide

   Allow partial autonomy only where the check is mechanical and a failure is cheap. Compare against the baseline, publish the before and after numbers, then scale, iterate or stop.

Two weeks of shadow mode costs less than months of quiet non-adoption. We also agree the design before writing code and build the smallest version that solves the problem: when we once over-built an OAuth flow with token rotation and grace windows, each extra created a defect, and the simpler version shipped clean.

Real examples of AI agents we have built

These are agents and AI features we built for clients and for our own business. Where a result is measured we give it; where it is not, we say so rather than guess. Two of them are prototypes and we label them that way. We report leads an agent sourced separately from deals it only assisted.

Lead reply and scheduling. On our own site a rule-based spam filter runs first, code picks the most relevant case study, and the form shows free slots from Google Calendar so the lead can book the call on the spot. Claude Haiku writes a 130 to 200 word reply within minutes, with timed follow-ups, and a person replies within one business day. The model only writes; the rules decide who gets a reply and which case study they see.

Job triage and proposals. Job-alert emails are read every minute, each job is rated strong, possible, weak or no fit with a reason, and a color-coded card lands in Slack. On request the agent drafts an 80 to 130 word proposal that answers the client's questions first and cites one real project. A person submits every draft because the platform does not allow bots.

Product pages and the design studio. For MEC Artworks, Claude vision turns product photos into copy, category, tags, attributes, alt text and SEO fields as hidden drafts, with price set by code within a band. An end-to-end test checks about 28 rules per site in about 4 minutes, replacing a 40-minute manual check. The current design studio lets visitors render a mosaic from a description, see it in a photo of their own room, or place a real catalogue piece at true tile scale; quote requests become CRM leads.

AI inside a product. In Groohve, our billboard management product, Gemini writes listing copy that the owner previews before saving, and a 113-tool MCP server lets owners run their business from Claude or ChatGPT with per-user permissions. DejaThink adds persistent memory, live team chat and a mission mode, with user-approved memories and EU data residency. For Floret, a model reads recent commodity prices and returns a structured trend, confidence and key points for traders.

Regulated work. For CureMD, ambient listening drafts coded SOAP notes (ICD-10, CPT, RxNorm) and queues orders once the clinician signs: 98% clinical note accuracy, notes in under 15 seconds and 30+ specialties, per CureMD's published figures. AOF opens brokerage accounts with guided forms and validation, and has no AI model in it at all. We include it because it shows the rule-first half of the job: clean, validated intake is what any later agent depends on.

Industries where we have built AI agents

The patterns carry across industries, but we only claim the ones we have built in. Each row below maps a small business industry to the work that backs it. For anything else we give general guidance rather than pretend to experience we do not have.

If you sell online, the ecommerce brands page goes deeper. Clinics and practices can start with healthcare and digital health, venues with hospitality, and software companies with SaaS product development.

How to get started

To get started with AI agents, write down one workflow, the person who owns it and the number you would use to judge it. Measure that number for a week. Then build or buy the smallest agent that drafts the work for review, and only widen its autonomy once the numbers hold.

If you want a team that has shipped agents across CRMs, stores, chat and clinical systems to scope that first pilot with you, tell us about the workflow. We will tell you honestly if a rule or an off-the-shelf tool would serve you better.