In mid-2025 Gartner put out a forecast that should have ended more sales calls than it did: more than 40% of agentic AI projects will be scrapped by the end of 2027, killed by runaway costs, fuzzy business value, and risk controls nobody budgeted for. The same analysts coined a phrase for the thing driving the bubble — 'agent washing' — after estimating that of the thousands of vendors claiming to sell agentic AI, only a tiny fraction were building anything that deserved the name. That is the real state of custom AI agent development right now: a market where the word 'agent' is doing most of the work, and the software is doing the rest.
The pitch everyone repeats
The conventional story goes like this. Chatbots were step one. Now you need autonomous agents — software that reasons, plans, calls tools, spawns sub-agents, and grinds away at goals without a human in the loop. You will orchestrate a fleet of them. One agent researches, one writes, one reviews, one books the meeting, and the org runs itself while you sleep. Every deck has the same diagram: boxes with little robot icons, arrows looping back on themselves, the word 'autonomous' in bold. The implication is that if you are not building multi-agent systems, you are already behind.
It is a good pitch because it sells the most expensive version of the project. Autonomy is open-ended, and open-ended work bills forever. The trouble is that the diagram and the production system have almost nothing to do with each other. The agents that survive contact with real users are narrow, heavily constrained, and mostly deterministic — and the parts that actually make them work are the parts the diagram leaves out.
You don't have an agent problem
Here is the read most buyers miss: the majority of tasks people want to 'build an agent' for are not open-ended at all. They are workflows. There is a known starting state, a known set of steps, a known finishing line — extract these fields, check them against that system, route the result, draft the reply for a human to approve. A workflow like that does not need a reasoning loop deciding what to do next. It needs a pipeline that does the same correct thing every time, with a language model dropped in at the two or three points where genuine ambiguity lives.
The distinction matters because non-determinism is the enemy of production software, and an agent is a machine for manufacturing non-determinism. Every autonomous loop is a place the system can decide to do something you did not anticipate. Give a model the freedom to choose its next ten actions and you have not built a feature — you have built a surface area you now have to test, monitor, and apologize for. The most reliable 'agent' I have seen ship was a state machine with three LLM calls in it. Nobody put it on a slide because it did not look like the future. It just worked, and it kept working on a Tuesday when the model vendor quietly changed a default.
What the word "custom" should actually mean
'Custom AI agent development' implies the custom part is the agent — some novel architecture, a proprietary orchestration layer, your own twist on the reasoning loop. It almost never is, and it almost never should be. The orchestration frameworks are commodities now; LangGraph, LangChain, CrewAI, MCP and the rest are free, mature enough, and converging on the same handful of patterns. Spending your budget reinventing them is how you end up in the 40% that gets cancelled.
The custom is everywhere else. It is your data — messy, contradictory, scattered across a CRM, a Postgres database, and a folder of PDFs nobody has opened since 2019. It is the retrieval layer that makes that data answerable without hallucination, the tool definitions that let the model touch your real systems safely, the guardrails that decide what it is allowed to do unsupervised, and the evaluation harness that tells you whether the thing is getting better or quietly worse. That is the work. It is unglamorous, it is specific to you, and it is the only part a vendor cannot copy-paste from a tutorial. When a team sells you 'custom agents' and the customization is the prompt, you are buying a demo.
Where autonomy actually earns its keep
None of this means agents are a fraud. It means autonomy is a cost you pay for a specific benefit, and the benefit only shows up when the task is genuinely open-ended — when you cannot enumerate the steps in advance because they depend on what the agent finds along the way. Open-ended research across sources. Multi-step debugging where the next move depends on the last error. Coding assistants that explore a repository they have never seen. These are real agent problems, and on them a constrained pipeline genuinely fails, because the whole point is that the path is not known up front.
That is also where my own bias comes from. At EltexSoft we have run a growing Python and AI/ML practice for the last couple of years, building production AI pipelines, and we use coding agents like Claude Code and Cursor every day — as reviewed accelerators, never as crutches. We have shipped genuinely agentic work, including a generative AI tool for an entertainment client that reads full screenplays and generates visual scene compositions, compressing months of a sketch artist's work into minutes. That is a real open-ended problem and an agent belongs there. The honest lesson from building it is the opposite of the marketing: the autonomy was the easy, late part. The hard, custom part was the plumbing, the evaluation, and the constraints that kept it from confidently producing garbage.
Build the boring 90% first
So commit to the inversion: the agent is the last ten percent, not the first. Before any reasoning loop exists, you need an evaluation set that tells you what 'correct' means for your task, observability that shows you what the model actually did on every run, and the tightest possible tool scope so a wrong decision is contained instead of catastrophic. Build that scaffolding and most projects discover they did not need much autonomy after all — the deterministic pipeline plus two model calls clears the bar. Skip it and you are flying an autonomous system blind, which is the precise recipe Gartner described for the projects that get killed.
There is also a discipline question hiding underneath the technical one, and it is the part I am least willing to hedge on. The reason agent projects detonate is rarely the model — it is scope. We once took on a stalled build, Meal4U, where the previous team had simply failed to deliver, and spent a week doing nothing but deconstructing scope, re-estimating it roughly ten times, and cutting thirty to fifty percent each pass until we found the smallest thing that could actually ship. Custom AI agent development needs exactly that reflex, and the hype is engineered to suppress it. 'Autonomous, multi-agent, self-improving' is scope expansion sold as ambition. The job is to find the smallest agent that solves the real problem, and most of the time that agent barely looks autonomous at all.
This connects to what we think the whole category gets wrong, laid out in what AI consulting really is. For shipped-software engagements, see our AI engineering services.
The position, stated plainly
Custom AI agent development is worth doing, and it is worth doing well — but not the way it is being sold. Stop buying autonomy by the pound. Assume your problem is a workflow until it proves otherwise, build the evaluation and guardrails before the reasoning loop, treat the orchestration framework as the cheap commodity it is, and spend your real money on the data, retrieval, and constraints that are unique to you. Reserve genuine agent autonomy for the genuinely open-ended slice of the work, and keep a senior human reviewing what it does — we do not merge a line of code without a second senior engineer on it, and we are not about to hand an LLM looser rules than we give ourselves. Do that and you land in the 60% of projects that survive. Buy the diagram with the robot icons and you have already met your cancellation date; you just have not scheduled it yet.