SMS Verification for AI Agents:
A Practical Setup Guide

SMS-based verification is one of the most persistent friction points in agentic AI development. You can automate browsing, form-filling, API calls, and complex multi-step workflows — but the moment a platform asks for a code sent to a mobile number, most automation stacks have no answer. This guide walks through the complete hardware and software setup for giving your AI agent reliable, autonomous SMS verification capability.

Why Standard Solutions Fall Short

Before covering what works, it's worth being precise about why the common approaches fail.

Virtual number APIs (Twilio, Vonage, etc.) seem like the natural fit — they're developer-friendly, have clean REST APIs, and don't require hardware. The problem is that major platforms have become adept at distinguishing virtual numbers from physical SIM numbers via carrier lookup APIs. When a platform calls a carrier lookup on the number you provide, a Twilio number returns metadata identifying it as a VoIP or virtual number. Many platforms reject these outright or flag accounts using them for additional review.

SMS-for-verification services (pools of shared numbers marketed specifically for OTP receipt) have the same carrier-lookup problem and an additional one: the numbers are shared across many users, meaning OTPs intended for your agent's registration may be intercepted or confused with messages to other users of the same number.

The developer's own personal number is operationally fragile — one flag or suspension affects every agent using it — and creates ambiguity between developer identity and agent identity that can cause problems with terms-of-service compliance.

The Hardware Approach: Physical SIM + USB Modem

The solution that works reliably is a physical SIM card in a USB modem attached to the machine running your agent. This gives you a real mobile subscriber number that passes carrier lookup checks, a dedicated number that belongs solely to that agent, and programmatic access to SMS receipt via standard interfaces.

The hardware setup requires two components: a KYC-free physical SIM (a Simbotica SIM satisfies this) and a USB LTE modem. Suitable modems are available from several manufacturers — Huawei, ZTE, and Sierra Wireless all make widely supported models — and typically cost $20–40. Any modem that exposes a serial interface and supports standard AT commands will work.

Step-by-Step Configuration

1. Insert the SIM into the modem. Most USB modems have a small SIM tray accessible by removing a panel on the device body. Insert the SIM in the correct orientation (the cut corner is a guide) and reassemble.

2. Connect the modem to your server. On Linux, the modem will typically appear as /dev/ttyUSB0 or similar. Run ls /dev/ttyUSB* before and after connecting to identify the correct device path. On macOS it appears as /dev/tty.usbmodem*.

3. Verify the connection with a basic AT command. Use any serial terminal (screen, minicom, or a Python serial library) to connect at 115200 baud and send:

AT
Expected response: OK

AT+CIMI
Returns the IMSI, confirming the SIM is recognized.

4. Configure SMS text mode. Send AT+CMGF=1 to set text mode (as opposed to PDU mode), which makes incoming messages human-readable and easier to parse programmatically.

5. Enable new message notifications. Send AT+CNMI=2,2,0,0,0 to configure the modem to push new incoming SMS messages directly to the serial interface rather than storing them in memory. Your application can then read and parse them in real time.

Reading SMS in Python

The pyserial library handles the serial connection cleanly. A minimal SMS reader looks like this:

import serial, re, time

modem = serial.Serial('/dev/ttyUSB0', 115200, timeout=5)
modem.write(b'AT+CMGF=1\r')
modem.write(b'AT+CNMI=2,2,0,0,0\r')

def read_otp(timeout=60):
    deadline = time.time() + timeout
    while time.time() < deadline:
        line = modem.readline().decode('utf-8', errors='ignore')
        match = re.search(r'\b\d{4,8}\b', line)
        if match: return match.group()
    return None

This function polls the serial interface for up to 60 seconds and returns the first 4–8 digit sequence it finds — sufficient for most OTP formats. In production you'd add sender filtering (checking the +CMT header for the sending number) to avoid false positives from unrelated messages.

Integrating with Agent Frameworks

In LangChain, CrewAI, AutoGen, or any other agent framework that supports tool use, wrap the SMS reader as a tool:

@tool
def receive_sms_otp(wait_seconds: int = 60) -> str:
    """Wait for an SMS OTP and return the code."""
    return read_otp(timeout=wait_seconds)

The agent can then call this tool naturally within a workflow: trigger an SMS send on a target platform, call receive_sms_otp, and pass the result back to complete the verification step — entirely without human intervention.

Managing Multiple Agents

For setups with multiple agents each requiring their own number, a USB hub with multiple modems works well. Each modem appears as a separate serial device. Assign one modem per agent process and the isolation is clean. Simbotica's limit of three SIMs per customer is designed with exactly this kind of small multi-agent setup in mind.