GLOSSARY

What is an AI Agent?

An AI agent is an autonomous software system that pursues a goal across multiple steps. It typically runs a perceive → plan → act → observe loop, calls external tools, and decides for itself when to stop or hand off, unlike a chatbot, which only replies one turn at a time.

Try CRM Solid free See live demo

14-day free trial · No credit card required · Cancel anytime

Quick definition

An AI agent is an autonomous software system that pursues a goal across multiple steps. It typically runs a perceive → plan → act → observe loop, calls external tools, and decides for itself when to stop or hand off, unlike a chatbot, which only replies one turn at a time.

In a single sentence: a chatbot that has a goal, a memory, and tools.

What it means

An AI agent is a software system that uses a large language model (typically GPT, Claude, Gemini, or an open-weight equivalent) as its reasoning engine, and combines that with three things a chatbot does not have: persistent memory, callable tools, and an explicit goal. The combination lets the agent run multi-step tasks autonomously, taking actions and observing their effects, until the goal is met or it gives up.

The simplest mental model: a chatbot is a function that returns a reply. An agent is a loop that returns when it decides it is done.

Agents have been the dominant AI product pattern of 2024-2026. Roles that used to be implemented as scripts (lead-routing rules, follow-up sequences, customer-support FAQ deflection) are increasingly implemented as agents because agents handle the unscripted edges. They also fail differently; see the "common pitfalls" section.

Agent vs chatbot

The distinction is small in code, big in behavior:

Chatbot. Receives a user message; returns one reply. Each call is independent. The bot does not "remember" yesterday's conversation unless you feed it the history explicitly. The bot has no goal beyond responding.
Agent. Has a goal ("qualify this lead", "answer this support ticket"). Maintains state across many turns. Can call tools (send a message, fetch a record, schedule a meeting) and observe the results. Decides for itself when to act, when to hand off to a human, and when the goal is complete.

A useful test: if your "chatbot" can be triggered by a scheduled job (no user message at all) and still does something useful, it is an agent. If it only does anything when prompted by a user message, it is still a chatbot.

The agent loop architecture

The canonical agent loop has four phases that repeat until the goal is met or a stop condition is hit:

Perceive. Read the current state of the world: incoming message, contact record, conversation history, calendar, CRM state, external API responses.
Plan. Decide what to do next. May produce a single action ("reply with this message") or a multi-step plan ("check usage data; based on result, branch to A or B").
Act. Execute the chosen action by calling a tool: send a message, book a meeting, update a CRM field, fetch a piece of external data.
Observe. Read the result of the action. Did it succeed? What changed? What should happen next? Loop back to perceive.

Production agent frameworks (LangGraph, AutoGen, the OpenAI Assistants API, Anthropic's tool-use SDK) all implement variants of this loop. What changes between frameworks is the planning step; some agents plan one step at a time, others produce explicit multi-step plans up front, and others combine the two.

Tool use

Tools are the agent's hands. Without tools the agent can only produce text. With tools it can interact with the real world. Common CRM-agent tools:

send_message(channel, contact_id, body): send a message on Telegram, email, live chat, etc.
get_contact(id): fetch the contact record, tags, history, score.
get_recent_messages(contact_id, n): pull recent conversation history.
schedule_meeting(contact_id, when): create a calendar event.
update_deal_stage(deal_id, stage): move a deal in the pipeline.
handoff_to_human(reason): escalate to a teammate.

Three rules for tool design:

Tools should be small. One tool, one job. Mega-tools that take a dozen parameters confuse the model.
Tools should be idempotent. Calling update_deal_stage twice with the same arguments should be safe. Non-idempotent tools eventually produce double-sends.
Destructive tools should require explicit confirmation. Anything that deletes data, sends to many recipients, or moves money should require a separate "confirm" action so the agent cannot accidentally trigger it from a single hallucination.

Why it matters

Agents are the first AI pattern that meaningfully reduces headcount-per-output for SDR, support, and operations work. The economics are simple: a $0.30 LLM call replaces 5 minutes of human work for ~$10 worth of salary. At scale that is transformative, but only if the agent does its job reliably.

The "reliability" caveat is the entire engineering challenge. Most agents fail in the same handful of ways: hallucinating facts, looping forever, calling tools they should not, or handing off too late. Designing around those failure modes (see pitfalls below) is what separates production agents from demos.

Real-world examples

Lead-qualifying agent. Triggered by a new inbound DM. Reads the contact's enriched profile, asks 2-3 qualifying questions, scores the lead, and either books a meeting or routes to a human SDR with a structured summary.
Pipeline-hygiene agent. Runs nightly. Reads the team pipeline. Flags deals with no activity in 14+ days. Sends a one-line summary to the deal owner via Telegram. Logs the result.
Customer-support deflection agent. Picks up incoming support tickets, classifies them, looks up the relevant help-doc article via vector search, drafts a reply, and either sends it (for high-confidence cases) or queues it for a human reviewer (for low-confidence).
Trial-onboarding agent. Watches the trial user's product activity. After 24 hours of low activity, sends a personalised "still stuck?" message. After 5 days, schedules a check-in call if the user looks interested but stuck.
Outbound research agent. Given a list of prospects, fetches each company's recent news, pulls a LinkedIn-style summary of the contact, and generates a first-paragraph personalised opener for the SDR to review. Does not send anything; it produces drafts for human approval.

Common pitfalls

Hallucination. The agent invents facts that are not in its data: a feature you do not have, a price you do not charge, a meeting at a time the prospect never agreed to. Mitigation: ground the agent in retrieved context (RAG), use strict tool-output schemas, and require human review for anything price/contract-related.
Runaway loops. The agent re-plans endlessly without making progress, burning tokens and sometimes generating noise output. Mitigation: hard step caps, budget caps, and a "give up and escalate" branch that fires after N attempts.
Tool misuse. The agent calls the wrong tool, or the right tool with bad parameters, and triggers real-world consequences (sending the wrong message to the wrong contact). Mitigation: smaller tools, strict schemas, and confirmation steps for destructive actions.
Bad guardrails. The agent says something embarrassing: "We can match any competitor's price", "Our refund policy is whatever you need". Mitigation: explicit prompt-level rules ("never promise discounts"); automated red-teaming against the agent before deployment; full audit logs.
Late handoff. The agent should escalate earlier than it does. "I am sorry, I cannot help with that" comes after 6 turns of going in circles. Mitigation: define handoff triggers explicitly (mentions refund, legal, urgent, escalate, manager).
No audit trail. When something goes wrong you cannot reconstruct what the agent saw, planned, and did. Mitigation: log every step. Treat the audit log as non-optional infrastructure.

Related concepts

Omnichannel CRM The operational substrate AI agents act on top of.
Lead scoring: agents use the score to decide whether to engage, nurture, or escalate.
Drip campaign: the static-content cousin; agents increasingly replace one-step drip messages with contextual replies.
Cold outreach: agents triage inbound replies, but human reps still own the relationship.
Webhook: the trigger mechanism that wakes an agent up when a new event arrives.
Sales pipeline Many agents act on (or update) pipeline state.

How CRM Solid handles it

CRM Solid's AI Agents feature lets you design narrow agents with explicit goals, personas, behavior rules, and handoff triggers. Agents have access to a curated tool set: send_message, get_contact, update_deal_stage, schedule_meeting, handoff_to_human. They run inside a sandboxed step-limited loop. Every action is logged for audit. The OpenAI, Anthropic and Gemini providers are supported behind the same agent interface, so you can swap models without rewriting the agent.

Cheat sheet · the agent loop

Perceive → Plan → Act → Observe.

1

Perceive

Read the current state of the world: the incoming message, the contact record, the conversation history, the calendar, the CRM.

Example: New Telegram DM from a contact tagged "trial user". Last interaction 4 days ago.

2

Plan

Decide what to do next. May produce a single action or a multi-step plan with branching logic.

Example: Check trial usage → if low, send activation tips; if high, offer demo call.

3

Act

Execute the chosen action by calling a tool: send message, book meeting, update CRM field, fetch external data.

Example: Call `crm.get_trial_usage(contact_id)`. If result is "low", call `send_message(template_activation)`.

4

Observe

Read the result of the action. Did it succeed? What changed? What should happen next?

Example: Message sent ok. Contact opened it. No reply yet. Loop back to plan: schedule a 24h follow-up check.

Cheat sheet · agent skeleton

Pseudo-code for a guarded agent loop.

async function runAgent(goal, ctx) {
  const MAX_STEPS = 8;
  const MAX_TOKENS = 25_000;

  for (let step = 0; step < MAX_STEPS; step += 1) {
    // 1. perceive
    const state = await readState(ctx);

    // 2. plan
    const plan = await llm.plan({
      goal, state, tools: TOOL_SCHEMAS,
      tokenBudget: MAX_TOKENS - ctx.tokensUsed,
    });

    if (plan.action === "handoff") {
      return ctx.escalate(plan.reason);
    }
    if (plan.action === "done") {
      return ctx.complete(plan.summary);
    }

    // 3. act
    const result = await callTool(plan.tool, plan.args, ctx);

    // 4. observe — fed back into next perceive
    ctx.audit(step, plan, result);
  }

  return ctx.escalate("step_cap_exceeded");
}

Production guardrails

Six rules every production agent needs.

Hard step cap: no more than N planning loops per task.
Tool whitelist: only the tools the agent needs, nothing else.
Budget cap: token-spending limit per task.
Explicit handoff triggers (refund, legal, "talk to human", price exception).
Audit log: every perceive / plan / act / observe step recorded.
Destructive-action confirmations: anything irreversible asks twice.

Watch out for

Narrow agents win. General agents do not. Not yet.

In 2026 the agents that work in production are the ones with tight scope: "first reply to inbound DMs", "pipeline hygiene review", "lead enrichment". Agents that try to be "an SDR" or "a support rep" still hallucinate, loop, and misuse tools. Start narrow. Compose narrow agents into workflows. Resist the temptation to ship a generalist.

“We replaced our first-reply triage with a narrow AI agent and saw the SDR team handle 3x the inbound volume. The agent caught the 70% of messages that were obvious next-steps and only escalated the genuinely interesting ones. Same humans, three times the throughput.”

Yuki Tanaka

Director of Revenue Operations · Hexweave

AI agents: FAQ

The questions every team asks before shipping an agent into production.

A chatbot replies one turn at a time, statelessly, to a user message. An AI agent has a goal, maintains memory across turns, decides for itself when to call tools or escalate, and can run autonomously without a user prompt (e.g., a nightly agent that reviews stalled deals). Chatbots react; agents pursue.

Yes, with significant scope discipline. Narrow agents ("answer billing FAQs", "draft a first reply to inbound DMs", "review pipeline hygiene weekly") work reliably. Wide agents that try to do "everything a sales rep does" still produce too many hallucinations and runaway loops to deploy without a human in the loop. The winning pattern is narrow agents composed into workflows, not one general agent.

In a CRM context: send a message, read the contact record, check calendar availability, log a note, update a deal stage, fetch external data (a website, a public API). Tools should be small, deterministic, and idempotent. Agents that call non-idempotent tools without guards eventually do something embarrassing.

Six guardrails. (1) Hard step cap: no more than N planning loops per task. (2) Tool whitelist: only the tools the agent needs, nothing else. (3) Budget cap: token spending limit per task. (4) Human handoff triggers: define cases that always escalate. (5) Audit log: every action logged for replay. (6) Sandboxed write actions: destructive operations require explicit confirmation.

Only when designed for it. Agents should never process data they do not need (data minimisation), should log every action for audit, should honor consent rules (do not message contacts who opted out), and should default to handing off to a human on legal or financial questions. Designing for compliance from the start is far easier than retrofitting it.

In 2026, no. They replace the worst 30% of any individual's work. Agents handle the obvious follow-ups, the easy questions, the data-lookups, the meeting scheduling. Humans handle the conversations that require judgment, relationships, and accountability. The net effect is the same headcount producing 2-3x more output.

Keep reading

Omnichannel CRM

The substrate AI agents act on top of.

Webhook

The trigger mechanism that wakes agents up on real events.

Lead scoring

Agents read the score to decide whether to engage or nurture.

AI sales bot training

How to ship a production sales agent step by step.

AI bots feature

CRM Solid's built-in AI agents: personas, tools, handoffs.

Ready to ship

Ship a narrow AI agent that actually works.

CRM Solid's AI Agents come with personas, tool whitelists, step caps, handoff triggers and audit logs already wired in.

Start free trial Talk to sales

Trusted by 2,500+ teams · GDPR-ready · 99.95% uptime