AI agent development is the work of designing, building, testing and running software in which a language model chooses the next step and calls tools toward a goal. The model loop itself is short. Most of the effort goes into the tools, limits and tests around it.
It matters when a task's next step depends on what the software finds along the way. Otherwise, Anthropic's engineers recommend the simplest solution possible, which "might mean not building agentic systems at all." When you do build one, treat its final message as weak evidence. OpenAI's report on two internal coding agents describes one that removed a monitoring integration "and then falsely claimed to the user that it had not removed the monitor."

What Is AI Agent Development?
AI agent development is the process of turning a goal into a working agent and proving it reaches the right end state. An agent is a system in which the model decides which step comes next. Anthropic separates workflows, which run "through predefined code paths," from agents, which "dynamically direct their own processes and tool usage."
OpenAI's practical guide to building agents adds a useful exclusion. "Simple chatbots, single-turn LLMs, or sentiment classifiers" use a model but are not agents, because the model does not control the work.
Gartner predicted in June 2025 that over 40% of agentic AI projects will be canceled by the end of 2027, citing "escalating costs, unclear business value or inadequate risk controls." That is a forecast, not a measured rate. All three can be scoped before the first line of agent code.
This guide follows one real system with agent steps inside it. Waggle is an open-source, read-only auditor of code and connected data that Theresa built. Its engine proposes suspected problems, called hypotheses, checks each against the code and data under a budget cap, and reports a claim as a finding only when it passes an evidence gate.
Get Started with Theresa for FREEHow Does AI Agent Development Work?
An agent runs a loop. The model reads the task and the results so far, then requests a tool call or returns a final answer. The application runs the tool, adds the result to the conversation and asks the model again. The ReAct paper described this interleaving of reasoning and "task-specific actions" in 2022.
The developer writes little of the loop itself. They write what it touches: the tools, the instructions, the checks on each result and the rules that stop it. Anthropic calls tools "a contract between deterministic systems and non-deterministic agents". An error such as customer_id must be numeric, got ACME-12 lets the model fix its call; invalid input leaves it guessing.
If a step always happens the same way, such as validating an ID, write it as a normal function. Reserve the model for steps where the right action depends on earlier results.
Every loop also needs stop conditions: the model says it is done, or the application stops it at a step limit, timeout or budget. In Waggle's engine, each lane, a strand of investigation with its own budget cap, stops at that cap. The cap stopped the lane as designed. The bug was in what the run recorded afterwards, covered in the lifecycle section.
Get Started with Theresa for FREEKey Components of AI Agent Development
OpenAI's guide names three core components: a model, tools and instructions. A production agent needs a few more.
| Component | What you decide | What goes wrong if you skip it |
|---|---|---|
| Model | Which model handles which step | Cost grows on easy steps, or hard steps fail quietly |
| Instructions | The goal, rules and guardrails, as plain policy | The agent fills gaps with guesses |
| Tools | A few well-named actions with clear errors | The model picks the wrong tool or misreads its result |
| Protocols | MCP for tools and data, A2A for other agents | Fine for a few in-house tools; past that, each new system needs its own adapter |
| State | What the agent saves between steps and runs | A resumed task repeats or skips work |
| Scaffold | The code that runs the loop, budgets, retries and stops | Runs end without saying what they left unfinished |
| Permissions | What the agent may read, write and spend | One bad step changes production data |
| Evals | Test cases graded on the end state | Users find the failures first |
The Model Context Protocol specification warns that tools "represent arbitrary code execution" and says hosts "must obtain explicit user consent before invoking any tool." Treat every tool result as untrusted input too, since a web page or email the agent reads can carry instructions. An agent that reads outside content should not hold write tools unless a person approves each call.
Waggle shows two of these decisions. It is read-only, so a wrong step cannot change the code it audits. Its evidence gate turns any unsupported claim into an "open question." The claim audit behind the gate is a model checking a model, so it filters weak claims but does not replace a test.
Get Started with Theresa for FREETypes of AI Agents
Most lists of agent types come from Russell and Norvig's textbook, Artificial Intelligence: A Modern Approach. The table maps its five types to what teams build with language models today. The mapping is our interpretation.
| Textbook type | What it looks like in an LLM system today |
|---|---|
| Simple reflex | A router that sends each request to a fixed handler |
| Model-based reflex | An agent that saves task state and reads it before acting |
| Goal-based | A tool loop that acts until a goal is met or a limit stops it |
| Utility-based | A loop that scores options, such as an evaluator ranking drafts |
| Learning | A system the team improves offline by changing prompts, tools or models |
An LLM agent in production does not usually update its own model. It changes only when its team changes it.
Anthropic's post gives a more practical list: prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer and autonomous agents. The first five are workflows with model steps inside. Waggle's engine fits there: its stages run in a fixed order, and the model chooses steps only inside each stage, the structure we would recommend for a first production agent. Start with one agent, and split work across several only when one agent's instructions grow too long to follow.
Get Started with Theresa for FREEAI Agent Development Lifecycle
The lifecycle runs from design to prototype, evaluation, deployment and monitoring, then back to design. Every change to a prompt, tool or model reruns the evals.
Anthropic's guide to evals for AI agents separates the transcript from the outcome. A flight-booking agent might say "Your flight has been booked," but the outcome is "whether a reservation exists in the environment's SQL database." Outputs vary between runs, so Anthropic runs several trials per task.
The τ-bench benchmark also grades the database at the end of a conversation. In 2024, its best function-calling agents succeeded on under 50% of tasks.
Waggle's engine had a failure of this kind. A lane hit its budget cap and left a hypothesis open. The run recorded no gap, and the next re-scan reused that result as checked.

An end-to-end test found the problem; Waggle did not, since it was the system under test. Our AI agent debugging guide tells the same bug from the debugging side.
Assert on what each run leaves behind, including every item a stop left unfinished.
Protect the tests too. OpenAI's agent "replaced an earlier regression test intended to preserve monitoring with one requiring that monitoring was not present." Keep the eval set outside the agent's write access.
Get Started with Theresa for FREEFrameworks Used in AI Agent Development
A framework supplies the loop, tool calling, state and tracing. The table lists the main options alphabetically, as of November 18, 2026.
| Framework or runtime | What it gives you | Status |
|---|---|---|
| Amazon Bedrock AgentCore | Managed runtime for agents built with most frameworks | Any framework, any model (AWS) |
| Claude Agent SDK | The agent loop and tools behind Claude Code, as a library | Renamed from Claude Code SDK |
| Claude Managed Agents | An agent scaffold Anthropic runs, or you self-host | Beta |
| CrewAI | Python framework: Crews for autonomy, Flows for event-driven control | Open source (MIT) |
| Gemini Enterprise Agent Platform | Google Cloud's agent platform with Agent Runtime | Took in Vertex AI and Agent Builder on 2026-04-22 |
| Google ADK | Agent kit for Python, TypeScript, Go, Java and Kotlin | 2.0 adds graph workflows |
| LangChain and LangGraph | Quick agents, plus a lower-level runtime for long-running ones | 1.0 since October 2025 |
| Microsoft Agent Framework | .NET and Python framework joining Semantic Kernel and AutoGen | 1.0 on 2026-04-03 |
| OpenAI Agents SDK | Agents, handoffs, guardrails and built-in tracing | Successor to Swarm |
| Pydantic AI | Typed agent loop with swappable models and Pydantic Evals | Open source |
Older guides still recommend retired names. Microsoft's Agent Framework 1.0 announcement tells AutoGen and Semantic Kernel users "Now is the time to migrate." Google's Gemini Enterprise Agent Platform release notes say "Agent Engine is now Agent Runtime." OpenAI shut down its Assistants API on August 26, 2026.
Anthropic warns that frameworks "can obscure the underlying prompts and responses, making them harder to debug," and suggests starting with model APIs directly. Our guide to enterprise AI agent deployment compares the managed runtimes in more depth.
Get Started with Theresa for FREESteps to Build an AI Agent
If no one on your team has shipped model-based software, decide first whether to build it yourselves or have it built; the table in the framework-choice section below covers both.
1. Confirm the task needs an agent
OpenAI's guide points to complex decisions, rules that are hard to maintain, or heavy reliance on unstructured data. "Otherwise, a deterministic solution may suffice." Theresa's free Observation app ranks a team's highest-cost workflows, which finds candidates but builds nothing.
2. Prototype by hand
Run the task in a chat window, pasting in what each tool would return. If the model keeps failing after several adjustments, the task may not suit an agent.
3. Design tools and permissions
Anthropic's tool guidance favors a few well-chosen tools, clear names and short, useful responses. Start read-only and add each write action behind an approval step. Waggle's audit only reads; the separate fix command in its Claude Code plugin writes to a branch, one commit per finding, and asks before each step.
4. Set stop conditions and record what they leave
Give every run a step limit, a timeout and a budget. When one fires, the run must record each item it did not finish.
5. Build the eval set from end states
Check what changed in the system, not what the agent said. Run each case several times, and include budget-exhausted, tool-error and timeout paths.
6. Deploy with approvals and traces
Require human approval for actions that change data or move money. Turn on tracing so reviewers can follow each model and tool call.
7. Budget the running cost
Cost grows with steps, because each iteration resends the growing conversation; prompt caching cuts the cost of the repeated part. For scale, Anthropic's price list on November 18, 2026 showed Claude Sonnet 5.5 at $2 and $10 per million input and output tokens, and Managed Agents adds $0.08 per session-hour. Measure tokens per task in your evals before estimating a bill.
Get Started with Theresa for FREEAI Agent Development Use Cases
Agents fit work where each case differs and the next step depends on what the agent finds. Gartner adds a caution: "Many use cases positioned as agentic today don't require agentic implementations."
| Use case | Why the next step varies | What to check first |
|---|---|---|
| Support and refund decisions | Each case has its own history, policy limits and evidence | The refund amount above which a person signs off |
| Coding agents | The next edit depends on what the code and tests show | That the agent cannot edit the tests or monitors that judge it, as OpenAI's incident shows |
| Research and market intelligence | Each source suggests the next search | Whether its sources are complete and current |
| Operations monitoring and alerts | An anomaly's cause decides who gets alerted | That data agrees across systems before alerts go out |
Two of Theresa's anonymized case studies show the data work agents depend on. At a film and TV media group's international division, work ran by hand, "down to staff scrolling YouTube every day." Theresa's team built a data platform from scratch plus agents for market intelligence, creator discovery, signing decisions and copyright risk, and the case study reports 8,000+ hours freed per year.
At a quick-service food chain, store data sat in separate systems. The build there was monitoring and recommendations, not an agent. Theresa's team built a unified store data foundation, store monitoring with anomaly alerts, and per-store recommendations, with a first version live in month 3.
Both projects started with a data foundation. If your agent's tools would query data nobody trusts, fix the data before you build the agent.
Get Started with Theresa for FREEHow to Choose an AI Agent Development Framework
Who builds and runs the agent comes first, because it decides whether you pick a framework at all.
| Question to answer first | If the answer is... | Sensible starting point |
|---|---|---|
| Who builds and runs it? | Your engineers, on your infrastructure | An open-source framework above |
| Who builds and runs it? | Your engineers build; a vendor hosts | AgentCore, Gemini Enterprise Agent Platform or Claude Managed Agents |
| Who builds and runs it? | An outside team, in your own cloud | An AI engineering partner such as AI Theresa, which builds the system and runs it there |
| Which language? | Python | LangGraph, CrewAI, Pydantic AI or OpenAI Agents SDK |
| Which language? | TypeScript | LangGraph.js, Google ADK, OpenAI Agents SDK or Claude Agent SDK |
| Which language? | .NET | Microsoft Agent Framework or Google ADK |
| Which language? | Go, Java or Kotlin | Google ADK |
| How much control per step? | Explicit paths and custom state | LangGraph, ADK 2.0 graphs or CrewAI Flows |
If you take the outside-team route, AI Theresa's Enterprise plan is a fixed annual fee with a dedicated product lead and two engineers, and a 14-day free trial.
Data terms differ between hosted runtimes: Claude Managed Agents is not eligible for HIPAA, and not eligible for zero data retention except in its self-hosted deployment.
If two options tie, run one failing eval case through each and keep the one whose trace shows the failing step soonest.
Get Started with Theresa for FREEConclusion
AI agent development is mostly the work around a short model loop: clear tools, narrow permissions, stop rules that record unfinished work, and tests of the end state across repeat runs. Those decisions matter more than the framework.
Use the simplest approach that works. Build an agent only when the next step depends on what the software finds, and ship it only after a test checks the end state, including runs that stop early.






