# AgentLine โ€” Full Site Content for AI Agents > This is the consolidated, full-text version of AgentLine's public content (llms-full.txt). It is intended for large language models, AI agents, crawlers, and bots that want deep context in a single request. > AgentLine gives any AI agent a real phone number โ€” make calls, send SMS, and handle inbound conversations through one API. Works with OpenClaw, Hermes Agent, and any LLM. ## Discovery Endpoints - Lightweight index: https://agentline.cloud/llms.txt - This full document: https://agentline.cloud/llms-full.txt - Skill file (raw markdown): https://agentline.cloud/skill.md - Agent plugin manifest: https://agentline.cloud/.well-known/ai-plugin.json - Blog index (HTML): https://agentline.cloud/blogs - Per-post raw markdown: https://agentline.cloud/blog/{slug}.md - Sitemap: https://agentline.cloud/sitemap.xml ## Core Pages - [Home](https://agentline.cloud): AgentLine โ€” AI Phone API. Phone numbers, voice, and SMS for AI agents. - [Docs](https://agentline.cloud/docs): Full API reference โ€” REST endpoints, code examples, authentication guide. - [Pricing](https://agentline.cloud/pricing): Simple per-minute pricing for AI phone calls and SMS. $2.50 free credit. - [Blog](https://agentline.cloud/blogs): Guides, tutorials, and insights on AI phone agents and telephony. - [About](https://agentline.cloud/about): The phone API built for AI agents. - [Contact](https://agentline.cloud/contact): Get in touch with the AgentLine team. ## API Reference - Base URL: https://api.agentline.cloud - Auth: Bearer token (API key starting with sk_live_) in the Authorization header. - MCP server: https://api.agentline.cloud/mcp --- ## AgentLine Skill File (SKILL.md) The complete skill definition that makes an AI agent (OpenClaw / Hermes / OpenCode-compatible) capable of making and receiving calls and SMS via AgentLine: ```markdown --- name: agentline description: Make phone calls, view received SMS, provision numbers, manage agents, and track billing through the AgentLine telephony API (REST or MCP). Use when the user asks to call someone, check transcripts, view text messages, manage phone agents, buy numbers, or check account balance. For MCP-native workflows, the server at api.agentline.cloud/mcp exposes 21+ tools as first-class agent tools. version: "1.11" metadata: openclaw: emoji: "๐Ÿ“ž" requires: env: - AGENTLINE_API_KEY primaryEnv: AGENTLINE_API_KEY --- # AgentLine โ€” AI Telephony Skill (v1.11) Give your AI agent a real phone number and voice calls โ€” no servers, no webhooks, no infrastructure. ## First-Time Setup **Follow these steps IN ORDER when setting up AgentLine for the first time:** 1. **Check for `AGENTLINE_API_KEY`** (starts with `sk_live_`) โ€” required. If missing, get one via **OTP** using any email โ€” yours or the human's (see **API Keys** below). If no email exists, ask the human to log in at **https://agentline.cloud** and hand you the key. Do NOT proceed without it. 2. **Check for `AGENTLINE_AGENT_ID`** (starts with `agt_`) โ€” this is optional. - **If you already have one**, use it and skip to step 3. - **If you do NOT have one**, create a new agent now by calling `POST /v1/agents` with `{"name": "My Agent"}`. Save the returned agent ID. 3. **Ask for area code and provision the number** โ€” ask the human for their preferred area code (e.g. 212, 415, 313), then `POST /v1/numbers` with `{"agent_id": "...", "area_code": "XXX"}`. If unavailable, ask for a different code. 4. **Ask for voice preference** โ€” **Always ask the human:** > "Would you like your agent to have a **male** or **female** voice?" - If **female**: `"female-1"` (friendly), `"female-2"` (reassuring), or `"female-3"` (guide) - If **male**: `"male-1"` (supportive), `"male-2"` (thinker), or `"male-3"` (helpful) - Apply via `PATCH /v1/agents/$AGENTLINE_AGENT_ID` with `{"voice_id": "chosen_preset"}` - Available presets: `female-1`, `female-2`, `female-3`, `male-1`, `male-2`, `male-3` 5. **Ask for owner phone (optional)** โ€” **Ask the human:** > "Would you like to register your personal phone number so you can call your agent to give it tasks?" - If yes, get their phone number in E.164 format (e.g. `+12125551234`) - Apply via `PATCH /v1/agents/$AGENTLINE_AGENT_ID` with `{"owner_phone": "+1XXXXXXXXXX"}` - When the owner calls the agent's number from this phone, the agent enters **task mode** โ€” it treats the conversation as instructions to execute, not a regular call. 6. **Start the event poller** โ€” **MANDATORY.** Without this, you will miss all inbound calls and SMS. Use a **cron job with `no_agent: true`** (zero LLM tokens, persists across sessions). - `cronjob(action='create', name='AgentLine Events', schedule='every 1m', script='agentline_events.py', no_agent=true)` - Write the polling script (see Events Mailbox) to `~/.hermes/scripts/agentline_events.py` - Verify with `cronjob(action='list')` > โš ๏ธ **Do NOT skip ANY steps or change the order.** Steps 1-5 set up the agent. Step 6 keeps it alive. --- ## Authentication Every request: `Authorization: Bearer $AGENTLINE_API_KEY` + `Content-Type: application/json` Base URL: `https://api.agentline.cloud` ### API Keys (OTP โ€” no browser) No key yet? Email a 6-digit code to **any address โ€” yours or the human's** (same email โ†’ same account). Whoever owns the inbox reads the code. | Method | Path | Auth | Body / Purpose | |--------|------|------|---------| | `POST` | `/v1/auth/otp` | none | `{"email":"..."}` โ†’ emails 6-digit code | | `POST` | `/v1/auth/verify` | none | `{"email":"...","otp":"123456"}` โ†’ key (shown once; new acct = **$2.50 bonus**) | | `POST` | `/v1/auth/keys` | Bearer | Mint another key | | `GET` | `/v1/auth/keys` | Bearer | List keys (marks current) | | `DELETE` | `/v1/auth/keys/{id}` | Bearer | Revoke (can't revoke current) | Rate-limited: 3 OTP/email, 5 OTP/IP, 5 verify/email per 10 min. --- ## How Calls Work (Hosted Mode) AgentLine runs in **Hosted Mode** โ€” the server runs the AI voice conversation autonomously. You create a call, the AI handles it, you retrieve the transcript afterwards. ### System Prompt & Greeting Resolution Both `system_prompt` and `initial_greeting` follow the same priority chain: | Priority | Where to set | Scope | API | |----------|-------------|-------|-----| | **1 (highest)** | Per-call override | This call only | `POST /v1/calls` with `system_prompt` / `initial_greeting` | | **2** | Agent default | All calls on this agent | `PATCH /v1/agents/{id}` with `system_prompt` / `initial_greeting` | | **3 (lowest)** | Hardcoded fallback | Last resort | Generic prompt + "Hello, how can I help you today?" | **When to use which:** - **Set on the agent** (`PATCH /v1/agents`) when you want a persistent personality/greeting for ALL calls (inbound AND outbound). - **Set per-call** (`POST /v1/calls`) when you need a one-time context-specific prompt/greeting for a single outbound call. Does NOT change the agent's default. > โš ๏ธ **`system_prompt` is a FULL REPLACE, not append.** The voice AI has no memory between calls โ€” include everything (personality, instructions, current context) in the prompt. > โš ๏ธ **`initial_greeting`** is what the agent SPEAKS ALOUD at the start of the call. It is NOT part of the system prompt โ€” it's the first thing the caller hears. Set it on the agent for a consistent greeting, or override it per-call for context-specific openers. --- ## Before Calling โ€” Balance Check Always check balance first. Calls require minimum **$0.50**: ```bash curl -s "$AGENTLINE_URL/v1/billing/balance" -H "Authorization: Bearer $AGENTLINE_API_KEY" ``` If balance < $0.50, warn the user before attempting the call. ## Make an Outbound Call **Pitfall:** Always write JSON payloads to a temp file and use `-d @file` โ€” inline payloads with special characters break: ```bash curl -s -X POST $AGENTLINE_URL/v1/calls \ -H "Authorization: Bearer $AGENTLINE_API_KEY" \ -H "Content-Type: application/json" \ -d @/tmp/al_call_payload.json ``` | Field | Required | Description | |-------|----------|-------------| | `agent_id` | Yes | Your agent ID | | `to_number` | Yes | E.164 phone number to call | | `system_prompt` | No | Dynamic prompt for this call only (overrides default) | | `initial_greeting` | No | What the agent says first when the person picks up | | `voice_id` | No | `"female-1"`, `"female-2"`, `"female-3"`, `"male-1"`, `"male-2"`, `"male-3"` | **After every outbound call:** Poll `GET /v1/calls/` every 15-30s until `status=completed`, then `GET /v1/calls//transcript`. Real calls take 45-120s. Use `sleep N && curl ... | python3 -c` to check status + extract transcript in one shot. Summarize and share with human. Never consider a call "done" without the transcript. **Outbound call to `owner_phone` = Owner Task Mode.** If `to_number` equals the agent's `owner_phone`, the call is a **task call**, not a support call โ€” the AI enters task mode and the completed call emits `call.owner_task` (with `is_owner_task: true`) instead of a plain `call.completed`. Treat the human turns as instructions to EXECUTE. See Owner Task Mode below. **If you get 400 "Agent has no active phone number"**, provision one first. **Pitfall โ€” agent loops on voicemail/call control:** The voice AI will repeat its greeting 3-4 times into voicemail or call-control prompts ("press 3 to connect", "please leave a message"). This wastes credits and sounds bad. After the first 15-20s poll, check the transcript: if human turns are all automated system messages (not real human replies), hang up immediately. Feedback surveys and check-in calls don't work on voicemail. **Exception โ€” business inquiry calls (apartments, doctor's offices, etc.):** For these, leaving a voicemail IS the right outcome. If the call reaches "please leave a message at the beep," let the agent leave a voicemail with: who you are, what you want, callback number/email, and a clear ask. Don't hang up. Include a voicemail fallback in the system prompt for these call types. **Pitfall โ€” phone tree / automated hold systems:** Many businesses have automated greetings ("This call may be recorded", "We will be with you shortly", "Thank you for calling X"). The voice AI will try to respond to every one of these as if it's a human, repeating the greeting and burning credits. To prevent this, add to the system prompt: "If you hear an automated message or hold music, stay silent and wait. Only speak when a real person greets you." Without this instruction, the agent will get into a loop responding to hold messages. --- ## Call Management - **Hang up:** `POST /v1/calls//hangup` - **Transcript:** `GET /v1/calls//transcript` โ†’ `[{role, text, timestamp}, ...]` - **List calls:** `GET /v1/calls?limit=20` or `?status=completed&limit=10` - **Call details:** `GET /v1/calls/` --- ## Events Mailbox Events are pushed when someone calls or texts your agent's number. **You MUST poll regularly.** **Event types:** `call.received` (inbound call started), `call.completed` (call ended, includes transcript), `call.owner_task` (owner call ended โ€” inbound OR outbound; transcript contains task instructions to execute), `sms.received` (inbound SMS) ### โšก MANDATORY โ€” Cron-Based Event Polling > Use a **`no_agent: true` cron job** โ€” it runs persistently across sessions, costs **zero LLM tokens**, and silently skips cycles when there are no events. Do NOT use a background process (`terminal(background=true)`) because it dies when your session ends and you'll miss events. **Step 1 โ€” Write the polling script** to `~/.hermes/scripts/agentline_events.py`: ```python #!/usr/bin/env python3 """Poll AgentLine for new events. Prints event details to stdout when events exist. Silent on empty cycles โ€” cron only delivers non-empty stdout.""" import os, sys, json, urllib.request API_KEY = os.environ.get("AGENTLINE_API_KEY", "YOUR_API_KEY_HERE") BASE_URL = "https://api.agentline.cloud" req = urllib.request.Request( f"{BASE_URL}/v1/events/peek", headers={"Authorization": f"Bearer {API_KEY}"} ) try: with urllib.request.urlopen(req, timeout=10) as resp: data = json.loads(resp.read()) count = data.get("pending_count", 0) if count > 0: # Consume the events req2 = urllib.request.Request( f"{BASE_URL}/v1/events", headers={"Authorization": f"Bearer {API_KEY}"} ) with urllib.request.urlopen(req2, timeout=10) as resp2: events = json.loads(resp2.read()) print(f"๐Ÿ“ž {len(events)} AgentLine event(s):") for ev in events: etype = ev.get("event_type", "?") payload = ev.get("payload", {}) if etype == "call.completed": print(f" โ€ข Call from {payload.get('from_number')} โ€” {payload.get('duration_seconds', 0)}s") transcript = payload.get("transcript", []) for t in transcript[-5:]: # last 5 turns print(f" [{t.get('role')}] {t.get('text', '')[:120]}") elif etype == "call.owner_task": print(f" โ€ข โšก OWNER TASK from {payload.get('from_number')} โ€” execute instructions below:") transcript = payload.get("transcript", []) for t in transcript: if t.get("role") == "human": print(f" TASK: {t.get('text', '')}") elif etype == "sms.received": print(f" โ€ข SMS from {payload.get('from_number')}: {payload.get('body', '')[:200]}") elif etype == "call.received": is_owner = payload.get("is_owner_call", False) print(f" โ€ข Inbound call from {payload.get('from_number')}{' (OWNER)' if is_owner else ''}") except Exception as e: # Silent on transient errors โ€” cron will retry next cycle if "401" in str(e) or "403" in str(e): print(f"AGENTLINE_AUTH_ERROR: Check your API key. {e}") ``` **Step 2 โ€” Create the cron job** (one-time setup): ``` cronjob(action='create', name='AgentLine Events', schedule='every 1m', script='agentline_events.py', no_agent=true) ``` **Step 3 โ€” Verify it's running:** ``` cronjob(action='list') ``` Runs every 1 min. Non-empty stdout โ†’ delivered to you. Empty stdout โ†’ silent skip (zero cost). If auth fails, prints `AGENTLINE_AUTH_ERROR` โ€” check `cronjob(action='list')` for `last_status`. ### Endpoints - **Consume events:** `GET /v1/events` โ€” returns events oldest-first, auto-deleted after retrieval - **Peek (don't consume):** `GET /v1/events/peek` - **Filter:** `?agent_id=agt_xxx` or `?event_type=call.completed` or `?event_type=sms.received` ### Event payload structure Each event contains: `event_id`, `agent_id`, `event_type`, and a `payload` with call/SMS details. `call.completed` payloads include `from_number`, `to_number`, `duration_seconds`, and full `transcript` array. `call.owner_task` payloads are identical to `call.completed` but with `is_owner_task: true` โ€” this means the transcript contains task instructions from the owner (see Owner Task Mode below). `sms.received` payloads include `from_number`, `body`, and `media_url`. --- ## SMS > **โš ๏ธ SMS sending is NOT enabled.** Do NOT attempt outbound SMS/MMS. Inbound SMS arrives as `sms.received` events in the Events Mailbox. View message history: `GET /v1/messages?limit=20` --- ## Update Agent (System Prompt, Voice, etc.) `PATCH /v1/agents/$AGENTLINE_AGENT_ID` with any of: | Field | Description | |-------|-------------| | `system_prompt` | Default instructions for ALL calls (inbound + outbound). Per-call override via `POST /v1/calls` takes priority. | | `initial_greeting` | Default opening line spoken on ALL calls (inbound + outbound). Per-call override via `POST /v1/calls` takes priority. | | `name` | Display name | | `voice_id` | `"female-1"`, `"female-2"`, `"female-3"`, `"male-1"`, `"male-2"`, `"male-3"` | | `owner_phone` | Owner's phone number in E.164 format. Calls from this number enter **task mode**. | --- ## Get/List Agents - **Get one:** `GET /v1/agents/$AGENTLINE_AGENT_ID` - **List all:** `GET /v1/agents` --- ## Voice Settings Priority (highest wins): per-call โ†’ per-agent โ†’ per-account - **List voices:** `GET /v1/voices` - **Set account default:** `PATCH /v1/account/voice` with `{"voice_id": "female-1"}` - **Check current:** `GET /v1/account/voice` - **Reset to default:** `DELETE /v1/account/voice` --- ## Phone Numbers Each agent needs one phone number. Only US numbers supported. **$2.00 per number.** ### Provision (Buy) a Number `POST /v1/numbers` with: | Field | Required | Description | |-------|----------|-------------| | `agent_id` | Yes | Agent to attach to | | `country` | Yes | Must be `"US"` | | `area_code` | No | Preferred 3-digit area code (e.g. `"212"`, `"313"`). **Always ask the user!** | | `number_type` | No | `"local"` or `"tollfree"` (default: local) | If no numbers are available for the requested area code, the API returns an error โ€” ask the user for a different area code. ### List Numbers `GET /v1/numbers` --- ## Billing - **Check balance:** `GET /v1/billing/balance` - **Expenditure:** `GET /v1/billing/expenditure?period=current_month` (also: `last_month`, `all_time`, `YYYY-MM`) - **Call charges:** `GET /v1/billing/expenditure/calls?limit=10` - **Number charges:** `GET /v1/billing/expenditure/numbers` - **Verify charge:** `GET /v1/billing/verify/` ### Rates | Item | Cost | |------|------| | Calls (in/out) | $0.10/min (billed per second) | | Phone number | $2.00 (one-time) | --- ## Feedback Hit a bug, an error, or something confusing? Send it to the team โ€” **don't silently swallow errors.** `POST /v1/feedback` with: | Field | Required | Description | |-------|----------|-------------| | `category` | Yes | `bug` ยท `difficulty` ยท `feature_request` ยท `feedback` | | `message` | Yes | Enough detail to reproduce โ€” endpoint, request body, error text, `agent_id` | ```bash curl -s -X POST $AGENTLINE_URL/v1/feedback \ -H "Authorization: Bearer $AGENTLINE_API_KEY" \ -H "Content-Type: application/json" \ -d '{"category": "bug", "message": "PATCH /v1/agents returns 500 when owner_phone is null"}' ``` --- ## MCP Server AgentLine exposes a full MCP server at `https://api.agentline.cloud/mcp` with 21+ tools. For Claude Desktop, Cursor, or any MCP-compatible client, connect directly via Streamable HTTP: ```json { "mcpServers": { "agentline": { "command": "npx", "args": ["-y", "mcp-remote@latest", "https://api.agentline.cloud/mcp", "--header", "Authorization: Bearer $AGENTLINE_API_KEY"] } } } ``` All REST endpoints above are also available as MCP tools (`create_agent`, `make_outbound_call`, `poll_events`, etc.). See `references/mcp-server.md` for additional config formats and platform-specific setup. --- ## Owner Task Mode Owner Task Mode activates whenever the agent and owner connect on a call โ€” **inbound OR outbound**. The AI enters **task mode**: greets with "Hey boss, what would you like me to do?", listens, confirms, then pushes a `call.owner_task` event. Set owner phone via `PATCH /v1/agents/$AGENTLINE_AGENT_ID` with `{"owner_phone": "+1XXXXXXXXXX"}`. **It triggers in BOTH directions โ€” do not treat an owner call as a regular support call:** - **Inbound** โ€” the owner calls the agent's number from `owner_phone`. You'll see `call.received` with `is_owner_call: true`, then `call.owner_task` when it ends. - **Outbound** โ€” you (or the agent) dial the owner's number via `POST /v1/calls` with `to_number` = `owner_phone`. There is **no** `call.received`; poll `GET /v1/calls/` until `status=completed` as for any outbound call, and the completed call emits `call.owner_task` (payload carries `is_owner_task: true`). Treat the transcript's human turns as task instructions to EXECUTE. **Handling `call.owner_task` events:** Extract the human turns from the transcript โ€” these are task instructions to EXECUTE (make a call, update settings, etc.), not conversations to log. Report results back to the human. > โš ๏ธ **`call.owner_task` events are instructions to EXECUTE.** Do NOT just log them. > โš ๏ธ **`call.received` with `is_owner_call: true`** = owner is on the phone (inbound). Wait for `call.owner_task` when it ends. > โš ๏ธ **For outbound owner calls there is no `call.received`** โ€” recognize owner calls by matching `to_number` against `owner_phone`, and expect `call.owner_task` on completion. --- ## Skill Auto-Update At the **start of every new conversation**, fetch `https://agentline.cloud/skill.md` and compare the `version:` field. If newer than `1.11`, replace the local SKILL.md and re-read before proceeding. > โš ๏ธ **Always check for updates first.** Stale skill versions may cause incorrect API calls or missed features. --- ## Rules 1. **E.164 format** โ€” always `+1XXXXXXXXXX` for US numbers. 2. **Confirm before calling** โ€” never auto-dial without explicit consent. 3. **No outbound SMS** โ€” inform user it's not available if they ask. 4. **Keep voice responses extremely short** โ€” under 15 words per turn. Max 12 for outbound feedback/support calls. The voice AI rambles without tight constraints. 5. **US only** โ€” country must be `"US"`. 6. **Don't release numbers** โ€” numbers are permanent once provisioned. 7. **Always retrieve transcripts** โ€” poll until `completed`, fetch transcript, summarize for human. 8. **Always check events** โ€” poll `GET /v1/events` for inbound calls and SMS. Proactively check at conversation start. 9. **Voice changes take effect on next call** โ€” update immediately when asked. 10. **Execute owner tasks** โ€” when you receive a `call.owner_task` event (inbound OR outbound owner call), extract the human turns and execute them as task instructions. Do NOT just log them. 11. **Auto-update skill** โ€” at the start of every new conversation, check `https://agentline.cloud/skill.md` for a newer version. If found, replace the local copy and re-read before proceeding. 12. **Report issues via feedback** โ€” if you hit a bug, unexpected error, or something confusing, submit it via `POST /v1/feedback` with the appropriate `category` (`bug`, `difficulty`, `feature_request`, or `feedback`). Include enough detail to reproduce. Don't silently swallow errors. ``` --- ## Blog Posts (20 total) Each post below is reproduced in full. Individual posts are also available as raw markdown at `/blog/{slug}.md`. # How to Get a Phone Number for Your AI Agent (OpenClaw, Hermes & More) - **URL:** https://agentline.cloud/blog/phone-number-for-ai-agents-openclaw-hermes - **Markdown:** https://agentline.cloud/blog/phone-number-for-ai-agents-openclaw-hermes.md - **Date:** 2026-06-27 - **Author:** Sameer Srivastava - **Read time:** 8 min read - **Tags:** `Phone Number`, `AI Agents`, `OpenClaw`, `Hermes Agent`, `Agentic Calling`, `Voice API`, `Guide` > Your AI agent can code, think, and automate โ€” but can it answer a phone call? Here's how to get a real phone number for OpenClaw, Hermes Agent, and any AI agent in under 10 minutes. Plus: what agentic calling is and why it's the next frontier in 2026. --- AI agents have gotten remarkably capable. They write code, answer questions, manage calendars, and automate workflows. But most of them have the same limitation: they're stuck in text. They can't pick up a phone when someone calls. They can't make an outbound call when something urgent happens. They can't send a text when a customer needs a reminder. This guide covers everything you need to know about giving your AI agent a real phone number. Whether you're running OpenClaw, Hermes Agent, or something you built yourself, here's how to add voice and SMS in under 10 minutes. **What Is Agentic Calling? Before we dive into phone numbers, let's talk about the concept behind them. Agentic calling is when an AI agent autonomously makes or receives phone calls as part of a workflow. It's not a chatbot on a phone line. It's an agent that decides when to call, what to say, and how to handle the conversation. Think of it like this: traditional phone systems are human-driven. Someone picks up the phone, dials a number, and talks. Agentic calling flips that. The AI agent decides when a call needs to happen, initiates it, handles the conversation, and takes action based on what happens. No human in the loop. Examples of agentic calling: a new lead signs up and your AI agent calls them within 60 seconds. A server goes down at 3am and your agent calls the on-call engineer. A patient misses their appointment and your agent reschedules. A payment fails and your agent calls to update billing info before service gets cut off. Agentic calling is one of the fastest-growing areas in AI infrastructure because it closes the loop between agents and the real world. **Phone Numbers for OpenClaw OpenClaw is a powerful agent framework. It manages files, runs terminal commands, orchestrates workflows, and interacts with APIs. But it can't handle phone calls natively. Getting an OpenClaw phone number with AgentLine takes 5 steps: sign up at agentline.cloud for an API key, install the AgentLine skill in OpenClaw, create an agent, buy a phone number ($2.00), and start making calls. The skill handles all telecom complexity: call routing, speech-to-text, text-to-speech, and number provisioning. Your OpenClaw agent sends text and receives text. Building it yourself with Twilio takes weeks: provision a number, set up WebSocket media streams, integrate Deepgram or AssemblyAI for transcription, pipe responses through Cartesia or ElevenLabs for voice, and manage call state. Most OpenClaw users who tried DIY gave up at the WebSocket debugging phase. One OpenClaw user routes all customer calls through their agent. The agent authenticates callers, handles routine questions, and escalates complex issues to humans. They went from 200+ daily support calls to about 60 that actually need a person. **Phone Numbers for Hermes Agent Hermes Agent has the same limitation: incredibly capable in text, no native voice support. You need a telephony layer. AgentLine works identically with Hermes Agent: install the skill, set your API key, and your Hermes agent can immediately make outbound calls, receive inbound calls on a dedicated number, send and receive SMS, and read call transcripts. A phone number for your Hermes agent lets it call you when server health checks fail instead of waiting for you to check a dashboard. Or call new leads within minutes of a contact form submission. Or handle customer support during off-hours. The setup flow is identical regardless of agent framework โ€” that's the advantage of a purpose-built AI telephony layer. **Phone Numbers for Any AI Agent What if you built your own agent? AgentLine provides a REST API that any agent can call. Your agent creates an agent and buys a number through the API. For outbound calls, POST to /v1/calls. For inbound, AgentLine sends transcripts to your webhook. Your agent responds with text, AgentLine speaks it to the caller. Any agent โ€” LangChain, AutoGPT, custom Python, no-code โ€” can have phone capabilities. No telecom protocols needed. Just HTTP requests. **The Voice API for AI Agents AgentLine provides a voice API purpose-built for AI agents. Unlike Twilio or Vonage that expect you to build voice infrastructure, a purpose-built AI voice API handles: number provisioning, real-time speech-to-text, natural text-to-speech via Cartesia, call state management, and webhook-based event delivery. For OpenClaw calling specifically, the skill wraps this API so you don't need direct HTTP calls. Tell your agent to call someone and the skill handles the rest. The API supports programmatic access for custom integrations: curl -X POST https://api.agentline.cloud/v1/calls with your agent ID and the number to dial. One API call initiates the entire phone conversation. **SMS Capabilities Every AgentLine phone number handles both voice and SMS. Common SMS workflows: appointment reminders, two-factor auth codes, order status updates, follow-up texts after calls, and alerts where voice would be too disruptive. The agent reads incoming texts, processes them, and responds โ€” same as voice but asynchronous. **Real Use Cases for Agentic Calling Customer support that never sleeps: Your AI agent answers 24/7, handles common questions, escalates complex issues. One SaaS team reduced support call volume from 200/day to 60/day. Sales follow-up at speed: Leads contacted within 5 minutes convert at 3-4x the rate of later contacts. An AI agent calls every lead within 60 seconds. Healthcare appointment reminders: No-shows cost healthcare billions. AI agents reduce no-show rates by 60-70%. **Getting Started The entire setup: sign up at agentline.cloud, install the skill for your framework, buy a number ($2.00), write a prompt, and make your first call. Under 10 minutes total." --- # What You Can Build When Your AI Agent Has a Phone Number - **URL:** https://agentline.cloud/blog/ai-agent-phone-number-real-use-cases - **Markdown:** https://agentline.cloud/blog/ai-agent-phone-number-real-use-cases.md - **Date:** 2026-05-08 - **Author:** Sameer Srivastava - **Read time:** 8 min read - **Tags:** `AI Agents`, `Use Cases`, `Voice AI`, `Automation`, `Customer Support`, `Sales` > Giving your AI agent a phone number sounds interesting in theory. But what can you actually build? Here are five real use cases teams are running on AgentLine right now. --- A lot of people hear "AI agent with a phone number" and think it sounds cool. But when they try to think through what they'd actually build with it, they draw a blank. Let me show you what's actually possible. These are real use cases that teams are building with AgentLine today. **Customer Support That Runs 24/7** Your AI agent answers calls when your team is asleep. It can handle common questions โ€” "Where's my order?", "How do I reset my password?", "What are your business hours?" โ€” and escalate anything complex to a human. The key is setting clear boundaries. Your AI should know exactly which questions it can answer and which need a person. We've found that about 60-70% of routine support calls can be handled entirely by an AI agent. The remaining 30% get warm-transferred to a human with full context of the conversation so far. One SaaS team we work with routes all calls through their AI agent first. The agent authenticates the caller, pulls up their account, and handles the basics. If the issue needs a human, the agent summarizes everything and passes it along. Their support team went from fielding 200 calls a day to handling about 60 that actually need human attention. **Sales Follow-Up That Doesn't Miss** About 80% of sales leads never get a follow-up call. Not because the team is lazy โ€” because there literally aren't enough hours in the day. An AI agent changes the math. When someone signs up for your product, your agent can call them within five minutes. It introduces itself, asks if they need help getting started, and answers initial questions. If the lead sounds interested, the agent schedules a call with a human salesperson. The speed matters. Data from our customers shows that leads contacted within five minutes convert at 3-4x the rate of leads contacted an hour later. An AI agent makes that five-minute window possible at any scale. **Healthcare Appointment Reminders** No-shows cost healthcare providers billions annually. A missed appointment means lost revenue, wasted provider time, and worse outcomes for the patient who needed to be seen. Text reminders help. But phone calls work better โ€” especially for older patients who don't check texts regularly. An AI agent can call the day before, confirm the appointment, give instructions (fasting requirements, what to bring), and answer basic questions. Clinics using this approach consistently report 50-60% reductions in no-show rates. **Order Status and Tracking** This is one of the simplest but highest-volume use cases. A customer texts or calls your number with an order ID. Your AI agent looks up the order in your database and responds with the status. No hold time. No navigating a phone tree. Just "Hey, where's my order?" and an immediate answer. Ecommerce teams tell us this alone cuts their support ticket volume by 30-40%. **Appointment Booking** If you run a service business โ€” salon, auto shop, dental practice โ€” you know the phone rings constantly with people trying to book. An AI agent can handle those calls, check availability against your calendar, and book the appointment. It can also handle rescheduling and cancellations. The person calling doesn't know they're talking to an AI. They just know they got through immediately and got their appointment booked. These aren't hypotheticals. Teams are running all of these on AgentLine today. The common thread: AI handles the volume, humans handle the exceptions. That's the model that actually works. --- # The Complete Guide to AI Agent Voice Calling in 2026 - **URL:** https://agentline.cloud/blog/ai-agent-voice-calling-complete-guide - **Markdown:** https://agentline.cloud/blog/ai-agent-voice-calling-complete-guide.md - **Date:** 2026-05-12 - **Author:** Sameer Srivastava - **Read time:** 7 min read - **Tags:** `Voice Calling`, `AI Agents`, `Tutorial`, `2026`, `Telephony`, `Getting Started` > In 2024, adding voice to an AI agent meant wrestling with WebSockets and telecom APIs. In 2026, it's a skill file. Here's what changed and how to get started. --- Two years ago, if you wanted your AI agent to handle phone calls, you were signing up for months of work. You'd need to understand SIP protocols, set up WebSocket servers, integrate separate transcription and synthesis services, and debug audio quality issues across multiple providers. Today, the picture is completely different. Purpose-built telephony layers for AI agents handle all of that โ€” and you get started by installing a skill file. This guide covers what AI agent voice calling looks like in 2026, how it works, and how to add it to your agent in under 10 minutes. **How Voice Calling Actually Works Now** The stack has simplified dramatically. Here's what happens when your AI agent makes a call in 2026: 1. Your agent tells the telephony layer who to call and what to say 2. The telephony layer dials the number through a carrier (SignalWire handles the actual phone network connection) 3. When the person answers, speech is captured and transcribed to text in real time 4. The text goes to your AI agent, which processes it and responds with text 5. The response is converted to speech (Cartesia handles voice synthesis) and played to the caller 6. This loop repeats until the call ends Your AI agent never touches audio. It just reads text and writes text. All the telecom complexity โ€” number provisioning, call routing, audio streaming, speech-to-text, text-to-speech โ€” is handled by the telephony layer. **Why This Is Better Than the Old Way** The old approach meant stitching together five different services: Twilio for numbers, a WebSocket server for audio streaming, Deepgram or AssemblyAI for transcription, ElevenLabs or Play.ht for voice synthesis, and custom code to orchestrate it all. It worked. Barely. But it broke constantly, needed maintenance, and took weeks to set up. Every time one provider changed their API, your integration broke. The new approach โ€” using a purpose-built layer like AgentLine โ€” means all of that is one API. One integration. One place to debug when something goes wrong. **Getting Started in 10 Minutes** Here's the actual setup: 1. Sign up at agentline.cloud and get your API key 2. Create an agent with a name and voice preference 3. Buy a phone number ($2.00 one-time, US only) 4. Write a system prompt that tells your agent how to behave on calls 5. Make a test call to your own number That's it. No WebSocket config. No audio format negotiation. You tell it who to call and what to say, and it handles the rest. **What About SMS?** Voice gets the attention, but SMS does a lot of the heavy lifting. Every number you provision on AgentLine handles both voice calls and text messages. When someone texts your number, your agent can read and respond โ€” same text-in, text-out model as voice calls, minus the speech conversion step. Teams use SMS for appointment confirmations, order status lookups, two-factor codes, and follow-up messages after voice calls. **Common Mistakes to Avoid** After watching hundreds of teams set up voice agents, here's what trips people up: - Rushing the prompt. Spend real time on this. A good prompt is the difference between an agent people talk to and one they hang up on. Include specific examples of good responses. Tell the agent what NOT to say. - Not testing with real callers. Your team will be polite. Strangers won't be. Test with someone who'll challenge the agent. - Forgetting about latency. There's always a small delay between when someone speaks and when your agent responds. Design your prompt to handle natural pauses. - Assuming one prompt fits all calls. Different call types need different prompts. A sales call and a support call are different conversations. Use per-call prompts when the context changes. **The Bottom Line** AI voice calling went from an infrastructure project to a feature you add in minutes. If you've been putting it off because it seemed complicated, it's not anymore. Start with a test call and build from there. --- # OpenClaw Phone Numbers: Give Your Agent Voice Calling in 10 Minutes - **URL:** https://agentline.cloud/blog/openclaw-voice-calling-agentline - **Markdown:** https://agentline.cloud/blog/openclaw-voice-calling-agentline.md - **Date:** 2026-05-15 - **Author:** Sameer Srivastava - **Read time:** 7 min read - **Tags:** `OpenClaw`, `Voice AI`, `Integration`, `Tutorial`, `Agent Framework` > Getting a phone number for your OpenClaw agent doesn't mean weeks of Twilio integration. Here's how to give your OpenClaw agent real voice calling in 10 minutes โ€” plus why purpose-built AI telephony beats building it yourself. --- If you're using OpenClaw, you already know how powerful it is. Your agent can handle files, run commands, manage your calendar, write code โ€” all through natural conversation. But one thing it probably can't do: answer a phone call. This is the gap we kept hearing about from OpenClaw users. They had agents that could do almost everything โ€” but when a customer needed to call in, their agent was useless. So they either gave out a personal number or built a complex Twilio integration that took weeks and never worked quite right. We built AgentLine to solve this properly. **Why OpenClaw + Voice Is a Powerful Combination** OpenClaw is great at orchestrating complex workflows. It can chain commands, manage files, and interact with APIs. Add voice capabilities and suddenly your OpenClaw agent can: - Take a customer call, look up their account in your database, and resolve their issue - Call a lead within seconds of them signing up on your site - Send follow-up texts after a voice conversation - Handle scheduling calls while checking your actual calendar The voice part handles the conversation. OpenClaw handles everything around it. That's the sweet spot. **The Two Paths to Voice** There are two ways to give your OpenClaw agent voice capabilities. Path one: build it yourself with Twilio. You'll need to provision a number, set up a media stream over WebSocket, pipe audio to a speech-to-text service like Deepgram, route the transcript to OpenClaw, convert OpenClaw's text response to speech with a service like Cartesia or ElevenLabs, and stream it back. You'll also need to handle call state, errors, and reconnection logic. Expect this to take a few weeks if you know what you're doing. Longer if you don't. A few OpenClaw users have done this successfully. Most gave up somewhere around the WebSocket debugging phase. Path two: use AgentLine. You install the AgentLine skill in OpenClaw, set your API key, and start making calls. All the telecom infrastructure is handled for you. OpenClaw sends text, gets text back. That's the whole integration. **Setting Up AgentLine with OpenClaw** Here's the step-by-step: 1. Sign up at agentline.cloud and get your API key (starts with sk_live_) 2. Install the AgentLine skill in OpenClaw through the skills directory 3. Create an agent through the AgentLine API or dashboard 4. Buy a phone number ($2.00, US numbers, takes about 30 seconds) 5. Tell OpenClaw to make a call The skill handles the API calls, event polling, and transcript retrieval. You just tell it who to call and what to say. **What OpenClaw Users Are Building** Here's what we're seeing in the wild: - A real estate agent who's using OpenClaw + AgentLine to call new leads from Zillow within two minutes of an inquiry. The agent qualifies the lead, answers basic questions about the property, and books a showing. - A SaaS founder whose OpenClaw agent calls every new signup to offer a personal onboarding session. About 40% of people who get the call book one. - A consultant who routes all client calls through OpenClaw first. The agent handles scheduling and basic questions. If a client needs to talk to the consultant directly, the agent texts them and they call back. None of these required custom infrastructure. They installed the skill, wrote a good prompt, and started making calls. **What to Watch Out For** A few things to keep in mind: - The initial greeting matters a lot. People decide in the first five seconds whether to keep listening. Write something natural. Don't announce you're an AI unless you have a good reason. - Test your prompt with real callers. Your friends will be nice. Strangers won't be. The agent needs to handle confused, frustrated, and impatient callers. - Set up event polling so you know when calls complete and can read transcripts. The AgentLine skill handles this automatically if configured. **Bottom Line** OpenClaw is already one of the most capable agent frameworks out there. Adding voice makes it dramatically more useful. The DIY path works but it's painful. AgentLine exists so you don't have to go through that. If you're comparing frameworks, check out our full guide on getting phone numbers for OpenClaw, Hermes Agent, and any AI agent. --- # How to Give Your AI Agent a Phone Number in Under 10 Minutes - **URL:** https://agentline.cloud/blog/ai-agent-phone-number-guide - **Markdown:** https://agentline.cloud/blog/ai-agent-phone-number-guide.md - **Date:** 2026-05-18 - **Author:** Sameer Srivastava - **Read time:** 8 min read - **Tags:** `AI Agents`, `Voice API`, `Integration`, `Tutorial`, `Phone Number`, `Setup Guide` > Most AI agents can code, write, and think โ€” but can they answer a customer call? Here's how to equip any AI agent with a real phone number in under 10 minutes. --- Here's a question I get from developers building AI agents all the time: My agent can handle text, can it handle phone calls? The short answer is yes. But most AI agents today are stuck in text-only mode. They can write code, answer questions, generate content โ€” but they can't pick up a phone when a customer calls. That's a real gap that limits what your agent can do. In this guide, I'll walk you through exactly how to give your AI agent a real phone number โ€” one that can make outbound calls, receive inbound calls, and handle SMS. We'll use AgentLine as the telephony layer, and the whole process takes under 10 minutes. No telecom expertise required. **Why Would You Even Want This?** Text is great. But phone calls unlock something different: - Real-time support: Customers can call in and get immediate answers, no ticket queue - Accessibility: Not everyone wants to type. Some users just want to call - Alerts and notifications: Your agent can call you when something important happens - Higher conversion: Outbound call follow-ups after signups consistently outperform email When we launched AgentLine, we talked to dozens of teams building AI agents. Almost all of them had hit the same wall โ€” their agent could do everything in text, but couldn't handle a simple phone call. **Step 1: Get Your API Key** Go to agentline.cloud and sign up. You'll get an API key immediately. It starts with sk_live_. This key authenticates all your requests to the AgentLine API. **Step 2: Create Your Agent** An agent is the AI personality that handles calls. Create one with a single API call: curl -X POST https://api.agentline.cloud/v1/agents -H "Authorization: Bearer YOUR_API_KEY" -H "Content-Type: application/json" -d '{"name": "My Agent", "voice_id": "female-2"}' You'll get back an agent ID (starts with agt_). Save it. Voice options: female-1 (professional), female-2 (warm), male-1 (deep). You can also use any Cartesia voice UUID. **Step 3: Buy a Phone Number** Your agent needs a number. Provision one: curl -X POST https://api.agentline.cloud/v1/numbers -H "Authorization: Bearer YOUR_API_KEY" -H "Content-Type: application/json" -d '{"agent_id": "agt_YOUR_ID", "country": "US", "area_code": "313"}' Cost: $2.00 one-time. Pick an area code that matches your business location. Numbers are US-only for now. You'll get a number back immediately โ€” it can make and receive calls and texts right away. **Step 4: Write Your Prompt** This is where most people rush. Don't. The prompt determines how your agent sounds, thinks, and handles edge cases. A good prompt includes: - Who the agent is (give it a name and personality) - What it should do (specific instructions for common scenarios) - What it should NOT do (boundaries are as important as instructions) - How to escalate (when to hand off to a human) - Example conversations (showing is better than telling) Spend at least 30 minutes on this. Test it. Revise. Test again. **Step 5: Make Your First Call** Your agent is ready. Make a test call to yourself first. Make sure the voice sounds natural, latency is acceptable, and the agent responds appropriately. Then try it with a friend who'll give honest feedback. **Step 6: Set Up Event Polling** When someone calls your agent's number or a call completes, you need to know about it. AgentLine has an event mailbox system. Your agent should poll GET /v1/events periodically to pick up call completions, transcripts, and inbound SMS. **What This Unlocks** Once your agent has a phone number, you can handle inbound support calls 24/7, make outbound sales follow-ups, send and receive SMS, build no-code workflows that trigger calls, and create multi-step sequences. **Pricing** Calls cost $0.10 per minute, billed per second. Phone numbers are $2.00 one-time. No hidden fees, no minimum commitment. A typical support call costs $0.30-0.50. Compare that to the cost of a human handling the same call. **Next Steps** Start with a test call. Then think about the one use case that would make the biggest difference for your team right now โ€” support, sales, scheduling, whatever it is. Build that first. Once it's working, expand from there. --- # AI Voice Agent for Customer Support: The 2026 Playbook - **URL:** https://agentline.cloud/blog/ai-voice-agent-customer-support-playbook - **Markdown:** https://agentline.cloud/blog/ai-voice-agent-customer-support-playbook.md - **Date:** 2026-05-20 - **Author:** Sameer Srivastava - **Read time:** 8 min read - **Tags:** `AI Voice Agent`, `Customer Support`, `Automation`, `2026`, `Support Playbook`, `ROI` > Customer support teams are understaffed and overworked. Here's how AI voice agents handle the volume โ€” without replacing your human team. --- If you're running a customer support team in 2026, you've probably felt the squeeze. Customers expect fast answers. Your team is small. And every time you scale volume, you scale costs. AI voice agents change that equation. They answer calls, handle common issues, and escalate complex ones โ€” without breaks, without queues, and without burning out your human team. This isn't about replacing humans. It's about handling the volume that shouldn't need a human in the first place. **Setting Up Your Support Agent** A good support AI agent starts with a clear understanding of what it can and cannot do. Here's the framework: First, identify your top 20 support questions. These are the calls your team gets over and over: "Where's my order?", "How do I reset my password?", "What's your return policy?" Write clear, accurate answers for each one. Your AI agent will handle these autonomously. Second, define your escalation rules. Anything involving billing disputes, account cancellations, security issues, or legal concerns should go to a human immediately. No exceptions. The agent should say "Let me connect you with someone who can help with that" and transfer the call. Third, give your agent access to relevant data. It should be able to look up orders, check account status, and verify customer identity. The more context it has, the more it can resolve without escalating. **What AI Support Agents Do Well** They handle the stuff your team hates: - Password resets and account access issues - Order status and tracking questions - Business hours and location lookups - Basic troubleshooting with step-by-step instructions - Gathering information before a human takes over They don't do well with: - Emotionally charged situations (angry customers, complaints) - Unique edge cases that aren't in the knowledge base - Decisions that require business judgment (refunds, exceptions) The rule: if a support script could handle it, an AI agent can handle it. If it requires judgment, escalate. **Measuring Success** Don't track "calls handled" โ€” that's a vanity metric. Track these instead: - First-call resolution rate: What percentage of calls does the AI resolve without escalating? Aim for 60%+. - Customer satisfaction: Send a one-question survey after AI-handled calls. "Was your issue resolved?" Yes/No is enough. - Escalation accuracy: When the AI escalates, was it the right call? Track false escalations and missed escalations. - Time saved: How many hours of human agent time did the AI free up? This is your ROI number. One SaaS team we work with saw their support team go from handling 200 calls a day to about 60 that actually needed human attention. Their CSAT scores stayed flat. Their cost per call dropped 70%. **Integration with Your Existing Stack** Your AI support agent should plug into your existing tools. AgentLine works with help desks (Zendesk, Intercom, Freshdesk), CRMs (HubSpot, Salesforce), knowledge bases (Notion, Confluence), and no-code platforms (Make, n8n, Zapier). **The Hybrid Model That Works** The best support setups use a tiered model: Tier 1: AI agent handles everything it can. This catches 60-70% of calls. Tier 2: Human agents handle escalations with full context from the AI conversation. Tier 3: Specialists handle the hardest cases โ€” billing, legal, technical deep-dives. This model scales. As call volume grows, the AI handles more without adding headcount. Your human team focuses on work that actually needs humans. **Getting Started This Week** Don't try to automate everything at once. Pick your top five support questions. Set up your agent to handle those. Run it for two weeks. Review the transcripts. Tune the prompts. Then add five more. The teams that succeed start small and iterate. The teams that fail try to automate everything on day one and end up with an agent that's mediocre at everything. --- # AI Agents with Phone Numbers: Why Twilio Is the Hard Way - **URL:** https://agentline.cloud/blog/ai-agent-phone-calls-vs-twilio - **Markdown:** https://agentline.cloud/blog/ai-agent-phone-calls-vs-twilio.md - **Date:** 2026-05-22 - **Author:** Sameer Srivastava - **Read time:** 8 min read - **Tags:** `AI Agents`, `Twilio`, `Voice Calling`, `Comparison`, `Telephony`, `Infrastructure` > Twilio was built for human call centers, not AI agents. If you've tried to add voice to your agent and hit a wall of WebSockets, here's why โ€” and the alternative. --- You've probably seen the tutorials. "Add telephony to your AI agent using Twilio." They make it sound straightforward. Buy a number, set up WebSockets, integrate speech-to-text, pipe in text-to-speech, handle the call state. Then you actually try it and spend three weeks debugging WebSocket connections, transcription lag, and audio quality issues โ€” only to end up with something that mostly works and requires constant maintenance. **What Twilio Actually Requires for AI Voice** Here's what a Twilio-based AI voice setup really looks like: 1. Number provisioning through Twilio. This part is actually easy. 2. Media streams over WebSocket. You need a server that accepts bidirectional audio streams and handles disconnections gracefully. This is where most people get stuck. 3. Speech-to-text service. Deepgram or AssemblyAI. Both require API integration, cost money, and add latency. 4. Text-to-speech service. ElevenLabs (great but expensive), Cartesia (fast), or Polly (cheap but robotic). 5. Orchestration layer. Custom code that ties it all together. Receive audio, send to STT, get transcript, send to AI model, get response, send to TTS, stream back. Handle errors at every step. 6. Ongoing maintenance. Every service updates its API. Your integration breaks. You fix it. Repeat. This isn't a weekend project. It's a multi-week engineering effort. **When Twilio Makes Sense** Twilio is right if you have a dedicated engineering team, need fine-grained control over the audio pipeline, handle extremely high call volumes where per-minute costs justify the investment, or already have Twilio integrated. **When Twilio Doesn't Make Sense** Twilio is wrong if you're a small team that can't dedicate someone to telecom infrastructure, need to launch quickly, want predictable costs without per-service billing from five different providers, or are building an AI-first product. Most AI agent builders fall into this second category. **The AgentLine Approach** AgentLine was built specifically for AI agents. The entire stack โ€” number provisioning, call routing, speech-to-text (via Deepgram), text-to-speech (via Cartesia), and event handling โ€” is bundled into one API. Your AI agent sends text. It gets text back. The platform handles everything in between. Setup: sign up, get API key, create agent, buy number ($2.00 one-time), make a call. No WebSocket config. No STT/TTS provider selection. No custom orchestration code. **Cost Comparison** Twilio DIY stack at moderate volume: Twilio voice (~$0.014/min), Deepgram STT (~$0.006/min), ElevenLabs TTS (~$0.015/min), server hosting ($20-50/month), plus significant engineering time. AgentLine: $0.10/min all-in (including STT and TTS). Number: $2.00 one-time. No server costs. For low to moderate volume, AgentLine is cheaper because you're not paying for engineering time or server hosting. At very high volumes, DIY can be cheaper per-minute if you've already amortized the build. **The Real Question** Are you building a telecom company, or are you building an AI product? If the answer is the second one, use a tool built for AI agents. Don't become a telecom engineer by accident. --- # How Sales Teams Use AI Agents to Never Lose a Lead Again - **URL:** https://agentline.cloud/blog/ai-agent-call-tracking-sales-teams - **Markdown:** https://agentline.cloud/blog/ai-agent-call-tracking-sales-teams.md - **Date:** 2026-05-24 - **Author:** Sameer Srivastava - **Read time:** 7 min read - **Tags:** `AI Agents`, `Sales`, `Lead Follow-Up`, `Automation`, `CRM`, `Conversion` > 80% of sales leads never get a follow-up call. Not because the team is lazy โ€” there aren't enough hours in the day. AI agents change the math. --- The stats are brutal. About 80% of sales leads never get followed up on. Not because the team is lazy โ€” because there's not enough time. Your salespeople can make so many calls a day, and every call they don't make is a potential customer who moves on to a competitor. This is where AI agents with phone capabilities change everything. **The Lead Follow-Up Problem, By the Numbers** Leads contacted within 5 minutes of signup convert at 3-4x the rate of those contacted after 30 minutes. After 1 hour, conversion rates drop by 7x. The average salesperson makes 30-40 calls a day. With 100+ leads coming in daily, 60-70 never get a call. This isn't a motivation problem. It's a math problem. Humans can't scale to meet the speed requirement. **How AI Call Agents Change the Math** An AI agent can call a lead within 60 seconds of signup. Every lead. Every time. The agent introduces itself, asks if the lead needs help, answers basic questions, and if interested, schedules a follow-up with a human. The AI doesn't close deals. It qualifies leads and gets them into the pipeline faster than any human team could. The workflow: lead signs up, CRM fires a webhook, AgentLine initiates an outbound call, AI agent has a conversation, outcome is logged back to CRM. The entire loop: under 90 seconds. **Setting Up Outbound Sales Calls** You need an AgentLine account with a number, a system prompt tuned for sales, and a webhook that triggers calls from your CRM. The prompt is critical. Template: "You are Alex, calling from [Company]. A potential customer just signed up. Your goal is to be genuinely helpful, not salesy. Introduce yourself briefly. Ask if they have questions. If interested, offer to schedule a demo. If not interested, thank them and let them go. Never push. Keep it under 3 minutes." **What Good Sales AI Agents Do** Respond instantly to new leads. Qualify interest level quickly. Answer common pre-sales questions. Schedule demos and follow-ups. Log everything to CRM automatically. **What They Don't Do** Negotiate pricing. Handle complex objections. Close enterprise deals. Replace your sales team. The AI handles volume and speed. Your sales team handles the conversations that matter. **Real Results** A B2B SaaS company we work with was losing 70% of leads to slow follow-up. They set up an AI agent to call every lead within two minutes. Results after three months: lead-to-demo conversion up 40%, sales team spending 100% of time on qualified demos, zero complaints, cost per qualified lead down 60%. **Getting Started** Build the integration once. Connect your CRM to AgentLine. Write a good prompt. Test with your team first, then friendly customers, then roll out. Start with new signups, then expand to abandoned carts, trial expirations, and cold lead re-engagement. --- # AI Phone Agents for Healthcare: Cut No-Shows by 60% - **URL:** https://agentline.cloud/blog/ai-phone-agent-for-healthcare-appointment-reminders - **Markdown:** https://agentline.cloud/blog/ai-phone-agent-for-healthcare-appointment-reminders.md - **Date:** 2026-05-26 - **Author:** Sameer Srivastava - **Read time:** 8 min read - **Tags:** `AI Phone Agent`, `Healthcare`, `Appointment Reminders`, `Automation`, `HIPAA`, `ROI` > Missed appointments cost healthcare billions. A phone call from an AI agent the day before cuts no-show rates dramatically โ€” without adding staff workload. --- No-shows cost the healthcare industry billions every year. A patient who doesn't show up for an appointment means lost revenue, wasted provider time, and worse health outcomes for patients who needed to be seen. Most clinics have tried the obvious solutions: reminder emails, text messages, even apps. But no-show rates stay stubbornly high. **Why Texts and Emails Aren't Enough** The average no-show rate in US clinics is around 18-23%. Text reminders reduce that by about 10-15 percentage points โ€” better, but still leaving a significant problem. Phone calls work better because older patients often don't check texts, reminder texts are easy to ignore, texts don't answer questions ("Do I need to fast?"), and patients can't easily confirm or reschedule via text. A phone call is two-way. **How AI Reminder Calls Work** Your scheduling system pushes tomorrow's appointments to AgentLine. The night before or morning of, your AI agent calls each patient. It confirms the appointment, gives prep instructions, and answers questions. If the patient needs to reschedule, the agent offers available slots or connects them to the front desk. If no answer, it leaves a voicemail and follows up with a text. This can be done through a no-code integration with Make or n8n, or via direct API. **What About HIPAA?** AgentLine is not HIPAA-compliant as a platform. For reminder calls that don't involve protected health information beyond the appointment time, this is generally fine. The call script should avoid mentioning specific medical conditions, test results, or treatment details. If you need to discuss PHI on calls, consult a healthcare compliance specialist. Basic reminders that say "You have an appointment with Dr. Smith tomorrow at 2pm. Please arrive 15 minutes early" are typically acceptable. **Patient Response Rates** Data from clinics using AI reminder calls: 85-90% of patients answer or listen to the voicemail, 60-70% verbally confirm, 15-20% ask a question or reschedule. No-show rates typically drop by 50-60% compared to text-only reminders. The biggest impact comes from the two-way nature of a phone call. When a patient says "I'll be there" out loud, they're more likely to show up. **The Multi-Channel Approach** Best results come from combining: AI phone call 24 hours before, follow-up text with details and confirmation link, second text reminder 2 hours before. The call handles engagement and questions. The texts handle the practical reminder. Together, they push no-show rates into single digits. **Implementation for Clinics** Sign up for AgentLine, provision a number with your clinic's area code, export tomorrow's appointments from your scheduling system, use Make or n8n to automate call triggers, write a warm call script, run it for a week, review logs, tune. Most clinics start with a manual CSV export and no-code automation. Once working, they build a direct EMR integration. **The ROI Math** An average missed appointment costs a clinic $200 in lost revenue. At 50 no-shows a month, that's $10,000 โ€” $120,000 a year. An AI reminder system costs $0.30-0.50 per call. For 1,000 reminder calls a month, that's $300-500. If it reduces no-shows by 50%, you're saving $5,000 a month on a $400 investment. The math works at almost any clinic size. Start with the highest-value appointment types first โ€” specialists, new patients, procedures. --- # From Call Center to AI Stack: Automate Phone Work at Scale - **URL:** https://agentline.cloud/blog/ai-agent-call-center-automation - **Markdown:** https://agentline.cloud/blog/ai-agent-call-center-automation.md - **Date:** 2026-05-28 - **Author:** Sameer Srivastava - **Read time:** 8 min read - **Tags:** `AI Agent`, `Call Center`, `Automation`, `ROI`, `Customer Experience`, `Cost Savings` > The traditional call center โ€” humans answering every call โ€” doesn't scale. Here's how teams are building AI-first phone stacks that handle volume without burning out staff. --- The call center model hasn't changed much in decades. You hire humans, they answer calls, you scale by hiring more humans as call volume grows. It's simple but it's expensive, and it doesn't handle spikes well โ€” you're either overstaffed (wasting money) or understaffed (angry customers). AI agents change that model fundamentally. **The Math of Traditional Call Centers** A mid-size call center: 50 agents at $35,000/year each ($50,000 fully loaded). Annual cost: $2.5 million. Average 40 calls per agent per day. Total capacity: 2,000 calls/day. Cost per call: $6-8. Add 30-45% annual turnover at $5,000-10,000 per replacement. The cost structure is linear with volume. That's the problem. **Where AI Agents Fit** AI agents don't replace the call center. They restructure it. Think of it as a filter. The AI handles the front line โ€” greeting, authenticating, handling routine questions, gathering information. Only calls needing human judgment get routed to a person. 60-70% of calls are fully resolved by AI. 20-25% are partially handled (info gathering then warm transfer). 5-10% go straight to humans. Your human agents go from 40 calls a day to 15-20 โ€” but every call actually needs their skills. **The Hybrid Model** Layer 1: AI Frontline โ€” answers every call instantly, authenticates, handles routine questions, routes complex issues with full context. Layer 2: Human Specialists โ€” handle escalated calls with AI-generated summaries, focus on problem-solving. Layer 3: Operations โ€” AI improves based on call data, humans review edge cases, analytics track everything. **Cost Comparison** Traditional (50 agents, 2,000 calls/day): ~$2.5M/year, ~$6-8/call. Hybrid (15 agents + AI layer): ~$750K humans + ~$58K AI = ~$808K/year, ~$2/call. That's a 68% reduction in cost per call, with faster answer times and no hold queues. **Implementation Timeline** Phase 1 (Weeks 1-2): AI for after-hours calls only. Low-risk testing ground. Phase 2 (Weeks 3-4): Route portion of daytime calls to AI. Start with easiest call types. Phase 3 (Weeks 5-8): Expand to more call types. Introduce warm transfers. Track resolution rates. Phase 4 (Week 9+): Optimize. Review data, identify patterns, update prompts. AI improves weekly. **Metrics That Matter** AI resolution rate (target 60%+), time to answer (first ring), escalation rate, customer satisfaction (simple post-call survey), cost per call, agent satisfaction (are your humans happier?). **The Real Transformation** For customers: no hold times, faster resolutions, human attention for things that need it. For agents: no more password resets and order tracking. Every call requires real problem-solving. Burnout drops. For the business: predictable costs, easy scaling, better data from transcribed calls, continuous improvement. This is already happening. The teams making the switch aren't going back. --- # Connect AgentLine to No-Code Platforms: Make, n8n & Zapier - **URL:** https://agentline.cloud/blog/integrate-agentline-nocode-automation - **Markdown:** https://agentline.cloud/blog/integrate-agentline-nocode-automation.md - **Date:** 2026-06-01 - **Author:** Sameer Srivastava - **Read time:** 8 min read - **Tags:** `No-Code`, `Automation`, `Make`, `n8n`, `Zapier`, `Integration` > Your AI agent can handle phone calls. But what if you could trigger those calls from a no-code workflow? Here's how to connect AgentLine to Make, n8n, and Zapier in minutes. --- One of the most common questions we get at AgentLine is about automation. People love that their AI agent can make and receive calls, but they want those calls to be part of a bigger workflow. A new lead signs up on your website, and your agent calls them. A payment fails, and your agent calls to sort it out. This is where no-code platforms come in. Tools like Make (formerly Integromat), n8n, and Zapier let you build workflows that connect different apps together. And AgentLine works great with all of them. **Why No-Code Matters for AI Phone Agents** You could build these integrations with code. Write a webhook handler, connect to your CRM, set up triggers, handle errors. But that takes time and needs maintenance. No-code platforms handle the plumbing for you. Here's what no-code unlocks for your AI agent: - Trigger calls from any event: new form submission, new Stripe payment, new row in Airtable, new calendar booking - Log call outcomes to your CRM, spreadsheet, or database automatically - Send follow-up texts or emails based on what happened on the call - Build multi-step sequences: call, wait, text, call again **Setting Up AgentLine with Make** Make is probably the most flexible no-code platform for this kind of work. Here's the setup: First, create a new scenario in Make. Add a trigger module. This could be a webhook (AgentLine can POST to it when a call completes), or it could be a watch module from another app ("Watch new rows in Airtable", "Watch new Stripe payments"). Second, add an HTTP module that calls the AgentLine API. You'll need three things: your API key (from your AgentLine dashboard), your agent ID, and the phone number you want to call. The HTTP module should POST to https://api.agentline.cloud/v1/calls with a JSON body like: { "agent_id": "agt_YOUR_AGENT_ID", "to_number": "+12125551234", "system_prompt": "You are calling a new user who just signed up. Welcome them and ask if they need help.", "initial_greeting": "Hi, this is Sarah from AgentLine. I noticed you just signed up. Do you have a minute?" } Third, add another HTTP module to retrieve the call transcript. After the call completes (AgentLine sends a webhook with the status), you can GET /v1/calls/{call_id}/transcript and store the results. **Setting Up with n8n** n8n is great if you want to self-host your automation. The setup is similar to Make: 1. Add a Webhook node as your trigger 2. Add an HTTP Request node that calls POST /v1/calls 3. Add a second HTTP Request node to fetch the transcript 4. Connect the output to your CRM, Google Sheets, Slack, or wherever you want the data to land The nice thing about n8n is you can run it on your own server. If you're already self-hosting your AI agent, n8n fits neatly into that same stack. **Setting Up with Zapier** Zapier is the most beginner-friendly option. If you're just getting started with automation, start here. In Zapier, create a new Zap with a trigger from your source app (Typeform, Google Forms, Stripe, etc.). Then add a "Webhooks by Zapier" action step that POSTs to the AgentLine API. That's basically it. The limitation with Zapier is that webhooks are a premium feature. You'll need a paid Zapier plan to use them. Make and n8n give you more flexibility on the free tier. **A Real Example: New Lead Call Flow** Let me walk through a setup we helped a SaaS company build. When someone signs up for their free trial, this sequence fires: 1. Webhook from their signup form hits Make 2. Make calls the AgentLine API to place an outbound call 3. The AI agent introduces itself, asks what the user is building, offers to help 4. When the call ends, AgentLine sends a webhook back to Make with the transcript 5. Make parses the transcript, extracts key info (what they're building, their timeline) 6. Make creates a task in their CRM with those details 7. If the user asked for a demo, Make schedules a calendar event All of this runs without any custom code. The AI agent does the talking. The no-code platform does the connecting. **Getting the Most Out of It** A few tips from teams that are running these setups in production: - Always include a clear system_prompt. The AI agent needs to know who it is and what it's supposed to do on the call. - Test with your own phone number first. Don't call real users until you've heard the conversation yourself. - Log everything. Store the call ID, transcript, and outcome. You'll want this data later for debugging and improving your prompts. - Start simple. One trigger, one call type. Get that working before you add complexity. **Getting Started** If you want to connect your AI agent to a no-code platform, here's all you need: 1. An AgentLine account with an API key (grab it from your dashboard) 2. An active agent with a phone number 3. A Make, n8n, or Zapier account From there, it's just HTTP requests. AgentLine's API is designed to be simple enough that any no-code platform can talk to it. No SDK required, no complex auth flow. Just POST with your API key in the header. Start building at agentline.cloud. --- # 5 Ways to Make Your AI Agent Sound Better on Phone Calls - **URL:** https://agentline.cloud/blog/improve-ai-agent-phone-call-quality - **Markdown:** https://agentline.cloud/blog/improve-ai-agent-phone-call-quality.md - **Date:** 2026-06-02 - **Author:** Sameer Srivastava - **Read time:** 7 min read - **Tags:** `Call Quality`, `AI Agents`, `Voice`, `Best Practices`, `Prompts` > AI phone agents are getting good, but they can still sound robotic. Here are five practical changes that make a real difference in how natural your agent sounds. --- Here's something I've noticed after listening to hundreds of AI agent phone calls: the difference between a call that feels natural and one that feels robotic isn't the AI model. It's mostly the prompt and the setup. Most people spend ten minutes writing a prompt, test it once, and assume the AI agent will figure out the rest. Then they wonder why customers hang up. Getting your AI agent to sound good on the phone isn't hard. It just takes a few specific adjustments. Here are the five changes that consistently make the biggest difference. **1. Write the Initial Greeting Like a Human, Not a Script** The first five seconds of a call determine whether someone hangs up or keeps listening. If your agent opens with "Hello, this is an automated call from..." people are already reaching for the end call button. Instead, write an opening that sounds like a person. Compare these two: Bad: "Hello, this is an AI assistant calling on behalf of Acme Corp regarding your recent inquiry. How may I assist you today?" Good: "Hey, this is Sarah calling from Acme. I saw you reached out about our pricing. Got a minute to chat?" The difference is night and day. One sounds like a robot reading a script. The other sounds like a busy but friendly person. Rules for good greetings: - Keep it under 15 words - Say who you are and why you're calling - Don't announce you're an AI - End with a question so the person talks next **2. Set the Pace with Explicit Timing Instructions** AI agents tend to be too eager. They respond instantly, talk too fast, and don't leave room for the other person to think or respond. This feels unnatural. In your system prompt, add specific timing instructions: - "Pause briefly before responding to let the other person finish their thought" - "If the person is silent for more than three seconds, gently check if they're still there" - "Don't rush to fill silence. Some people think before they speak" These small cues dramatically change how the conversation flows. The call feels like two people talking, not a question-and-answer interrogation. **3. Give Your Agent a Personality, Not Just Instructions** Most system prompts read like employee handbooks. They're all rules and no character. The result is an agent that sounds correct but boring. Give your agent a personality: - "You are Sarah. You're patient, warm, and you listen more than you talk. You genuinely care about helping the person on the other end. If you don't know something, you say so instead of making things up." This is way more effective than "You are a customer support agent. Answer questions accurately and escalate when needed." The first prompt creates a character the caller can relate to. The second creates a FAQ bot that happens to have a voice. **4. Handle Silence and Confusion Gracefully** Real phone conversations have awkward moments. People get confused. They ask you to repeat things. They trail off mid-sentence. Most AI agents handle these badly. They either ignore the confusion and plow forward, or they get stuck in a loop of "I didn't understand that." Add these fallback behaviors to your prompt: - "If someone sounds confused, rephrase what you said instead of repeating it verbatim" - "If someone asks you to slow down, slow down. Then check if that pace works better" - "If you completely misunderstood something, apologize briefly and ask for clarification. Don't pretend you understood" **5. Test with Real People, Not Just Yourself** This is the one that catches most teams. You test your agent by calling it yourself, thinking "that sounded fine," and shipping it. But you know what your agent is supposed to do. You unconsciously give it the right answers. A real customer won't. Have someone who doesn't know the product call your agent. Watch what happens. They'll ask questions you didn't anticipate. They'll go off script. They'll say things in a way you didn't plan for. Every time this happens, update the prompt. After 10 to 15 test calls, you'll have an agent that handles 90% of real conversations smoothly. **One More Thing: Voice Matters More Than You Think** The voice you pick is as important as the prompt. A warm, natural-sounding voice with slight variation in tone will outperform a flat monotone every time, even with the same prompt. AgentLine gives you voice options (female-1, female-2, male-1, and custom Cartesia voices). Pick the one that matches your brand and test it. If you're not sure, female-1 or female-2 tend to be the most natural-sounding for general use. **The Bottom Line** Getting natural-sounding AI phone calls isn't about having the best model. It's about putting in the work on prompts, pacing, personality, and testing. The teams that do this consistently have customers who can't tell they're talking to an AI. The teams that don't have customers who hang up in the first ten seconds. Spend an afternoon on these five changes. Your call success rate will thank you. Start improving your calls at agentline.cloud. --- # AgentLine vs Bland AI vs Vapi: Which AI Phone API Fits You - **URL:** https://agentline.cloud/blog/agentline-vs-competitors-comparison - **Markdown:** https://agentline.cloud/blog/agentline-vs-competitors-comparison.md - **Date:** 2026-06-02 - **Author:** Sameer Srivastava - **Read time:** 8 min read - **Tags:** `Comparison`, `Bland AI`, `Vapi`, `AI Phone API`, `Voice` > Shopping for an AI phone API? Here's an honest breakdown of AgentLine, Bland AI, and Vapi - what they're each good at, where they fall short, and which one fits your use case. --- If you're building with AI and need phone capabilities, you've probably come across three names: AgentLine, Bland AI, and Vapi. They all promise to give your AI agent a voice, but they go about it in very different ways. I run AgentLine, so I'm obviously biased. But I'll do my best to give you an honest comparison. I've used both Bland and Vapi. I know what they're good at. I also know where they drive people crazy. **What These Tools Actually Do** All three tools solve the same core problem: connecting AI to the phone network. They handle buying numbers, routing calls, transcribing speech, and converting text back to voice. You don't need to understand SIP, WebRTC, or any telecom protocols. But the similarities end there. **Bland AI: The Enterprise Powerhouse** Bland AI was one of the first players in this space. They built for scale from day one. If you need to make tens of thousands of calls simultaneously, Bland can handle it. Their infrastructure is solid. What Bland does well: - Massive scale. They handle enterprise-level call volumes without breaking a sweat - Custom voice cloning. You can clone a specific voice and use it across all calls - Analytics dashboard. Good visibility into call metrics, success rates, and trends Where Bland falls short: - Complexity. Bland's API is powerful but it's a lot to learn. Expect a learning curve measured in days, not hours - Pricing. Bland is priced for enterprises. Smaller teams can find it expensive, especially at low volumes - Developer experience. The docs are thorough but dense. You'll spend time reading before you can build Bland is the right choice if you're a large company with dedicated engineering capacity and high call volumes. If you're a two-person startup, it might be overkill. **Vapi: The Developer's Playground** Vapi took a different approach. They built an API that developers love - clean, well-documented, and flexible. If you want fine-grained control over every aspect of a call, Vapi gives you that. What Vapi does well: - Developer experience. Great docs, clean SDKs, well-designed API - Flexibility. You can customize call flows, add function calling, and build complex conversational logic - Active community. Lots of developers building on Vapi, which means lots of examples and support Where Vapi falls short: - Too much flexibility. Sometimes you just want to make a call, not configure a state machine. Vapi requires you to define everything upfront - Setup time. Getting a production-ready call flow working on Vapi takes time. It's not a "paste a skill file and go" experience - Infrastructure overhead. You still need to think about how your agent connects to Vapi. It's not turnkey Vapi is great if you're a developer who wants control. If you enjoy configuring things and you have specific conversational flows in mind, Vapi is powerful. If you want to say "call this person" and have it just work, it's more setup than you might want. **AgentLine: Built for AI Agents, Not Call Centers** AgentLine was built with a specific user in mind: someone who already has an AI agent (running in Claude Code, Cursor, OpenClaw, or their own setup) and wants to add phone capabilities without building telecom infrastructure. What AgentLine does well: - Installation speed. One skill file, two environment variables, you're making calls in under 10 minutes - No infrastructure. AgentLine runs the telephony for you. No WebSocket servers to maintain - Native AI agent experience. Your agent doesn't need to understand audio or call states. It receives text, responds with text, and AgentLine handles the rest - Unified calls and SMS. Same API, same webhook format for both voice and text - Simple pricing. Straightforward per-minute pricing, no surprises Where AgentLine falls short: - Not for custom call flows. AgentLine is designed for conversational AI agents, not rigid IVR trees. If you need "press 1 for sales, press 2 for support," there are better tools - Newer platform. AgentLine is younger than Bland and Vapi, which means the feature set is growing but not as mature in some areas - Focus on agent-native integration. If you're not already running an AI agent, AgentLine's model might not click immediately **The Honest Comparison Table** Here's how they stack up for the things that actually matter when you're building: Setup time: Bland (days), Vapi (hours to days), AgentLine (minutes) Developer experience: Bland (good), Vapi (excellent), AgentLine (excellent, simpler) Scale: Bland (enterprise), Vapi (high), AgentLine (growing) Customization: Bland (high), Vapi (very high), AgentLine (moderate - focused on conversational AI) Pricing model: Bland (enterprise/usage), Vapi (usage), AgentLine (per-minute, simple) Best for: Bland (large teams, high volume), Vapi (developers who want control), AgentLine (AI agent builders who want speed) **Which One Should You Pick** If you're building an AI agent and you want phone capabilities without becoming a telecom engineer, pick AgentLine. That's literally what we built it for. You'll be making calls in 10 minutes. If you need massive scale and have a dedicated engineering team to manage the integration, Bland AI is the right call. It's built for that. If you're a developer who wants to build custom conversational flows and you enjoy configuring things at a low level, go with Vapi. The developer experience is great. There's no universal right answer. It depends on what you're building and how much time you want to spend on integration versus building your actual product. For most AI agent builders, AgentLine hits the sweet spot: fast setup, simple API, and you never have to think about audio streams or WebSocket connections. Try it at agentline.cloud. --- # SMS for AI Agents: Text Messaging with AgentLine - **URL:** https://agentline.cloud/blog/sms-for-ai-agents-agentline-guide - **Markdown:** https://agentline.cloud/blog/sms-for-ai-agents-agentline-guide.md - **Date:** 2026-06-02 - **Author:** Sameer Srivastava - **Read time:** 6 min read - **Tags:** `SMS`, `Text Messaging`, `AI Agents`, `Workflow`, `Guide` > Voice calls get the attention, but SMS is where a lot of AI agent communication actually happens. Here's how to use AgentLine's SMS features to handle inbound texts and build text-based workflows. --- Everyone talks about AI voice agents. And voice is powerful. But here's something I've learned from watching teams build on AgentLine: SMS does a lot of the heavy lifting. Think about it. Not everyone wants to pick up a phone. But almost everyone reads their texts. SMS is low-pressure, asynchronous, and it creates a written record of every interaction. For a lot of use cases, it's actually the better channel. Here's how SMS works with AgentLine, what you can build with it, and some practical tips from teams already doing it. **How SMS Works on AgentLine** When you provision a phone number on AgentLine, it handles both voice calls and SMS. You don't need a separate number for texting. Inbound SMS works like this: someone texts your agent's number, AgentLine receives it, and if you've configured your agent to check for messages, your AI agent can read and respond. The message payload includes the sender's number, the message body, and a timestamp. Your agent sees it as text and can respond accordingly. **What You Can Build with SMS** Here are the SMS workflows teams are running on AgentLine right now: Appointment confirmations: A patient texts "confirm" and your agent confirms their appointment in the scheduling system. No phone call needed. Order status checks: A customer texts their order number and your agent looks up the status, replies with an ETA. This is one of the most common use cases we see in ecommerce. Two-factor authentication: Your agent sends a verification code via SMS when someone logs in. Simple, reliable, no separate SMS provider needed. Follow-up sequences: After a voice call, your agent sends a text with a summary or next steps. "Thanks for the call! Here's a link to schedule a demo: [link]" Alerts and notifications: When a server goes down or a payment fails, your agent texts the right person. Voice calls are great for urgent things, but a text is often enough and less disruptive. **The Voice + SMS Combo** Where SMS really shines is when it works alongside voice calls. A common pattern we see: 1. Your agent calls a lead to introduce your product 2. The lead is busy, asks to be contacted later 3. Your agent sends a text: "No worries! Text me when you have a few minutes and I'll call back. Or grab a time here: [calendar link]" 4. The lead texts back, your agent calls, conversation happens This is way better than playing phone tag. The SMS keeps the conversation alive without being pushy. **Things to Know About SMS on AgentLine** A few practical notes from the trenches: Character limits: Standard SMS is 160 characters. Longer messages get split into multiple segments. Keep your texts short and to the point. Delivery isn't guaranteed: SMS delivery depends on carriers. Most messages arrive within seconds, but some can be delayed. Build your workflow to handle this gracefully. Sender ID: Your messages come from your AgentLine phone number. If you text someone repeatedly and they save your number, they'll recognize it. This is actually an advantage for building trust over time. No MMS yet: As of now, AgentLine handles text SMS but not picture messages. If you need to send images, you'll want to use a link instead. **Building SMS Workflows** Setting up your AI agent to handle SMS is straightforward. Your agent checks for new messages and processes them like any other text input. Here's what a good SMS prompt looks like: "You receive SMS messages from users. Keep responses brief, under 160 characters. If someone asks a complex question, say 'Let me call you to discuss this in more detail.' If someone asks about pricing, say 'Check out agentline.cloud/pricing or I can call you to walk through the options.'" The key is brevity. SMS is not the place for long explanations. Get to the point. **Getting Started** If you already have an AgentLine account with a phone number, SMS is ready to go. Your number handles both voice and text from the start. If you're new to AgentLine, sign up, provision a number, install the skill file, and you can start handling both calls and texts in the same workflow. Start at agentline.cloud. --- # How a SaaS Startup Automated 80% of Customer Calls - **URL:** https://agentline.cloud/blog/agentline-case-study-automated-customer-support - **Markdown:** https://agentline.cloud/blog/agentline-case-study-automated-customer-support.md - **Date:** 2026-06-02 - **Author:** Sameer Srivastava - **Read time:** 7 min read - **Tags:** `Case Study`, `Customer Support`, `SaaS`, `Automation`, `ROI` > A small SaaS team was drowning in support calls. Three months after switching to AgentLine, their AI handles 80% of calls on its own. Here's exactly how they did it. --- Every SaaS founder knows this moment. You launch, you get customers, and then the support calls start. At first it's manageable. You answer a few calls a day. No big deal. Then you grow. Twenty calls a day. Fifty. A hundred. And suddenly your engineering team is spending half their day on the phone instead of building product. That's where one of our customers was six months ago. A SaaS startup with about 800 customers, doing B2B workflow automation. Their product was solid, but their phone support was becoming a bottleneck. **The Problem** Before AgentLine, this team handled support the old-fashioned way. Customers called a number, a team member answered, and they resolved the issue live. On paper, this sounds fine. In practice, it was eating them alive. Most calls were routine: "How do I reset my password?" "Where do I find my invoice?" "Is feature X available on my plan?" These were questions their docs already answered. But customers preferred calling, and every call pulled someone away from real work. The team tried hiring a support person. That helped for about two months, until call volume doubled again. They were back to square one. **The Setup** They decided to try an AI phone agent. The goal wasn't to replace human support entirely. It was to filter out the routine stuff so humans could focus on what actually needed human attention. Here's what their setup looked like: 1. They signed up for AgentLine and provisioned a US phone number. They routed their existing support number to it. 2. They wrote a system prompt for the AI agent. This took the most time, about two afternoons of writing and testing. The prompt covered: - Common questions and their answers (pulled from their help docs) - Account-specific questions the AI could answer by looking up in their database - Clear escalation rules: anything involving billing disputes, cancellations, or bugs got routed to a human 3. They connected the AI agent to their internal database. When a customer called, the agent could look up their account info, subscription status, and recent activity. This was key. Without this, the agent would just be reading help docs aloud. 4. They set up escalation. When the AI couldn't handle something, the call transferred to a human team member with full context. The human saw the transcript of what had already been discussed. The customer never repeated themselves. **The Results** Within the first month, the AI agent was handling about 60% of calls on its own. After three months of iterating on the prompt (every call that went to a human was a learning opportunity), that number hit 80%. What does 80% look like in practice: - 800 calls per month, down from about 1,000 before (some customers started using the help docs more once they saw how fast the AI was) - 640 calls handled entirely by the AI agent - 160 calls escalated to humans, each with full context so resolution was fast - Human support time dropped by roughly 70% The team went from spending 4-5 hours a day on support to about 1-2 hours. That's 15-20 hours per week that went back into building product. **What They Learned** I asked them what they'd do differently if they were starting over. Here's what they said: "We overthought the prompt at first. We tried to cover every possible question. After two weeks, we realized it's better to handle the top ten questions really well than to handle everything poorly. We stripped the prompt down to the essentials and just kept adding as we learned." "We should have connected the database earlier. Once the AI agent could actually look up customer info, the quality of support jumped dramatically. Before that, it was just reading docs at people." "The escalation handoff is the most important part. If the human doesn't get context, they have to start from scratch. We spent a lot of time making sure the transcript and context were clear before routing to a person." **Can You Do This Too** This same setup works for any business that gets a lot of routine support calls. The ingredients are: - An AgentLine account with a phone number - A well-written system prompt (start with your top 10 questions) - Database access so the agent can look things up - Clear escalation rules - A willingness to iterate based on real calls It won't replace your support team. It will free them up to handle the stuff they're actually needed for. Start building at agentline.cloud. --- # AI Agent Phone Integration: 7 Common Fixes - **URL:** https://agentline.cloud/blog/troubleshoot-ai-agent-phone-integration - **Markdown:** https://agentline.cloud/blog/troubleshoot-ai-agent-phone-integration.md - **Date:** 2026-06-02 - **Author:** Sameer Srivastava - **Read time:** 7 min read - **Tags:** `Troubleshooting`, `Debugging`, `AI Agents`, `Phone Integration`, `Guide` > Spent hours trying to get your AI agent to make phone calls and something's still not right? You're not alone. Here are the seven most common issues and exactly how to fix them. --- Getting an AI agent to make phone calls sounds simple. Install the skill, set the API key, tell it to call someone. What could go wrong? Quite a bit, it turns out. Not because the tools are bad, but because phone systems are complex and AI agents are still learning how to interact with them. After helping hundreds of developers debug their AgentLine setups, I've seen the same problems come up over and over. Here are the seven most common ones and how to fix them fast. **1. The Call Goes Through But Nobody Says Anything** This is the number one issue we see. The call connects, the person on the other end says hello, and your AI agent sits there in silence. What's usually happening: your agent isn't receiving the transcript. The call connected, but the text never reached your agent's brain. Fix: Check your webhook configuration. Make sure the webhook URL is publicly accessible (localhost won't work unless you're using a tunnel). Test it with a simple curl request to make sure it responds with a 200 status. If you're using the AgentLine hosted mode, make sure your agent_id is correct in the call request. **2. The AI Agent Talks Over the Person** This one makes calls feel terrible. The person is mid-sentence and your agent starts talking like it didn't hear anything. Fix: Add explicit turn-taking instructions to your system prompt. Something like "Wait until the person has clearly finished speaking before you respond. If you're not sure, give them an extra second. It's better to have a brief pause than to interrupt." Also check if you're using a voice with very fast TTS. Some voices speak faster than others. Try female-2 for a more relaxed pace. **3. The Transcript Is Garbled or Misses Words** Nobody expects perfect transcription, but if your agent is consistently misunderstanding callers, something's off. Fix: Check the caller's audio environment. Are they on speakerphone? In a noisy room? On a bad connection? Your agent can only work with what it hears. If you're testing, use headphones and a quiet room. Also make sure your prompt gives the agent permission to ask for clarification. "If you didn't catch what the person said, don't guess. Say 'Sorry, I missed that last part. Could you say it again?'" **4. Calls Drop After a Few Seconds** The call connects, the greeting plays, and then silence. The call ends without warning. Fix: This is almost always a webhook timeout. Your agent's webhook endpoint is taking too long to respond, so the call drops. Check that your endpoint responds within a few seconds. If your agent needs time to think, consider using the AgentLine hosted mode where the server handles call state for you. **5. The Agent Sounds Robotic or Unnatural** This isn't a technical bug, but it's probably the most impactful issue. Customers hear a robot and hang up. Fix: Voice selection matters. AgentLine gives you female-1, female-2, male-1, and custom Cartesia voices. Test all of them. female-2 tends to sound the most natural for general use. Prompt writing matters even more. See our guide on improving call quality for specific prompt techniques that make a huge difference. **6. Can't Provision a Phone Number** You're ready to go but the system won't give you a number. Fix: Check your account balance. Numbers cost $2.00 (one-time). Make sure you have enough credit. Also check that you're requesting a US number (that's all we support right now). If you're still stuck, contact support at agentline.cloud. **7. SMS Isn't Working** You're receiving calls fine but texts aren't coming through. Fix: First, make sure you're trying to receive SMS, not send it. AgentLine supports inbound SMS (reading texts people send to your number) but outbound SMS sending is not yet available. If you're expecting inbound texts and they're not arriving, check your message endpoint. Make sure it's configured to handle the same webhook format as calls. SMS events arrive through the same events endpoint as call events. **When All Else Fails** If you've checked all seven and something's still not working: 1. Read the logs. Every failed call or event has logs that tell you exactly what happened. 2. Simplify. Strip your setup down to the absolute minimum: one agent, one number, one simple prompt, one test call to yourself. 3. Get it working in that minimal state, then add complexity back one piece at a time. Most issues come down to either the webhook configuration, the prompt, or the network environment. Start there. Need more help? Check the docs at agentline.cloud or reach out to support. --- # Build an AI Voice Assistant for Your Business in One Day - **URL:** https://agentline.cloud/blog/build-ai-voice-assistant-agentline - **Markdown:** https://agentline.cloud/blog/build-ai-voice-assistant-agentline.md - **Date:** 2026-06-02 - **Author:** Sameer Srivastava - **Read time:** 8 min read - **Tags:** `Voice Assistant`, `AI Agents`, `Tutorial`, `Build Guide`, `Getting Started` > You don't need a telecom engineering degree to build a voice assistant. With AgentLine, you can have a working AI that answers calls, handles questions, and routes to humans in a few hours. --- The phrase 'build an AI voice assistant' sounds intimidating. It conjures images of server racks, telecom engineers, and six-month development timelines. It's 2026. It doesn't take any of that. Here's how to build a functional AI voice assistant for your business using AgentLine. Total time: one afternoon. No telecom knowledge required. **What We're Building** By the end of this guide, you'll have: - A phone number that customers can call - An AI agent that answers, has natural conversations, and helps callers - Automatic escalation to a human when the AI hits its limits - Call transcripts stored for review and improvement Let's go step by step. **Step 1: Get Your API Key (5 minutes)** Go to agentline.cloud and sign up. You'll get an API key immediately. It starts with sk_live_. Save it somewhere safe. If you're building this for a business, use a dedicated email. If you're just prototyping, your personal email is fine. **Step 2: Create Your Agent (5 minutes)** An agent is the AI that will handle calls. You can create one through the dashboard or via the API. Through the API, it's a single POST request: curl -X POST https://api.agentline.cloud/v1/agents \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{"name": "Support Agent", "voice_id": "female-2"}' You'll get back an agent ID (starts with agt_). Save this too. **Step 3: Buy a Phone Number (2 minutes)** Your agent needs a number to make and receive calls. Buy one through the dashboard or API: curl -X POST https://api.agentline.cloud/v1/numbers \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{"agent_id": "agt_YOUR_AGENT_ID", "country": "US", "number_type": "local"}' Numbers cost $2.00 (one-time). You'll get a number back immediately. This is now your business's AI phone line. **Step 4: Write Your Prompt (The Most Important Step)** This is where the real work happens. Your system prompt defines who your agent is, how it talks, and what it can do. Here's a template to start with. Customize the parts in brackets: "You are [Agent Name], the [role] at [Company Name]. You answer calls from customers and help them with [list of things you help with]. Your personality: [brief description - warm, professional, casual, etc.] What you can do: - [Capability 1: e.g., Answer questions about pricing] - [Capability 2: e.g., Help with account issues] - [Capability 3: e.g., Schedule demos] What you cannot do (escalate these to a human): - [Limitation 1: e.g., Process refunds] - [Limitation 2: e.g., Handle billing disputes] Rules: - Keep responses under 30 words - Don't interrupt. Wait for the person to finish speaking - If you don't know something, say so. Don't guess - If the person gets frustrated, apologize and offer to connect them with a human" Set this as your agent's system prompt: curl -X PATCH https://api.agentline.cloud/v1/agents/YOUR_AGENT_ID \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{"system_prompt": "Your prompt here", "initial_greeting": "Hello, thanks for calling [Company Name]. How can I help you today?"}' **Step 5: Test It (30 minutes)** Call your new number. Have a real conversation. Does the agent sound natural? Does it answer your questions correctly? Does it handle when you go off script? Keep a notepad open. Every time something feels off, write it down. Update the prompt and call again. Here's what to test: - Common questions you get from real customers - Edge cases: "I don't know my account number," "Just connect me to a person," "Your product is terrible" - Silence: stay quiet for five seconds and see what the agent does - Misunderstanding: say something confusing and see if the agent asks for clarification **Step 6: Connect Your Data (optional but powerful)** Your AI agent can look up information if you give it access. This is what separates a basic FAQ bot from a genuinely useful assistant. If your agent has access to your database, it can: - Look up order status when someone gives their order number - Check account details when someone verifies their identity - Find available appointment slots and offer them to callers The setup depends on your stack. Most teams connect their agent through a webhook that queries their database and returns results. Your agent sees the results and can share them with the caller. **Step 7: Go Live (5 minutes)** Once you're happy with how the agent handles test calls, route your existing business number to your AgentLine number, or just start giving out the new number. Monitor the first few days closely. Read the transcripts. See what callers are actually asking and how your agent is handling it. Every transcript is a chance to improve the prompt. **What's Next** A voice assistant is a living thing. It gets better the more you use it. Here's the rhythm that works for most teams: - Week 1: Monitor every call. Update the prompt daily based on what you see. - Week 2-4: Spot-check calls. Focus on the ones that escalated to humans. What could the AI have handled? - Month 2+: Weekly review. Add new capabilities as you learn what callers want. **The Tools You'll Want** - AgentLine dashboard: See call logs, transcripts, and billing - AgentLine API docs: Reference for all endpoints - A notepad: Seriously, write down every prompt improvement That's it. One afternoon, a few API calls, and some thoughtful prompt writing. You don't need telecom expertise. You need a clear idea of what your customers need and a willingness to iterate. Start building at agentline.cloud. --- # AgentLine API: Developer Walkthrough with Code Examples - **URL:** https://agentline.cloud/blog/agentline-api-developer-walkthrough - **Markdown:** https://agentline.cloud/blog/agentline-api-developer-walkthrough.md - **Date:** 2026-06-02 - **Author:** Sameer Srivastava - **Read time:** 7 min read - **Tags:** `API`, `Developer`, `Documentation`, `Code Examples`, `Integration` > Skip the marketing fluff. Here's a hands-on walkthrough of the AgentLine API: authentication, making calls, reading transcripts, and building your first integration with real code examples. --- You're a developer. You don't need another landing page. You want to see the API, understand the endpoints, and figure out if this thing actually works for your use case. Here's that walkthrough. No fluff. Just the API, endpoints, and working code examples. **Authentication** Everything starts with your API key. You get it from the AgentLine dashboard after signing up. It starts with sk_live_. Every request includes it in the Authorization header: Authorization: Bearer sk_live_YOUR_KEY_HERE Base URL for all endpoints: https://api.agentline.cloud **Your First Agent** Before you can make calls, you need an agent. An agent is the AI that handles conversations. Create one: curl -X POST https://api.agentline.cloud/v1/agents \ -H "Authorization: Bearer sk_live_YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "name": "My First Agent", "system_prompt": "You are a helpful assistant. Keep responses brief and friendly.", "initial_greeting": "Hi there, how can I help?", "voice_id": "female-2" }' Response includes your agent ID (agt_xxx). Save it. **Buying a Phone Number** Your agent needs a number. Provision one: curl -X POST https://api.agentline.cloud/v1/numbers \ -H "Authorization: Bearer sk_live_YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "agent_id": "agt_YOUR_AGENT_ID", "country": "US", "number_type": "local" }' Cost: $2.00 one-time. You get a number back immediately. This number can now make and receive calls and texts. **Making an Outbound Call** Now the good part. Making a call: curl -X POST https://api.agentline.cloud/v1/calls \ -H "Authorization: Bearer sk_live_YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "agent_id": "agt_YOUR_AGENT_ID", "to_number": "+12125551234", "system_prompt": "You are calling to remind them about their appointment tomorrow at 2pm.", "initial_greeting": "Hi, this is a quick reminder about your appointment tomorrow. Do you have a minute?" }' You'll get back a call ID (call_xxx). The call starts immediately. The AI agent handles the conversation. **Getting the Transcript** After a call completes, grab the transcript: curl https://api.agentline.cloud/v1/calls/call_YOUR_CALL_ID/transcript \ -H "Authorization: Bearer sk_live_YOUR_KEY" The response is an array of messages: {role: "agent" | "human", text: "...", timestamp: "..."}. **Checking for Inbound Calls** When someone calls your number, you'll want to know about it. Check the events mailbox: curl https://api.agentline.cloud/v1/events \ -H "Authorization: Bearer sk_live_YOUR_KEY" This returns any call.completed events you haven't seen yet. Each event includes the full transcript and call metadata. Events are consumed once: after you read them, they're gone. That's by design so you can poll without getting duplicates. If you just want to check if there are events without consuming them: curl https://api.agentline.cloud/v1/events/peek \ -H "Authorization: Bearer sk_live_YOUR_KEY" **Listing Your Calls** Get your call history: curl "https://api.agentline.cloud/v1/calls?limit=20" \ -H "Authorization: Bearer sk_live_YOUR_KEY" Filter by status: curl "https://api.agentline.cloud/v1/calls?status=completed&limit=10" \ -H "Authorization: Bearer sk_live_YOUR_KEY" **Updating Your Agent** Change the system prompt, voice, or greeting anytime: curl -X PATCH https://api.agentline.cloud/v1/agents/agt_YOUR_AGENT_ID \ -H "Authorization: Bearer sk_live_YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "system_prompt": "Updated prompt here", "voice_id": "female-1" }' Changes take effect on the next call. **Checking Your Balance** Keep an eye on your credit: curl https://api.agentline.cloud/v1/billing/balance \ -H "Authorization: Bearer sk_live_YOUR_KEY" Returns your current balance, how many minutes you can afford, and the rate card. **Rate Card** - Outbound calls: $0.10/minute (billed per second) - Inbound calls: $0.10/minute (billed per second) - Phone numbers: $2.00/number (one-time) **Building a Real Integration** Here's a minimal Node.js example that makes a call and waits for the transcript: ```javascript const API_KEY = 'sk_live_YOUR_KEY'; const AGENT_ID = 'agt_YOUR_AGENT_ID'; const BASE = 'https://api.agentline.cloud'; async function callAndWait(number, prompt, greeting) { const headers = { 'Authorization': `Bearer ${API_KEY}`, 'Content-Type': 'application/json' }; // Make the call const callRes = await fetch(`${BASE}/v1/calls`, { method: 'POST', headers, body: JSON.stringify({ agent_id: AGENT_ID, to_number: number, system_prompt: prompt, initial_greeting: greeting }) }); const call = await callRes.json(); console.log(`Call started: ${call.call_id}`); // Poll until completed let status = 'in_progress'; while (status !== 'completed') { await new Promise(r => setTimeout(r, 5000)); const statusRes = await fetch(`${BASE}/v1/calls/${call.call_id}`, { headers }); const callStatus = await statusRes.json(); status = callStatus.status; } // Get transcript const transcriptRes = await fetch(`${BASE}/v1/calls/${call.call_id}/transcript`, { headers }); const transcript = await transcriptRes.json(); return transcript; } ``` **Resources** - Full API docs: agentline.cloud/docs - Skill file: agentline.cloud/skill.md - Dashboard: agentline.cloud/dashboard That's the API. Simple enough to use from curl, powerful enough to build a real phone system on top of. If you can make HTTP requests, you can build with AgentLine. Start at agentline.cloud. --- # How to Write AI Phone Agent Prompts That Actually Sound Human - **URL:** https://agentline.cloud/blog/ai-phone-agent-prompts-best-practices - **Markdown:** https://agentline.cloud/blog/ai-phone-agent-prompts-best-practices.md - **Date:** 2026-06-02 - **Author:** Sameer Srivastava - **Read time:** 7 min read - **Tags:** `Prompts`, `AI Phone Agent`, `Best Practices`, `Conversation Design`, `Voice` > The difference between an AI agent people hang up on and one they have real conversations with comes down to the prompt. Here's how to write prompts that make your agent sound like a person, not a robot. --- I've reviewed prompts for hundreds of AI phone agents. At least half of them have the same problem: they tell the agent what to do, but not how to be. The result is an agent that's technically correct. It answers questions accurately. It follows instructions. But it sounds like it's reading from a manual, and callers pick up on that instantly. Here's how to fix that. These are the prompt techniques that consistently produce agents that sound like real people having real conversations. **Give Your Agent an Identity, Not a Job Title** Compare these two prompts: Version A: "You are a customer support agent for a SaaS company. Answer questions about pricing, features, and account issues. Escalate billing disputes to a human." Version B: "You are Jess. You work on the customer team at a small SaaS company. You genuinely enjoy helping people figure things out. When someone calls, your first instinct is to listen, not to solve. Once you understand what they need, you help them get there. If you don't know something, you say 'Let me check on that' instead of making things up." Version A produces a help desk chatbot. Version B produces a person. The difference isn't the information. It's the frame. **Show, Don't Tell** Most prompts read like lists: "Be friendly. Be helpful. Don't interrupt." That's telling the agent how to behave. It's better to show it. Include a short example conversation in your prompt: "Here's an example of how you should handle a frustrated customer: Caller: I've been on hold for 20 minutes and nobody's helped me yet. You: I'm sorry about that wait. That's frustrating and it shouldn't happen. Let me help you right now. What's going on? Caller: My payment went through but my account still shows as inactive. You: Let me look into that. Can you give me the email on your account so I can pull it up?" The agent now has a concrete example of what good looks like. It's not guessing what 'be empathetic' means. It has a pattern to follow. **Define What the Agent Cannot Do** This is just as important as defining what it can do. AI agents tend to be overly helpful. They'll try to answer questions they don't have information for. They'll make promises they can't keep. Explicitly list what's out of bounds: "You cannot: - Issue refunds or process payments - Make changes to someone's account - Promise a specific timeline for feature requests - Say 'I'll make sure this gets fixed today' unless you can actually do that If someone asks about any of these, say 'I want to make sure this gets handled right. Let me connect you with someone who can help directly.'" **Handle the Hard Moments** Real conversations have awkward moments. Most prompts don't prepare the agent for them. Add explicit instructions for: When the caller is angry: "If someone is upset, don't get defensive. Acknowledge their frustration first. 'I understand why you're frustrated. That sounds really annoying. Let me see what I can do.' Then move toward a solution." When you don't understand: "If someone says something you genuinely didn't catch, ask them to repeat it. Don't guess. 'Sorry, I missed that last part. Could you say it one more time?'" When you can't help: "If someone asks for something you absolutely can't do, don't string them along. Be direct but kind. 'I wish I could help with that, but it's outside what I'm able to do. Let me get someone who can.'" When there's silence: "If the line goes quiet for more than a few seconds, gently check in. 'Still there?' or 'Take your time.' Don't rush to fill every silence." **Keep Responses Short** This is the most common prompt mistake: letting the agent ramble. On a phone call, people don't want paragraphs. They want answers. Add this rule to every prompt: "Keep every response under 30 words. If you need to say more than that, break it into two shorter responses and wait for the person to respond in between." This single rule transforms how natural the agent sounds. Long responses feel like a lecture. Short ones feel like conversation. **Include a Strong Greeting** The initial greeting sets the tone for the entire call. A bad greeting gets people on guard before the conversation even starts. Some good greetings: "Hey, this is Jess from Acme. How can I help you today?" "Hi there, thanks for calling Acme. What can I do for you?" "Hello, you've reached Acme. Jess here. What's going on?" Notice what these have in common: they're short, they identify the person and company, and they end with a question that hands the conversation to the caller. **Test and Iterate** No prompt survives first contact with real callers. Write it, test it, and be ready to change it. The best way to improve a prompt: read the transcripts of calls that went badly. Find the exact moment where the conversation went off the rails. Figure out what the agent should have done instead. Add that to the prompt. Do this for 10 calls and your agent will be dramatically better than it was at the start. **The Bottom Line** A great AI phone agent prompt is less about instructions and more about identity. Don't tell your agent to be helpful. Tell it who it is and let being helpful follow naturally. Start writing better prompts at agentline.cloud. --- # What Is AgentLine? AI Telephony for Beginners - **URL:** https://agentline.cloud/blog/what-is-agentline-beginners-guide - **Markdown:** https://agentline.cloud/blog/what-is-agentline-beginners-guide.md - **Date:** 2026-06-02 - **Author:** Sameer Srivastava - **Read time:** 6 min read - **Tags:** `Beginner`, `Guide`, `AI Telephony`, `Getting Started`, `Overview` > New to AI phone agents? Here's what AgentLine is, how it works, and whether it's the right tool for what you're building. No jargon, no hype. --- You've probably heard terms like 'AI voice agent' and 'AI telephony' floating around. Maybe you're wondering if this is something you need for your project. Or maybe you just want to understand what AgentLine actually does. Here's the simple version. **What AgentLine Is** AgentLine gives AI agents a phone number. That's it at its core. If you have an AI agent that can process text (like ChatGPT, Claude, or something you built yourself), AgentLine lets that agent make and receive phone calls. Think of it as the phone company for AI. We handle everything related to actual phone calls (buying numbers, connecting calls, transcribing speech, generating voice) so your AI agent only has to worry about the conversation. **How It Works** When someone calls your AI agent's number, here's what happens behind the scenes: 1. AgentLine answers the call 2. AgentLine records what the person says and transcribes it into text 3. The text is sent to your AI agent 4. Your AI agent processes it and responds with text 5. AgentLine converts that text to speech and plays it to the caller 6. This loop continues until the call ends Your AI agent never touches audio. It just reads text and writes text. AgentLine handles everything about the phone system. For outbound calls, your AI agent tells AgentLine who to call and what to say. AgentLine dials the number, starts the conversation, and feeds transcripts back to your agent. **What You Can Build** This might sound narrow, but it unlocks a surprising number of use cases: Customer support: Your AI answers routine questions 24/7. Humans handle the complex stuff. Customers get faster answers. Your team gets fewer interruptions. Sales follow-up: When someone signs up for your product, your AI agent calls them within minutes to offer help. Most leads appreciate the personal touch. The ones who don't, don't pick up. Appointment reminders: Your AI calls patients or clients the day before their appointment. Confirmation rates go way up. No-shows go way down. Staff time gets freed up. Alerts and notifications: When something important happens (server down, payment failed, deadline approaching), your AI agent calls the right person. Information lines: Customers call to check order status, get pricing, or hear business hours. Your AI handles it instantly. **Who AgentLine Is For** AgentLine works best for: - Developers building AI agents who want to add phone capabilities - SaaS companies that want to automate customer calls - Healthcare practices that want to reduce no-shows - Sales teams that want to scale outbound follow-up - Anyone who's tried to use Twilio for AI and found it too complex AgentLine is probably not for you if: - You need a traditional call center with hold queues and IVR menus ("press 1 for sales") - You want to send outbound SMS (inbound SMS works, outbound SMS is not yet supported) - You're outside the US (we currently only support US phone numbers) **How It's Different from Twilio** Twilio is a general-purpose telecom API. It gives you raw control over phone calls, which means you have to build everything yourself: WebSocket servers, transcription, text-to-speech, call state management. AgentLine is purpose-built for AI agents. You don't manage any of the phone infrastructure. You just process text. If you're building a custom phone system from scratch, Twilio is great. If you want your AI agent to make calls today, AgentLine is faster. **Getting Started in 3 Steps** 1. Sign up at agentline.cloud (free to start, you get test credit) 2. Create an agent and buy a phone number ($2) 3. Give your AI agent the skill file and start making calls The whole setup takes about 10 minutes. You don't need telecom knowledge. You don't need server infrastructure. You just need an AgentLine account and an AI agent that can process text. **What It Costs** - Phone number: $2.00 (one-time) - Calls: $0.10 per minute (both inbound and outbound) - SMS: Included with your number (inbound only) No monthly minimum. No hidden fees. You only pay for what you use. **What's Next** If you have an AI agent and you want it to handle phone calls, AgentLine is the fastest way to get there. Sign up, get a number, paste the skill file, and make your first call in under 10 minutes. If you're still figuring out whether you need this, try reading some of our other posts. The case studies and comparison articles will help you decide. Start at agentline.cloud. ---