How to Build an AI Agent for Your Business — Without Buying One or Coding It From Scratch

Somewhere in your company there is a process that costs more than it should. Support tickets three people answer by hand. Quotes assembled from the same five sources every time. A report someone rebuilds every Monday morning. It works, it's expensive, and the cost climbs with volume.

So the question isn't whether you want an AI agent. It's whether one can run that process for less than your team currently does — and what getting one would actually cost you.

That answer depends almost entirely on which of four paths you take — and it's worth knowing up front that this whole category is young. The two classics are buy a ready-made agent from a platform, or build one on a framework with a development team. "Classic" here means about three years: the agent frameworks themselves only arrived in 2022–2023. For most of that short history these were the only two real answers, and they sit at opposite ends of the same trade-off — one locks you into someone else's product, the other turns you into a software company.

Two more paths have opened since. The workflow-automation tools — n8n, Make, Zapier — have been wiring services together for years, and recently grew AI-agent capabilities on top, which made them a genuine middle path. And most recently, capable coding agents made a fourth path possible: you can now grow an agent around the process you already run, instead of buying or building one. That path is newer than most procurement conversations, which is why it so rarely comes up in them.

This guide prices all four, with sourced and dated numbers. But price is not the only thing that separates them, and the two questions that matter most never appear on a quote: who has to drive this thing, and what happens when the process changes.

Table of contents

• Four ways to get an agent — and why the fourth is new
• What actually counts as a business agent
• The off-the-shelf answers and what they cost
• The fourth answer: how to build an AI agent by growing one
• What an AI agent really costs, four ways
• Which of your processes actually qualifies
• Why the last 20% is the expensive part
• Frequently asked questions

Four ways to get an agent — and why the fourth is new

Start with the two classics, because their cost shapes are opposites and both are real.

A platform agent bills by consumption: roughly $2 per conversation, or credits burned by the action. Cheap to pilot, and then it scales with use, until a busy month becomes a five-figure line item (all platform prices in this guide are sourced and dated to June 2026; they change monthly). A custom build inverts that shape entirely: developer-weeks before anything runs at all, then a system that's yours to keep — and yours to maintain forever.

Both are the right answer for someone. A 5,000-seat enterprise that needs governance and audit trails should probably buy a platform. A company whose core product is the software should probably build. Neither shape is designed for a mid-sized business that wants one process handled well, without a procurement saga or an engineering team of its own.

That gap is why the other two paths exist.

The middle path came first. The workflow-automation tools — n8n, Make, Zapier — have been around for years wiring services together, and only recently added AI-agent capabilities on top. The tools are not new; their agent layer is. For simple, well-defined flows they're fast and genuinely cheap. They hit a wall on complex logic, and someone still has to build and maintain them.

The fourth path is the genuinely new one, and it didn't exist until capable coding agents did. Point one at a real business process and it writes the scripts and tools that carry it out — so instead of buying a fixed agent or commissioning one, you grow one around the process you already run.

Here the obvious objection deserves a straight answer, because it's the one a good CTO will raise immediately: isn't "grow" just "build" with a faster developer? A dev shop can point a coding agent at a framework and ship you the same thing in half the time. And to be fair to them, a good one can ship you a genuine agent — LangChain and its peers build systems that reason and pick their own tools at runtime. So the difference is not "they build dumb software and we build a smart agent." That would be a cheap shot and it would be false.

The difference is what you're left holding on the Monday after go-live.

On the build path, what stays is the software. On the grow path, what stays is the loop that produced it.

A development shop uses a coding agent as a power tool, hands you the artifact, and goes home — and the machine that made the artifact walks out with them. On the grow path that machine is the thing you keep. The agent that wrote your process is still sitting there, still pointed at it, still able to change it. You didn't buy a deliverable; you bought a capability.

Two consequences follow, and they are the whole reason the fourth path is a different category and not a discount on the third.

Who has to drive it. Build speaks code: a software engineer creates the agent, and an engineer is back in the room every time it changes. Grow splits that job in two, and the split is the point. Someone still has to operate the substrate — set it up, wire the tools, keep the checks honest — and that person needs real skill; we'll come back to why that person is worth paying for. But the person who directs the work is someone who knows the process: a business-process owner, an operations manager, the person who actually does the job today. They describe what a good outcome looks like and judge whether the agent produced one, in the language of the business rather than the language of software. On the build path that person can only file a ticket. On the grow path they hold the steering wheel — and for most mid-sized businesses, they're already on the payroll.

What happens when reality moves. It always moves — prices change, a supplier's format changes, an exception becomes routine. On the build path, that is a change request: engineer, backlog, release. On the grow path, adaptation is the loop itself — the same directed cycle that produced the agent handles the change, because the agent is still there. The build path buys you a snapshot of your process. The grow path buys you something that keeps up with it.

So there are four ways to get an agent: buy a platform, assemble one from no/low-code parts, build one on a framework, or grow one on a coding-agent substrate. The rest of this guide prices all four — and the fourth gets the most space, because it's the one nobody has explained to you yet.

What actually counts as a business agent

One thing to settle before any of those numbers mean anything: the words on the price tag don't tell you what you're buying.

The label "AI agent" is now attached to very different products. A website chatbot that answers questions is sold as an AI agent. So is a system that reconciles your billing overnight without anyone watching. Start shortlisting vendors and you'll collect more examples of this within an afternoon — the same two words, an order of magnitude apart in what they actually do, and in what they cost. When you compare quotes, check what's under the label before you compare the numbers.

The useful test is not how autonomous the thing is. It's who leads the work.

If a person leads and the AI helps — you ask, it answers, you decide the next step — that's an assistant, however clever it sounds. If the AI leads the work and a person owns the judgment — it decides the next step, picks the tool, sequences the job, and a human sets it going and approves what comes out — that's an agent. The dial that matters runs from assistant to agent, and it is about leadership of the work, not about whether a human is present. A human being in the loop does not demote an agent to an assistant. It's the difference between a manager who does the job and a manager who runs someone who does the job.

So here is what this guide prices. A business agent is a system where the AI leads the execution of a real end-to-end process — not a single task, not a conversation — with the tools to act on its own, while a human starts it and owns the judgment calls. That's the thing worth paying for, and it's what all four cost comparisons below refer to. (Where on that dial your agent should sit is a cost question with a surprising answer — see why the last 20% is the expensive part.)

One flag before we go on: if the thing you actually need is the conversation — customers asking the same five questions all day, leads arriving with nobody to qualify them — then what you want is a chatbot, not an agent. Different product, smaller project, and we'll come back to it at the end with the numbers, because the honest answer for a lot of readers is the cheaper one.

Everything below assumes you genuinely have a process to hand over. If you want the full taxonomy of what an agent is rather than what it costs, that's our companion guide on what an AI agent is for business; the arc from tool to chatbot to agent is laid out in five generations of AI in business.

The off-the-shelf answers and what they cost

Three of the four paths are things you can buy or assemble today. Here's the shape of each one's cost, with the full numbers in the comparison table below. Every figure is sourced and current as of June 2026; re-check before you sign anything, because these change monthly.

Buy: enterprise platform agents

The platforms bill by consumption, and that is the whole story of their cost. Salesforce Agentforce runs about $2 per conversation, or you pre-buy Flex Credits and spend roughly 20 credits ($0.10) per standard action (Salesforce pricing). Microsoft 365 Copilot is $30 per user per month, with agent actions metered separately through Copilot Studio credits (Microsoft). SAP Joule meters per action too, and licensing analysts warn that customers who don't model adoption can face six-figure annual overage invoices (SAP licensing analysis). ChatGPT Enterprise is sold on a quote basis — OpenAI doesn't publish the number — and the figures circulating in the market (roughly $50–60 per seat, with a seat minimum) come from resellers and buyers, not from OpenAI. Treat them as estimates, not quotes; the only number that binds is the one on your own proposal.

The signature is the same across all four: cheap to start, then the bill climbs with every conversation, action, and credit — and you run your process the vendor's way, because it's their agent.

To be fair, there's a company this is right for. If you're a 5,000-seat enterprise that needs single sign-on, audit trails, procurement-grade support, and governance reviewed by a security team, buying a governed platform can be the correct call. The per-action bill is the price of not having to think about any of that. For a mid-sized business running one or two processes, it's overhead you don't need — but the concession is real, and it sharpens the case rather than weakening it.

Build: frameworks from scratch

The build path starts from the opposite end. Frameworks like LangChain, CrewAI, and AutoGen are open source — the tooling is free. What you pay for is developer time to assemble the plumbing, plus the model tokens the agent consumes once it runs. The cost driver is developer-weeks, and the hidden cost is everything after launch: you now own a piece of software, and someone has to maintain it as models change and the process evolves. You've solved the lock-in problem by becoming a software shop — a fair trade for some companies, but not the business most are in.

The middle path: no-code and low-code

Between buying and building sit the workflow tools. Self-hosted n8n runs about $3–7 a month for unlimited executions, plus your own LLM API fees on top; the cloud tier climbs from roughly $24 to $800 a month as execution volume grows (n8n pricing). Make runs from free to about $29 a month by operation count (Make). These are fast and cheap for simple, well-defined flows, but they hit a wall on complex logic, and you still need someone to build and maintain them. We've written before about the build-versus-buy decision for chatbots; the same logic extends to agents, with one more option than that framing allowed.

The fourth answer: how to build an AI agent by growing one

The fourth path is the one we use, and it's how to build an AI agent for your business without either a six-figure platform or a development team standing up framework plumbing.

The mechanism is a general-purpose coding agent used as an automation substrate — the approach behind the AI agents we build, and the one we run in our own production. Instead of configuring a vendor's fixed agent or assembling framework plumbing by hand, you give a capable coding agent (Claude Code is the one we run) your actual process. It writes the scripts and small tools that carry out that process, and those tools live as plain files in your own repository. When a step turns out to be brittle, the next iteration produces a better tool for it. The agent doesn't replace your process; it grows around it.

Three things keep this honest, and each one matters for what it costs.

A human directs and reviews — every time. The phrases "writes its own tools" and "self-improving" describe a human-directed engineering loop: a person and the agent iterate the prompts, scripts, and tools together, each cycle a little better. It is not the model retraining or modifying itself, and it is not autonomous, unsupervised tool-building. The judgment calls stay with a person. That human-in-the-loop design is structural, not incidental — and it's most of what you're paying for.

"Grow" is not "no-code." Someone has to drive the coding agent — you, if you have the skill in-house, or a partner who does. Don't let anyone sell you "anyone can do this." The substrate is cheap; the driver is not free.

The substrate has to be capable. A real business agent needs a capable model and room to work — the two multiply, they don't substitute. The model has to be good enough to reason about your process, and the system around it has to keep the relevant slice of that process in front of the model at every step (via retrieval, compaction, and sub-tasks — no agent holds an entire business process in one window, and any vendor who implies otherwise hasn't run one). Small, cheap models fail on the reasoning, and no amount of context rescues them. This is a real technical requirement, not a slogan.

One honest caveat on lock-in. The grow path has lower lock-in than a platform, because your process lives in portable files and scripts you own — but it isn't zero. You still depend on a capable model provider, and switching one costs real work: re-tuning prompts, re-validating tool calls, re-testing outputs. The accurate way to say it: your process is portable, and you choose the model. That's a materially better position than a platform that owns both.

Does it work? Here is our proof, and here is exactly what it isn't. This site's own publishing pipeline runs on this substrate — keyword research, drafting, multi-critic review, publishing — with the agent leading the work and a human owning the judgment. By the definition above that is a genuine business agent, and it is where the method in this article comes from: every article here goes through an eight-critic review gate that has to clear a quality bar before it can publish, and when a draft fails, the fix goes back into the agent's instructions rather than just into the draft. That gate is the unglamorous engineering most people skip, and it is the difference between an agent that produces work and an agent that produces work you'd sign.

The limit is worth naming plainly: we run this on ourselves. We do not yet have an external client running a grown agent — our external, paying proof is in chatbots, not agents. Vendors usually blur that line. We'd rather you knew which side of it we're on, and priced us accordingly.

What an AI agent really costs, four ways

First, price the thing you're comparing against — the way you run the process today. Every guide skips this, and it's the only number that decides whether any of the rest is worth doing. A mid-level US specialist costs roughly $9,000 a month fully loaded — around $70–75K of salary, plus payroll taxes, benefits, and workplace overhead. So the three people answering those tickets by hand are a $21,000–$27,000-a-month line item, and it grows with your volume. That is the incumbent. Everything below is competing with it, not with each other.

Now the four paths. The real AI agent development cost splits into three layers: one-time costs (build and integration), recurring costs (license, model tokens, hosting, connector fees, and maintenance labor), and the one almost every vendor omits — the human-in-the-loop expert who keeps the agent honest. Platforms hide the token line inside credits; nobody puts the expert on the invoice. Here's the comparison with all four paths and the lines made visible.

These are estimates for planning, not quotes. Vendor pricing changes monthly and every number below is dated June 2026 — the shape of each column is the durable part, not the digits.

* The substrate, honestly. For development and low-volume work, a Claude Code subscription runs $20/month (Pro) or $100–200/month (Max). But be careful with that number: subscription tiers are rate-limited plans built for a person working interactively — they are not a production runtime for an unattended process. A real business agent running on a schedule bills API tokens: Claude Opus 4.8 is $5 per million input tokens and $25 per million output (Claude pricing, June 2026). Prompt caching can cut the cost of a repeated prefix by up to ~90% on a cache hit — but read the conditions: writes carry a ~1.25× premium, the default cache lifetime is five minutes (a one-hour option exists at a 2× write premium), and prefixes below a few thousand tokens aren't cacheable at all. So a nightly agent should assume no caching benefit whatsoever, and an hourly one only with the longer TTL, priced accordingly. Model your real invocation pattern; don't plan on the best case.

A worked example, since we're asking you to price everyone else's: an agent that reads ~50,000 tokens of context per run and writes ~5,000, firing 20 times a business day, costs roughly 50K × $5/M + 5K × $25/M ≈ $0.38 per run — about $150 a month in tokens. Heavier context or higher frequency moves that into the high hundreds. That is the honest shape of "the substrate is cheap": cheap next to a $9,000/month specialist and next to per-action platform billing, not free, and not $20.

† Note what that unit is: Agentforce's headline price is per conversation — a chatbot unit, not a process run. It is not directly comparable to the columns beside it. This is the label problem from earlier in the article, showing up in the pricing itself.

Read the table honestly and the grow column does not say "free." The license is small and the build is low, because the agent generates its own tooling under direction. The real cost sits where it belongs: the human-in-the-loop expert who turns a capable coding agent into your business agent and keeps it producing work you'd sign your name to.

So what does a client actually pay? Two things, stated separately on purpose. There's the substrate — the cheap, public line above, which the client runs on their own account. And there's the expert retainer — the engagement that supplies the person who directs the substrate. The substrate cost is not the service price; conflating the two is exactly the mistake the platforms encourage. The agent is cheap to run. The expertise to run it well is what you're buying.

Which of your processes actually qualifies

The grow path is powerful, but it is bounded, and an honest cost guide has to draw the boundary. A process is a good agent candidate when it meets three tests.

• It's repeatable. It happens often and follows a recognizable pattern. A monthly reconciliation qualifies; a once-a-decade decision does not.
• It's computer-based. The inputs and the actions both live in software the agent can reach. If a step requires a phone call or a physical signature, that step is outside the agent's hands.
• It's review-tolerant. A human can check the output before it becomes consequential, and an occasional error during the learning phase is survivable.

That third test is where the boundary bites. Some processes are not good candidates no matter how repeatable they are: a loan approval, a regulatory filing, a medical or legal decision, anything high-stakes or compliance-critical where an unreviewed error is a serious problem. Low-frequency, one-off tasks don't qualify either — there's nothing for the agent to learn against. "Almost any process" is the marketing version; the true version has these edges.

If your candidate just failed one of those tests, here is the useful thing to do next. Most of the time, the work that doesn't pass isn't a process at all — it's a conversation. Customers asking the same questions, leads arriving unqualified, bookings nobody chases. That's a chatbot, and it's a genuinely different product: a fixed-scope project rather than a directed loop, running $3,000–$20,000 depending on channels and integrations rather than an ongoing retainer, and typically live in four to ten weeks. It is also the thing we have actually shipped for paying clients — Royal Finance (30+ loan products, sales) and a yacht-charter booking bot with natural-language search and CRM lead capture — where the agent work on this page is, honestly, proven on ourselves and not yet on an external client. If that's your problem, take the cheaper, better-proven answer: what our chatbots cost and do. There is no shame in the smaller project, and a vendor who won't tell you which one you need is selling, not advising.

Notice that the review-tolerance test is exactly why the human-in-the-loop expert is structural, not optional. The agent earns its keep on the processes a person can check, which means a person has to be in the loop by design. That's not a cost you can engineer away. Not sure which of your processes pass these three tests? That's the first question our AI consulting work answers, and it's the cheapest hour you'll spend on this.

Why the last 20% is the expensive part

Every vendor sells autonomy as the destination: hands off, set it and forget it, no humans required. Run the arithmetic and the destination turns out to be the wrong place to stand.

Say your agent handles 80% of cases end-to-end and hands you the rest. (Take 80% as a working figure, not a law — the real number is process-specific, and the argument below holds for any figure short of 100%.)

That is not "80% of a solution." The ceiling it puts on your throughput is five times the volume per person: one case in five now needs a decision instead of five in five. You will not hit that ceiling, and we'd rather do the arithmetic properly than sell you the headline. Two things pull it down. You still review what the agent produces — that's the whole point of a human in the loop, and reviewing is cheaper than doing but it isn't free. And the cases it hands back are, by construction, the harder ones. Put realistic numbers on both and the honest answer lands nearer two to three times the volume per person. That is still a transformation of your cost base, and you got it on the easy 80%: the common, well-patterned cases with plenty of examples to learn from.

Now try to buy the last 20%. Each remaining case is harder than the one before it — that's what makes it remaining. Some are rare, so there's little to learn from. Some are high-stakes, so they must be checked anyway. Some need a phone call. Fewer examples, more edge conditions, more effort per point of coverage. And the environment keeps moving: prices change, a supplier's format changes, an exception becomes routine. The tail refills — never as fast as you close it, and never quite to empty. You are not filling a fixed gap; you are chasing a receding one.

You can push a long way into that tail with engineering — guardrails, confidence thresholds that escalate to a person, regression tests, canary runs. That is real work and we do it. But notice what it buys: coverage, not judgment. Checks tell you the agent probably got it right. They cannot tell you what to do about the case where the right answer depends on knowing your customer, your margin, or what you promised someone last quarter. To automate that, you'd need a supervisor with broader context and better judgment than the process it oversees — and here we'll be plain that this is an argument, not a measurement: we expect such a supervisor to cost more to build and keep running than the human it was meant to replace, because broad context and good judgment are exactly the expensive parts. It would also inherit the liability that human was carrying — and an unsupervised judgment call that goes wrong doesn't merely underperform. It annoys customers, damages your brand, and increasingly creates legal exposure.

So the human in the loop is not a training-wheels stage you graduate from, and it is not a vendor apologising for an incomplete product. There is a stopping point well short of full autonomy, and it is further from the finish line than anyone selling autonomy wants to admit. You take the multiple and you keep the judgment. Almost nobody in this market will tell you that, because "we'll get you most of the way and then deliberately stop" is a harder thing to sell than "hands off."

It is also the honest answer to "what am I actually paying for?" Put the four paths side by side: Buy is fast but locked-in, and the bill grows with use. Build is yours — and yours to maintain, with an engineer on call every time reality moves. Grow keeps your process portable, runs on a cheap substrate, and is directed by someone who knows the work — the right shape for a mid-sized business that wants one process handled well.

"So why wouldn't we just do this ourselves?" You might — and we'd rather say so than pretend otherwise. The substrate is public and the tokens are cheap. If you have someone who knows the process cold, has the patience to direct an agent through the messy first weeks, and has the judgment to catch output that's subtly wrong, you can run this yourself. That's a real option and some companies should take it.

Notice, though, what the last section actually said: the hard part was never the code — there isn't any — and it was never the tool. It's building the checks that tell you when the agent is wrong, and then owning the loop week after week while the tail keeps refilling. That is a job, not a project. Most in-house attempts don't fail on the technology; they fail because the loop had no owner, the operations manager's day job reasserted itself by week three, and a half-directed agent quietly produced work nobody could trust. What you'd be paying us for is the decomposition, the checks, and the discipline to keep showing up — the same eight-critic gate we run on ourselves, pointed at your process.

There's also a middle path we'll happily quote: we stand the agent up and train your own process owner to drive it, then step back to a lighter retainer. Lower cost, more involvement from your team, and the capability stays in-house. Ask for it.

Start with the cheap step, not the big one. Before anyone quotes you anything, the useful question is which of your processes pass the three tests above, what one of them costs you today, and what an agent for it would actually cost. That's a free AI readiness assessment — an hour, not an engagement. We'll tell you if the honest answer is a chatbot, or a cheaper fix, or nothing at all.

Frequently asked questions

How much does it cost to build an AI agent?

How much an AI agent costs depends entirely on the path. A platform agent is cheap to pilot and then bills by consumption — per-action credits that reach five or six figures a year at scale. A custom framework build is free tooling plus developer-weeks of labor, with maintenance you own and an engineer needed every time the process changes. The grow path runs on a modest substrate cost — API tokens for a production agent, or a $20–200/month coding-agent subscription for development and low-volume work — plus the real cost: the human-in-the-loop expert who directs it. The cheapest line item is never the deciding one; the expert and the maintenance are.

Can I build an AI agent without a development team?

Yes — and this is the clearest difference between the build path and the grow path. Building on a framework requires a software engineer, at creation and again every time the process changes. On the grow path the coding agent writes the scripts and tools itself, so the person directing it is someone who knows the process, not someone who knows Python — a business-process owner or operations manager, describing what a good outcome looks like and judging whether the agent produced one. What you can't skip is that person. Someone still has to operate the substrate competently — that skill is real and it is not free. But the person steering, the one who decides what "right" looks like, is the process owner, and anyone who tells you no human is needed at all is selling you something.

Should I buy an AI agent platform or build my own?

For most mid-sized businesses, neither cleanly. Buying a platform is the right call if you're a large enterprise that needs governance, single sign-on, audit trails, and vendor support — the per-action bill buys all of that. Building from scratch makes sense only if you're prepared to own and maintain software. For a company that wants one or two processes handled well, growing an agent on a coding-agent substrate usually fits better: lower lock-in, a cheap substrate, and an expert in the loop. Whether you build an AI agent for business in-house or have a partner create one, the grow path keeps the process yours.

What's the cheapest way to run an AI agent?

On a pure license basis, the grow path's substrate is cheapest — API tokens for a scheduled agent, or a $20–200/month subscription for development work. But "cheapest to run" is not "cheapest to own": the cost that decides your total bill is the expertise that directs the agent and the maintenance that keeps it working. A platform that looks cheap in a pilot becomes the most expensive option once consumption scales; a cheap substrate without an expert produces work nobody can trust. And chasing the last 20% of autonomy costs more than the human it removes — the 80/20 split is where the arithmetic says to stop. Price the whole picture, not the license line.