AI Agents in Practice: A Real Setup Story

Everyone seems to already know the answer to what is an AI agent: something that makes its own decisions and uses tools on its own. Fair enough, but that definition doesn't tell you how you'd actually build one, what it costs, or where it tends to break. This piece skips the definitions and goes straight to a real setup, real cost ranges, and the problems that show up in practice.

Our guide to AI infrastructure decisions already covered how agents differ from chatbots and RAG at a summary level; here's what that difference actually looks like once you're building one.

What separates an AI agent from a chatbot?

Ask a chatbot to schedule a meeting and you'll get you could check your calendar back, it answers with information, it doesn't act. Ask an AI agent the same thing and it checks your calendar, finds an open slot, books the room, and sends the invite, it carries the task through from start to finish on its own.

That difference changes the risk profile too, and it's worth sitting with for a second. When a chatbot gets something wrong, you get a wrong answer and that's the end of it. When an agent acts on wrong information, it may have already approved the wrong order or issued a refund it shouldn't have, and now someone has to undo it. Technically, an agent is a system that manages state, plans across multiple steps, and calls tools when needed, sending an email, querying a database, processing a payment; it generates text and then reaches into your systems to act on it.

This distinction matters in practice because plenty of companies buy an agent when a chatbot would have done the job, or the reverse, they try to force a chatbot into a role that genuinely needs multi-step execution. Get this wrong in either direction and you'll be unhappy with the result no matter how good the underlying model is.

A real setup story: an invoice processing agent

A supply chain team was processing 40-50 invoices a week by hand, roughly two hours per invoice: opening the email attachment, checking the totals, entering the data into an inventory spreadsheet, and creating the order in their ERP. The agent they built works like this: an incoming PDF attachment gets pulled automatically, sent to a vision-capable model, the extracted data gets checked against an existing inventory spreadsheet, and if it matches, the order gets created in the ERP automatically.

The result: roughly 90% of invoices now get processed without any human involvement, and the team saves 8-10 hours a week. It was built with an off-the-shelf automation tool (n8n) in a matter of hours, and the operations manager learned to modify the workflow themselves. What this example teaches is that an AI agent doesn't have to be a months-long engineering project; a narrowly scoped agent aimed at one repetitive task can go live in a few days and deliver real, measurable time savings.

The remaining 10%, a mismatched total, an unreadable scan, an unrecognized supplier format, gets routed to a person automatically; the agent flags it and waits rather than guessing. That design choice is really the source of the whole project's reliability: the agent knows what it doesn't know, and that's exactly where a human takes over. The same principle shows up in other fields too; a security team took a months-long investigation process and rebuilt it with n8n in two days, cutting investigation time from weeks down to about half an hour, which shows the same narrow-scope pattern travels well across very different domains.

What tools do people actually build these with?

Teams that write code tend to reach for open-source frameworks like LangGraph and CrewAI, or provider-specific tools like the Claude Agent SDK. For companies that want to build without writing code, n8n's AI Agent node is a genuinely accessible option, and it's cheap enough to self-host on a small server, around $5-10 a month.

Framework choice has a direct line to your monthly bill. Agents run in loops, so token consumption can run far higher than a normal chat session; in one documented case, a startup spending $7,800 a month on CrewAI switched to LangGraph and got the same result for $3,500. That decision reaches well beyond development convenience, straight into your ongoing operating cost.

Another practical yardstick worth using: how many steps does your agent take to touch an external system, email, CRM, payment. Each additional step compounds both token cost and failure risk; a three or four-step agent tends to run reliably, chains past ten steps get progressively harder to test and debug. Keeping the step count low on your first project is the simplest way to keep both cost and risk under control.

The real cost picture

Industry figures put a proof of concept at $5,000-$30,000, a simple reactive agent at $10,000-$50,000, a fuller MVP at $20,000-$60,000, and a complex, multi-step enterprise agent system at $100,000-$500,000 and up. A sample budget breakdown: $5,000 for discovery, $22,000 for development and RAG integration, $10,000 for system integrations, $5,000 for testing, $3,000 for launch, roughly $45,000 total.

Setup cost is only the visible part of the iceberg. It typically makes up just 25-35% of the three-year total cost of ownership; annual maintenance adds another 15-30% of the setup cost, and monthly running costs after launch can range from $500 to $15,000. When you budget for an agent project, plan for at least a year of operation, not just the build.

Local development teams outside the US market usually bring the labor portion of these numbers down in absolute terms; API and infrastructure costs stay in dollar terms regardless. A narrowly scoped agent like the invoice example above can get built for a few thousand dollars total, well under the six-figure numbers, those large numbers generally belong to multi-step, multi-system enterprise agent architectures.

Why do most agent projects fail?

Industry reports suggest a meaningful share of enterprise agents that run flawlessly in a controlled demo fail to hold up once they hit real workflows; Gartner forecasts that over 40% of agentic AI projects will be cancelled by 2027. That's a striking number, but it tracks with what shows up in the field, an agent that performs beautifully in a demo often gets caught off guard by how messy real data actually is.

The main failure modes: the model tries to call a tool that doesn't exist (a hallucinated tool call), a multi-step plan breaks down partway through, a malicious user tries to manipulate the model (prompt injection), and runaway costs from an uncontrolled loop. Only a minority of organizations have a mature governance model in place for autonomous agents; most are operating largely without one. That's exactly why a human approval point on every high-stakes step is still the most reliable safety net available, RAG reduces hallucination risk but it's not sufficient on its own.

Market size figures vary source to source, but the growth direction is consistent: the agentic AI market is estimated in the roughly $9-11 billion range in 2026, with multiples of growth expected in the years ahead. Enterprise interest is high too, a large share of IT leaders at big companies are highly interested in agentic AI, but only a small fraction have actually scaled it into production. That gap, high interest, low real production, traces directly back to the failure modes above.

A concrete scenario: a customer request agent

Picture a small e-commerce business where the support team answers the same handful of questions dozens of times a day, where's my package, how do I return this, is this in stock. The agent they build handles these over WhatsApp automatically: it checks the shipping tracker for a live status, and it opens a return request directly in the system.

The critical decision here is exactly where the human approval point sits. The agent can open a return request, but it doesn't process the refund on its own, that last step still needs a person to sign off on, since it's hard to undo. Lower-risk tasks, like reporting shipping status, run fully autonomously. In month one, the volume of questions the support team has to handle by hand drops noticeably, freeing them up for the more complex requests that actually need a human.

In month two, the team tries expanding the agent to product recommendations, and runs into a snag: the agent recommends items that are technically out of stock, because inventory only updates weekly instead of daily. It's a lesson that shows up again and again in agent projects, an agent is only as good as the data it's connected to. The problem isn't the agent, it's the data pipeline feeding it; once the team moves stock updates to a daily cadence, the recommendations get accurate again.

So what should you actually do?

• Scope your first agent project narrowly, around a single repetitive task, rather than a large, multi-step system out of the gate.
• Define a human approval point for every action that's hard to undo, payments, refunds, contract approvals.
• Weigh framework choice on token consumption and monthly cost, not just development convenience.
• Budget for at least a year of operation and maintenance, not just the initial build.
• Don't stop at demo performance, test against real, messy data before you go live.

AI agents aren't a future promise anymore, they're something you can build today; but the best-performing agent is usually the narrowest and best-supervised one, not the most impressive one. Skip the vision of automating everything at once, find the one repetitive task your team complains about most this week, and start your agent decision there.