AI agents: What they are and when you should (or shouldn't) use them

Here’s how they work, how they vary from other AI products, and when you should (and shouldn’t) use them.

AI agents are a big step forward in making generative AI more useful for businesses, as they’re able to take over processes and decide on steps to reach a goal or solve a problem without human intervention.

For the past few years, the true potential of generative AI has been somewhat obscured by aggressive hype around generic AI solutions that are underwhelming. They need too much handholding, and aren’t smart enough to learn from their mistakes.

You’ve likely interacted with an AI chatbot (if not launched one). These are primarily simple wrappers on top of large language models (LLMs), and use natural language processing to interpret user questions and formulate responses. Businesses can supplement those models with access to their own proprietary and customer data to give the chatbot access to relevant contextual information (this process is called retrieval-augmented generation, or RAG).

While you can use LLMs for automation—a chatbot layered over an LLM can perform simple lookups, such as checking on a customer’s order status—there things an LLM wrapper can't do. Making decisions, solving problems, or performing tasks outside of a narrow, linear scope aren't within an LLM's capabilities. Their processes are referred to as “deterministic”, meaning that there is a repeatable, predictable output based on the inputs.

How AI agents work, on the other hand, is nondeterministic. Given a task, an agent calls on a defined set of data, tools, and systems to carry out self-determined steps toward a goal.

Agents help to fill a gap in between generic AI tools that perform tasks like data analysis, summarizing documents, or ideation and brainstorming, or chatbots that can’t do much beyond their script, and processes that rely on human judgement to take inputs and decide on the next step. Autonomous AI agents’ nondeterministic mode of execution lets businesses fully automate end-to-end processes.

For complex tasks that require an understanding of context, AI agents can integrate information from various sources and apply it practically, using the toolset you give them access to. This means AI agents can provide more intelligent, adaptive responses than a rigid, linear workflow automation or chatbot.

AI agents are autonomous systems that can take on complex tasks by using predefined tools, accessing systems, and querying data—without needing step-by-step instructions.

Here’s a step-by-step example of how AI agents work:

A customer support agent for a healthcare practice receives a message from a patient wanting to reschedule their appointment. The agent must:

A simple LLM-wrapper chatbot or interface would lack the core abilities needed for direct integration with other tools, reasoning, and multi-step execution beyond conversation. These limitations are down to architecture.

AI agent architecture dictates what data and tooling it can access to perform tasks, as well as making it possible to self-improve based on feedback. Here’s an overview of the components of an AI agent:

While chatbots or prompt chains are typically reactive, handling one exchange at a time without persistent memory or true decision-making, an AI agent autonomously pursues goals. By retaining context across multiple steps and dynamically interacting with tools or data, an agent is able to reason about the task or problem and then take action—handling complex, multi-turn workflows.

A lot of the use cases for AI agents are around automating manual processes. There is a key difference between traditional automation of workflows, and handing over entire processes to autonomous agents: while the former works with predefined rules and control flows, agents can learn, adapt, and handle complex, dynamic problems.

If you have a manual process that follows a rigid set of steps or rules for what happens under what conditions, it’s probably a fine candidate for automation.

Agent-based automation really comes into its own in murkier situations, where there might be multiple ways to solve a problem or complete a task, and choosing the right steps requires reasoning or referring to contextual information.

Agents retain more context than chatbots or automated workflows, adapting their responses dynamically based on new information and changing conditions.

Agents operate outside of predetermined, linear workflows, which is useful when you need to handle inputs in natural language or determine the best action when there isn’t one obvious correct approach. But their flexibility can make them harder to debug: reproducing errors is tricky, and it’s harder to identify where an incorrect assumption may have occurred within multiple large context windows across steps.

The planner module of your agent is responsible for breaking down a task into steps, and adapting in response to new inputs or changing conditions. The planner module needs to account for errors and failures, and should include provision for retrying, adjusting the steps, or escalating for human intervention.

Agents need both short- and long-term memory to retain context and improve over time. Early adopters of ChatGPT will remember quickly hitting the limit on how much you could paste into the chat in one session. That’s because early models had limited “context windows”—the chatbot’s working memory for a session.

Agents need to go a step further by taking in and retaining information across sessions to improve reasoning and results. Memory is typically an expensive component of any application, so you should factor in considerations like ‘selective forgetting’ to retain only the context that’s needed, and other mechanisms for memory efficiency.

For agents to be truly useful, they need to take action. This often means using the tools in your company’s stack just as a member of the team would. While it’s simple enough to stand up a proof-of-concept that works with one of your systems of record, internal agents may need to integrate with GitHub, Salesforce, Zendesk, internal databases, and more.

Anthropic open sourced the Model Context Protocol to help provide a standardized way for LLMs to connect with external data sources and tools, but until there’s widespread adoption of a standard, you may need to implement custom authentication, error handling, and response parsing.

Isolating agent actions where possible can help to prevent unintended consequences in other parts of your system, as well as data leakage. Another way to think about it is by introducing constraints to the possible paths your agent can take to solve a problem—like Spotify’s “Golden Paths” to reduce fragmentation in their ecosystem.

However, what makes agents so powerful is their ability to reason and generate novel paths towards a goal, so you want them to have some autonomy, balanced with visibility.

One of the challenges with observability in AI agent systems is that traditional logging and metrics tools aren’t equipped to capture the complexity of agentic workflows. Without proper logging and debugging tools, when your agent fails in production, you’ll have no visibility into why. It could be a token limit issue, an incorrect assumption in a reasoning step, or an external API issue. At scale, those observability gaps become critical.

Agents’ output is not always predictable, because they usually handle complex, sometimes ambiguous tasks with a multitude of possible solutions. What makes them useful is what also introduces variance and can make debugging challenging, so organizations should have guardrails in place and monitor accordingly.

Agents’ potential to be unpredictable means that they might not be the right choice for some processes, where you need consistency rather than creativity. Agents will also apply reasoning to achieve any outcome you task them with—even otherwise deterministic tasks—making them unnecessarily resource intensive in some contexts. Here’s how to know when to use an AI agent instead of a workflow.

Agents excel at open-ended, ambiguous tasks like research, debugging, and collating and summarizing data (even as it updates) from across different sources. If you can’t distill a task or process into a sequence of distinct, consistent steps, you might have a candidate for an agent.

See more step-by-step examples of AI agent use cases here.

Multi-step agents are nascent technology, and therefore still prone to failure. Here's one engineer, on his experiences building AI agents:

When they do work, agents’ unpredictable and often opaque processes pose a challenge to existing auditing tools, making them a tough sell for regulated industries and public companies.

AI agents can be used in production (and many already are!) but safeguards are essential. Tracing, observability, and human oversight are needed for visibility and debugging when things go wrong, while fallback logic ensures users aren’t left hanging if the agent fails.

We know that agents are great for more nebulous, open-ended tasks, while workflows are best suited for well defined processes consisting of a series of predictable steps. To get the best of both, you can task an agent with the planning element of a task—deciding what should happen and how—leaving the execution to workflows. When dynamic decision making is needed, agents step in. “Workflows provide stability, and agents offer flexibility.”

Agent actions and all the steps in between—their reasoning, the tools they choose to use—aren’t logged and traceable by default. But when things go sideways in production, you need more information than just the agent’s input and final output. There are tools you can use that let you watch what’s happening under the hood, or Retool Agents lets you replay an entire agent run to see what went wrong.

Getting an agent into production and having it complete a successful run is just the beginning: to make sure it’s actually delivering business value you need to evaluate its performance and continuously improve it. Did the outcome align with user intent? Is it operating efficiently? Evaluation could include conducting test runs in different environments or with different LLMs, and evaluating not just the agentic system as a whole, but each component.

While LangChain offers flexibility, it also introduces complexity. You still need to contend with connecting a string of disparate data sources, your CRM or ticketing system, or other external tools—and ensure that access is managed securely. Sometimes the best tool for the job is the one that works with the rest of your existing toolchain. Retool lets builders bundle prompt engineering, tool use, human-in-the-loop controls, and production observability into one development experience, with security controls and governance managed in one control pane.

Adding constraints to AI agents for safety, like business rules and access controls, help to prevent your agent from taking risky or undesired actions, like this rogue Replit agent:

That’s the worst case scenario. Agents can also fail in less dramatic ways, but the experience can be confusing and frustrating to users if the agent can’t recover gracefully from errors. Fallback paths allow agents to retry the run or hand off to a human in the event of repeated failure.

Retool Agents offers a single platform for authoring, tooling, governance, evaluations, and observability, all built on Retool’s enterprise-grade infrastructure.

Some challenges with building AI agents are particularly critical—and particularly painful—at scale. With Retool Agents, security and governance, tool integrations, and observability are managed in one unified surface, all built on the same infrastructure trusted by over 10,000 companies for mission-critical internal tools.

Rather than spending time writing custom code to connect with the rest of your stack, you can draw from a vast suite of existing Retool integrations, alongside prebuilt tools like Google Calendar, web search, code execution, email, Retool Storage, data visualization, and others.

Instead of contending with the typical orchestration overhead that plagues agent development, Retool Agents lets you configure instructions and models, and attach tools to your agent that are based on existing Retool primitives. The platform automatically manages the complex loop of tool selection, execution, and reasoning—no boilerplate code required.

Agents have great potential to automate processes that previously only humans could handle, but they’re not infallible. Complex, multi-step execution has multiple possible points of failure. By combining agents with the right constraints to prevent rogue behavior, and with workflows to execute on the more structured, predictable elements of a task, you can play to their strengths and reduce their risks.

Agentic systems, when successful, are going to be key differentiators for businesses in the years to come, but not every company should need to be an expert in agent development.

Retool is building for a future in which enterprises can build secure, scalable agentic systems using tried and tested components that abstract away the hard parts of agent development—in the same way that businesses are already building internal tools without the heavy lifting and with first-class observability, security, and governance baked in.