AI Agent
Also known as: agentic AI, autonomous AI agent, LLM agent
An AI agent is software that pursues a goal by deciding its own next steps: it reasons with a language model, calls tools or APIs to act on the world, reads the result, and decides again, looping until the goal is met or it stops. Unlike a chatbot that only returns text, an agent takes actions. Unlike a fixed automation, it chooses the path at runtime instead of following one you scripted in advance.
The line that actually defines it: who chooses the next step?
Most definitions list traits, autonomy, memory, tools, and leave you no sharper than before. The cleaner test is one question: at runtime, who decides what happens next? In a workflow, you decided in advance and the machine follows your branches. In an AI agent, the model decides step by step from what it just observed. That single handoff is the whole story. It is what lets agents handle messy, open-ended work, and it is exactly what makes them harder to test, govern, and trust, because you can no longer read the path off a diagram. Everything else, 'an agent is an LLM plus tools in a loop,' is mechanism. The transfer of decision rights is the definition.
- Chatbot: generates text, takes no action on your systems.
- Automation / RPA: takes action, but you authored every step in advance.
- AI agent: takes action AND chooses the steps itself, at runtime.
- So 'agentic' is a spectrum, not a label: it measures how much path-choice you've delegated, and a system can be a little agentic or a lot.
How the loop works
Strip the branding and almost every agent is the same loop. A model receives a goal and context. It decides on an action, usually a 'tool call' to an API, a database, a search index, or another system. The result of that action is fed back in, and the model decides again. Memory carries state across turns. Orchestration owns the retries and the stopping conditions, the part most demos quietly hard-code. Guardrails constrain which tools it may call, with which arguments, and when a human must approve. The components are simple. The engineering that decides whether it works in production lives in the parts around the loop: tool definitions tight enough that the model can't misuse them, and stop conditions strict enough that it can't run forever.
- Model: the reasoning core that interprets the goal and picks the next move.
- Tools: the typed actions it can take, lookups, writes, calculations, handoffs, each with a clear contract.
- Memory / context: what it knows now, plus what it has learned this run.
- Orchestration: the loop, retries, and stopping conditions that keep it bounded.
- Guardrails: permissions, approval gates, and limits on blast radius if it's wrong.
Where it fits, and where the marketing skips ahead
Agents earn their keep on work that is high-volume, judgment-light, and previously stuck between 'too varied to script' and 'too cheap to staff': triage, lookups, drafting, routing, qualifying. The part the demos skip is that an agent is only as good as the data and tools it can reach. A reasoning loop over stale, ungoverned, or disconnected data produces confident nonsense, fast. That is why serious deployments fix the data layer before pointing an agent at it, and why the honest unit of value is not 'we shipped an agent' but 'the agent moved a metric we agreed to in advance.' An agent that runs but moves nothing is a line item, not a capability.
- Good fit: speed-to-lead, support triage, research summarization, internal lookups.
- Poor fit: irreversible, high-stakes, or thin-data decisions with no human gate.
- Precondition: clean, connected, permissioned data, an agent amplifies whatever the data already is.
- Real test: a metric it's accountable for, latency, conversion, cost-per-resolution, not activity.
Why agents are hard to evaluate (and how serious teams do it anyway)
Because the path changes every run, you can't certify an agent the way you certify a script. The same input can take a different route tomorrow, so a single passing demo proves almost nothing. This is the real gap between a flashy prototype and a system you'd trust with a customer. The teams that get past it stop measuring the model and start measuring outcomes: they define a task-level success metric up front, run the agent against a held-out set of real cases, track how often it succeeds end to end, and study where it fails, wrong tool, hallucinated argument, an escalation it should have made but didn't. Then they tighten the tools and gates and measure again. The discipline is closer to operating a process than to shipping a feature, which is why who runs it and who is accountable for the number matters as much as who built it.
- Evaluate on outcomes across many real cases, not one clean demo.
- Define success and acceptable-failure modes before launch, not after.
- Instrument the failures: wrong tool, bad argument, missed escalation, runaway loop.
- Treat it as an operated process with an owner, not a one-time deliverable.
Frequently asked
What's the difference between an AI agent and a chatbot?
A chatbot produces text and stops there. An AI agent takes actions in real systems, calling tools and APIs, and chooses its own sequence of steps toward a goal. Many products labeled 'chatbots' are now agents under the hood. The distinguishing trait is whether it acts and decides, not whether it talks.
Is an AI agent the same as workflow automation or RPA?
No. Both take actions, but automation and RPA follow a path you authored in advance. An AI agent decides the path at runtime from what it observes. That makes agents better at variable, open-ended work and worse at tasks where you need a guaranteed, auditable sequence, which is exactly why guardrails and human-approval gates matter.
How do you measure whether an AI agent is actually working?
Not by uptime or message count. The useful measure is a task-level outcome you set in advance, conversion, resolution rate, cost per case, time-to-response, scored across many real cases rather than one demo, because the agent takes a different path each run. Pair that with failure tracking: how often it picks the wrong tool, fabricates an argument, or skips an escalation it should have made.
Do AI agents replace humans?
In practice they replace specific high-volume tasks, not whole roles, and they work best with a human accountable for the outcome and a gate on the risky steps. The useful framing is delegation of steps, not replacement of judgment. The more irreversible the action, the more a human stays in the loop.
Related terms
Agentforce
Agentforce is Salesforce’s platform for building AI agents — software that reasons over your business data, makes decisions, and takes actions inside Salesforce, governed by your existing permissions and audit trail. Unlike a chatbot that only replies, an agent can complete a task end to end.
AI ROI
AI ROI is the net financial return from an AI system measured against everything it costs to build, run, and govern over its useful life: ROI = (value created − total cost of ownership) ÷ total cost of ownership. It differs from traditional software ROI in two ways: the costs are recurring and usage-based (per-token inference, monitoring, error correction) rather than a fixed license, and the value depends on the model's hit rate on a real task and what the misses cost — not on whether the feature shipped.
Ready when you are
Worth a
conversation?
Tell us one number you'd like AI to move. We'll show you how we'd do it, what it's worth, and how we'd tie our fee to getting you there.