AI agent development that survives production

AI agent development is building software where a language model decides which steps to take, calls real tools to take them, reads the result and decides again — until a goal is met or a limit stops it. The model is not the product; the loop around it is. That loop is where the engineering lives: what the agent is allowed to call, how failures come back to it, how state is carried between steps, what happens when it goes off course, and how you know afterwards whether it did the job. A chatbot answers. An agent acts, and acting is what makes it a software project rather than a prompt.

A working prototype for a narrow task usually takes one to three weeks. Getting that prototype to a state you would put in front of customers takes considerably longer — typically two to four months — and almost none of that time goes into prompting. It goes into integrations that fail in ways the model has to handle, an evaluation set that catches regressions, permissions, logging you can debug from, and the human handover path for the cases the agent should not decide alone. Teams that budget for the demo and not the second phase are the ones whose agents never leave the pilot.

Start with the lightest thing that solves your task. For a single agent with a handful of tools, the model provider's own SDK and a loop you wrote yourself is often the whole job, and it leaves you able to debug every step. Reach for an orchestration framework when you genuinely need durable state, branching control flow, retries across long-running steps or several coordinated agents. The cost of a framework is not the API, it is that the parts you most need to inspect on a bad day are inside somebody else's abstraction. Whichever you choose, keep the prompts, tool definitions and evaluation set outside the framework so switching later is a day, not a rewrite.

There are two costs and teams routinely plan for the wrong one. Build cost: a narrow internal agent typically lands between $8,000 and $30,000 of engineering; a customer-facing agent with real integrations, evaluation and monitoring is more often $30,000 to $120,000. Run cost: token spend is usually the smaller line and the easiest to reduce — routing simple steps to a cheaper model, caching, and trimming context regularly cut it by half or more. The line teams forget is maintenance: models are deprecated, APIs change, and your eval set needs re-running. Budget roughly 15–25% of build cost per year to keep an agent honest.

You constrain what it can do rather than hoping it behaves. In practice: ground answers in retrieved documents and make the agent cite the source it used; give tools strict, typed arguments and validate them before execution; let a tool return an honest "not found" and teach the agent that returning nothing is an acceptable outcome; cap the number of steps and the spend per run; and put a human approval gate in front of anything irreversible — payments, deletions, outbound messages to customers. Then measure it. An eval set of fifty real cases, including the awkward ones, tells you more about reliability than any amount of prompt tuning.

Use a no-code platform when the task is standard, the volume is modest and the cost of a wrong answer is low — internal FAQ routing, lead triage, drafting first replies. They are genuinely faster to a working result and you will learn what the task really needs. Build custom when the agent must touch your own systems with real permissions, when latency or unit cost matters at your volume, when you need your own evaluation and audit trail, or when the agent is part of the product you sell. The common path is sensible: prove the workflow on a platform, then rebuild the parts that earned it.