From Scripted Bots to Smart Agents: How to Systematically Humanize Your AI Sales Agent

Based on a presentation by Lior Mechlovich, CTO & Co-founder of Salespeak.ai. View the full presentation →

Early AI sales agents were glorified decision trees. Rigid "if X, then Y" logic with no memory, no judgment, and zero context awareness. The moment a buyer deviated from the expected path, the entire experience fell apart.

That era is over. But most companies haven't caught up.

They're still deploying chatbots dressed up as AI agents — collecting email addresses, routing to humans, and frustrating buyers who came expecting something smarter. The gap between what buyers want and what most AI agents deliver is widening every quarter.

This post breaks down exactly how to close that gap: the architecture, the frameworks, and the production systems that turn a generic LLM into an AI sales agent that sells the way your best rep does.

What Buyers Actually Want (And What Most Agents Miss)

Before touching architecture, get clear on buyer psychology. There are three things every modern B2B buyer wants from a sales interaction:

To feel understood, not sold to. Buyers want agents that grasp their world before pitching a solution. Generic responses that ignore context signal immediately that the agent is a bot, not an advisor.

To feel guided, not pushed. Smart follow-up questions and context-aware conversations that adapt in real time. Buyers can tell when they're being funneled versus when they're being helped.

Continuity across touchpoints. Every conversation should build on the last. Starting from scratch on the third interaction isn't just annoying — it's a deal-killer for high-value accounts.

The common thread: human doesn't mean random. Human means adaptive and context-driven. That's an engineering problem, not a prompt problem.

The Core Difference: Scripts vs. Systems

Most "AI sales agents" are scripted agents with an LLM bolted on. They have static flows, hardcoded branches, and no abstraction of intent. They break the moment a buyer goes off-script — which is most of the time.

A systematic agent works differently. It models intent, tracks conversation state, and has explicit goals per interaction. It makes real-time decisions with reasoning and uses persistent memory across sessions. The difference isn't just technical — it's the difference between a tool that frustrates buyers and one that actually moves deals forward.

At Salespeak, we define this as AI-native sales agent infrastructure: purpose-built for revenue conversations. Four principles guide every agent we build:

• Intent-aware — understands what the buyer really needs, not just what they typed
• Goal-oriented — every turn drives toward a defined outcome
• State-driven — tracks where the conversation stands across every touchpoint
• Memory-enabled — recalls context across sessions, not just within them

We don't build chatbots. We build intelligent conversational agents.

Modeling Discovery as a System

The hardest thing to replicate in AI is great discovery. Your best reps don't follow a checklist — they run a structured system that unfolds based on what they learn. Each question builds on the last, moving from problem identification to a clear picture of success.

Discovery answers six things:

1. What problem are they actually trying to solve?
2. How painful is it? (quantification of impact)
3. What happens if they do nothing? (cost of inaction)
4. How are they solving it today? (current state)
5. Who is involved in the decision? (stakeholder mapping)
6. What does success look like? (desired future state)

To model this in AI, you need four composable layers:

1. Conversation State — What do we know? What's missing? The agent maintains a live map of extracted fields: pain points, budget signals, timeline, authority, use case. It prioritizes gaps in real time.

2. Hypothesis Layer — What problem might they have? What signals suggest urgency? The agent forms and tests hypotheses rather than waiting for buyers to volunteer information.

3. Goal per Turn — Each turn has a purpose: Clarify → Expand → Validate → Quantify. The agent doesn't ask questions randomly; it asks questions that advance the conversation toward a specific goal.

4. Question Strategy — Open-ended → Narrowing → Confirmatory. The agent guides without interrogating. By prioritizing relevance over completeness, every question earns its place in the conversation.

The output is an agent that avoids the interrogation feel — the number one reason AI-led discovery conversations fail.

Building for Production: LangGraph + LangSmith

Discovery architecture is the blueprint. Production intelligence is what makes it real.

Build with LangGraph. Model the agent as a state machine. Nodes handle LLM calls, tool use, retrieval, and validation. Edges define conditional routing, retries, and escalation paths. Persistent state tracks memory, extracted fields, and deal stage across the entire conversation lifecycle. This gives you structured, predictable decision-making — not a black box.

Observe with LangSmith. Full execution traces for every step and every tool call. Prompt and model version tracking. Latency, cost, and error visibility. Side-by-side experiment comparison. If you can't see exactly what your agent did and why, you can't fix it when it fails — and it will fail.

LangGraph gives you control. LangSmith gives you visibility. Together, they give you a production-grade AI sales agent instead of a prototype that works in demos and breaks in the field.

Choosing the Right Model: Latency vs. Thinking Depth

Model selection for a sales agent isn't a one-size-fits-all decision. There's a fundamental tradeoff: the more complex the reasoning, the higher the latency and cost.

A fast agent makes a single LLM call with minimal reasoning steps. Lower cost, lower quality. A deep agent runs multi-step reasoning chains with tool use and self-reflection. Higher quality outcomes, but slower and more expensive.

In sales conversations, speed is not optional. A 1-2 second response time is acceptable. Anything over 10 seconds kills the conversation flow and the deal with it. For discovery agents specifically, reasoning quality consistently outweighs creative writing ability — but it still needs to be fast enough to feel like a real conversation.

The practical answer: optimize for the minimum reasoning depth that delivers acceptable discovery quality. Then measure relentlessly.

Why Observability Is Non-Negotiable

In production, AI agents fail in ways that are subtle, silent, and destructive. The failure modes that kill sales conversations:

• Silent hallucinations — agents fabricating product capabilities or case studies
• Partial extraction errors — missing key data points like budget or timeline
• Goal drift mid-conversation — losing the thread and pivoting to irrelevant topics
• Context loss after 8+ turns — forgetting earlier details, forcing buyers to repeat themselves
• Tool misuse — incorrectly calling CRM integrations or misinterpreting outputs

Without robust observability, you're debugging vibes instead of data. You can't scale safely, and you can't improve systematically. Every conversation needs a score. Every failure needs to be visible.

The Continuous Improvement Loop

Shipping an AI sales agent isn't a one-time event. It's the beginning of a continuous improvement process:

1. Collect conversations
2. Label failures
3. Add to eval dataset
4. Run regression tests
5. Deploy new prompt version
6. Monitor metrics

Run this loop weekly. The agents that compound in quality over time are the ones built on systematic improvement, not prompt guessing.

For evaluation, combine LLM semantic judgment with deterministic checks. Pure LLM scoring is subjective and inconsistent. Pure rule-based scoring misses nuanced failures. Hybrid assertions give you balanced, actionable assessment.

RAG Quality: Beyond "Did It Answer?"

Most teams evaluate RAG by asking whether the agent provided an answer. For a B2B sales AI, that's nowhere near enough.

We use a WKYT (What, Know, Why, Think) scoring framework — a DIKW-style system that measures the depth of understanding, not just retrieval accuracy:

• Specificity & Completeness (0-14) — Detailed facts and full coverage. Are all core pain points retrieved accurately?
• Persona Depth (15-19) — Persona-specific context and motivations. Is the content segmented for CMOs vs. RevOps vs. Founders?
• Strategic Intelligence (20-25) — Actionable, decision-ready insights. Does the agent understand strategic implications, not just surface facts?

If RAG retrieves only generic content instead of persona-specific, strategically aligned information, the agent's quality score drops — and so does its ability to move deals forward. The goal is continuously improving the knowledge bank to hit 100% per category.

Structured Memory: Stop Passing Raw History

One of the most common production mistakes: passing 40+ turns of raw chat history into every LLM call. It overwhelms the context window, forces the agent to re-derive state on every turn, and leads to inconsistent behavior that gets worse as conversations get longer.

The fix is structured memory. Instead of raw history, pass:

• An extracted summary of the conversation
• Key fields (pain points, budget, timeline, authority, use case)
• Current open questions and next steps
• Assessed emotional state of the buyer

This dramatically improves consistency and focus. The agent operates with a clearer understanding of the ongoing dialogue — and it scales as conversations get longer instead of degrading.

Human-in-the-Loop Is a Design Choice, Not a Failure

The best AI sales agent systems aren't fully autonomous. Human-in-the-loop is a strategic design choice that optimizes performance where human judgment, empathy, and nuanced understanding are critical:

• High-value deals — human review ensures tailored negotiation and risk management
• Ambiguous intent — humans clarify unclear requests and guide responses
• Sensitive objections — empathy and judgment resolve delicate concerns that AI misreads
• Escalation scenarios — humans intervene for complex or critical outcomes

When a conversation score falls below threshold, the system sends a Slack alert to RevOps with the conversation summary, extracted state, where the agent failed, and a suggested improvement area. Low-scoring conversations enter a review queue automatically. The human can label the failure type, approve overrides, suggest corrections, or mark it as a training example.

This turns failures into visible, actionable events — instead of silent revenue leaks.

Context Engineering: The Hardest Problem Nobody Talks About

Most agents fail because they don't have the right context — or they have too much of it.

Context engineering means making deliberate decisions about what to include, what to exclude, how to structure it, and when to refresh it. The four types of context a production sales agent needs:

Static context — product information, pricing structures, company positioning. Changes infrequently, but must be accurate and comprehensive.

Dynamic conversation context — chat history (structured), extracted fields, current stage. Updated on every turn.

External context — CRM data, account metadata, past interactions. Pulled at conversation start and refreshed as needed.

Strategic context — current objective, allowed actions. Defines what the agent is trying to accomplish in this specific interaction.

More context means better personalization but higher latency and cost. Less context means faster responses but more hallucination and less continuity. Smart agents overcome this by extracting only the most critical information — structured memory — rather than dumping everything into the context window and hoping for the best.

The Bottom Line

Humanizing an AI sales agent isn't a prompt engineering exercise. It's a systems engineering problem.

It requires modeling discovery as a structured system, building observable and testable agent infrastructure, selecting the right models for the right reasoning depth, managing memory and context deliberately, and running a continuous improvement loop that compounds quality over time.

The agents that feel human aren't the ones with the best LLM. They're the ones built on the best systems.

If your current AI sales agent breaks when buyers go off-script, misses half the fields during discovery, or can't remember what was discussed two sessions ago — the issue isn't the model. It's the architecture.

That's what we built Salespeak to fix.

This post is based on a presentation by Lior Mechlovich, CTO & Co-founder of Salespeak.ai. View the full presentation →