Shipping AI sales agents scheduling follow-up in production means treating the model as one component in a system with hardcoded tools, retry boundaries, and audit trails. A prompt alone will double-book meetings and spam leads; you need a deterministic execution layer around the LLM. This walkthrough builds that layer with OpenAI-compatible tool calls, a calendar API, and a simple job queue that an engineer can deploy in an afternoon.
Step 1: Define the Agent’s Contract with Structured Tools
The first mistake teams make is letting the model emit natural language that a regex then scrapes. That breaks the moment the model rephrases. Instead, use function calling (sometimes called tool use) with strict JSON schemas. The LLM returns a structured call; your code executes it.
Define two primitives: schedule_meeting and send_followup. Keep the schema minimal but explicit about formats.
tools = [
{
"type": "function",
"function": {
"name": "schedule_meeting",
"description": "Book a calendar slot with a lead",
"parameters": {
"type": "object",
"properties": {
"email": {"type": "string", "format": "email"},
"start_time": {"type": "string", "format": "date-time"},
"duration_min": {"type": "integer", "minimum": 15}
},
"required": ["email", "start_time"]
}
}
},
{
"type": "function",
"function": {
"name": "send_followup",
"description": "Queue a follow-up email to a lead",
"parameters": {
"type": "object",
"properties": {
"email": {"type": "string", "format": "email"},
"subject": {"type": "string"},
"body": {"type": "string"},
"delay_hours": {"type": "integer", "minimum": 0}
},
"required": ["email", "subject", "body"]
}
}
}
]Validate before executing
Wrap the arguments in pydantic models in your backend. The model will occasionally emit duration_min as a string. Reject and re-prompt rather than coercing silently. AI sales agents scheduling follow-up must not guess at types.
Step 2: Point the Client at a Resilient Inference Endpoint
Your agent will make many sequential calls. If the primary LLM provider returns 429s during a launch, the whole cadence stalls. Use an OpenAI-compatible gateway that fronts multiple providers. An OpenAI-compatible gateway such as n4n.ai exposes 240+ models behind one endpoint and fails over automatically when a provider is rate-limited, so your scheduling loop does not hard-crash mid-negotiation.
Configure the client once:
from openai import OpenAI
import os
client = OpenAI(
base_url="https://api.n4n.ai/v1", # OpenAI-compatible, auto fallback
api_key=os.environ["N4N_KEY"]
)
def chat(messages):
resp = client.chat.completions.create(
model="anthropic/claude-3.5-sonnet", # any routed model
messages=messages,
tools=tools,
tool_choice="auto"
)
return resp.choices[0].messageThe model field can be any identifier your gateway supports. Because the gateway honors client routing directives, you can pin a specific vendor or let it pick based on latency. Per-token metering lets you attribute cost per lead without building your own proxy.
Step 3: Implement the Tool Backends
The LLM calls functions; your code does the work. For scheduling, write to a database with an idempotency key derived from the lead email and the proposed start time. This prevents duplicate events when the model retries.
import sqlite3, uuid, json, os
from datetime import datetime, timedelta
DB = sqlite3.connect("crm.db")
DB.execute("""CREATE TABLE IF NOT EXISTS events (
id TEXT, email TEXT, start TEXT, end TEXT, dedup TEXT UNIQUE)""")
def schedule_meeting(email, start_time, duration_min=30):
start = datetime.fromisoformat(start_time)
end = (start + timedelta(minutes=duration_min)).isoformat()
dedup = f"{email}|{start_time}"
try:
DB.execute("INSERT INTO events (id,email,start,end,dedup) VALUES (?,?,?,?,?)",
(str(uuid.uuid4()), email, start_time, end, dedup))
DB.commit()
except sqlite3.IntegrityError:
return {"status": "duplicate", "note": "already scheduled"}
return {"status": "confirmed", "start": start_time, "end": end}For follow-up, never send email directly inside the LLM call path. Queue it. A simple outbox table works for prototypes; move to SQS or Redis in production.
DB.execute("""CREATE TABLE IF NOT EXISTS outbox (
id TEXT, email TEXT, subject TEXT, body TEXT, run_at TEXT)""")
def send_followup(email, subject, body, delay_hours=0):
run_at = (datetime.now() + timedelta(hours=delay_hours)).isoformat()
DB.execute("INSERT INTO outbox VALUES (?,?,?,?,?)",
(str(uuid.uuid4()), email, subject, body, run_at))
DB.commit()
return {"queued": True, "run_at": run_at}Why queue?
AI sales agents scheduling follow-up often propose a sequence: meet, then email in 2 days, then another in 5 days. If you SMTP-send inside the tool call, a later exception in the loop loses the state. The outbox makes the cadence durable.
Step 4: Run the Agent Loop
The loop is straightforward: send messages, inspect for tool calls, execute, feed results back. Terminate when the model returns text without tools.
def run_agent(lead_msg, history=None):
messages = history or [{"role":"system",
"content":"You are a sales agent. Use tools to schedule and follow up. Confirm times in lead's timezone."}]
messages.append({"role":"user","content":lead_msg})
while True:
msg = chat(messages)
if msg.tool_calls:
for call in msg.tool_calls:
fn = call.function.name
args = json.loads(call.function.arguments)
if fn == "schedule_meeting":
result = schedule_meeting(**args)
elif fn == "send_followup":
result = send_followup(**args)
else:
result = {"error": "unknown tool"}
messages.append({"role":"tool","tool_call_id":call.id,
"content":json.dumps(result)})
else:
messages.append({"role":"assistant","content":msg.content})
break
return messagesKeep the system prompt opinionated: instruct the model to propose concrete ISO times, not “next week”. When building AI sales agents scheduling follow-up, the model’s job is to resolve ambiguity, not defer it.
Step 5: Execute the Follow-Up Cadence
A worker process drains the outbox. Run it on a cron or a long-lived loop. This is where the delayed emails actually send.
import smtplib
from email.message import EmailMessage
def dispatch_outbox():
now = datetime.now().isoformat()
rows = DB.execute("SELECT id,email,subject,body FROM outbox WHERE run_at <= ?",
(now,)).fetchall()
for row in rows:
msg = EmailMessage()
msg["To"] = row[1]
msg["Subject"] = row[2]
msg.set_content(row[3])
# with smtplib.SMTP("localhost") as s: s.send_message(msg)
print(f"WOULD SEND to {row[1]}: {row[2]}") # swap for real SMTP
DB.execute("DELETE FROM outbox WHERE id=?", (row[0],))
DB.commit()
if __name__ == "__main__":
dispatch_outbox()Cron entry:
*/15 * * * * /usr/bin/python3 /opt/sales-agent/worker.py >> /var/log/agent.log 2>&1The core value of AI sales agents scheduling follow-up is removing manual CRM hygiene. The worker guarantees the promised email goes out even if the original conversation happened three days ago.
Step 6: Verify Success
You cannot ship without a test that proves the loop creates an event and queues mail. Use pytest with a temporary DB.
def test_agent_flow(tmp_path):
global DB
DB = sqlite3.connect(tmp_path/"test.db")
DB.execute("CREATE TABLE events (id TEXT, email TEXT, start TEXT, end TEXT, dedup TEXT UNIQUE)")
DB.execute("CREATE TABLE outbox (id TEXT, email TEXT, subject TEXT, body TEXT, run_at TEXT)")
msgs = run_agent("Let's meet Thursday at 14:00 for 30 min. Follow up in 48 hours.")
ev = DB.execute("SELECT * FROM events").fetchall()
ob = DB.execute("SELECT * FROM outbox").fetchall()
assert len(ev) == 1, "meeting not scheduled"
assert len(ob) == 1, "follow-up not queued"
assert "confirmed" in str(msgs), "agent did not close"
print("Verified: AI sales agents scheduling follow-up created event + delayed email")Run pytest test_agent.py -q. For manual verification, point the worker at a mailbox you control, trigger a conversation, and confirm: (1) a calendar row exists with correct UTC time, (2) the outbox row has run_at in the future, (3) after the delay, the SMTP send fires. If any step fails, the logs show which tool returned an error.
Production caveats
- Set a max iteration count in the loop to avoid infinite tool recursion.
- Store the full
messagesarray per lead for audit and fine-tuning. - Use the gateway’s cache-control hints to avoid re-billing for identical system prompts across leads with shared context.
Building AI sales agents scheduling follow-up is mostly plumbing. The model decides; your code guarantees. Get the tools strict, the queue durable, and the endpoint redundant, and the agent will book meetings while you sleep.