I Built the Easiest Way for Your AI Agent to Get a Phone Number (AgentLine)

Sam Rogers — Wed, 17 Jun 2026 12:48:04 +0000

A few weeks ago I was debugging why my voice agent was adding 400ms of latency before it even said hello. Turned out it wasn't the LLM, wasn't the TTS, wasn't the network. It was my own API doing unnecessary work on every single inbound call.
That sent me down a rabbit hole that eventually became AgentLine.

What AgentLine actually is
AgentLine gives your AI agent a real US phone number. Voice calls, SMS, inbound and outbound, all accessible through a dead simple API. You provision a number, you point it at your agent, and it works.
The pitch is boring on purpose. The hard part was making it actually work well for agents specifically, not humans building IVR trees.

The latency rabbit hole
When an inbound call hits your number, there's a chain of things that need to happen before your agent can respond. My original architecture was doing too much in that chain synchronously.
I was fetching call metadata, running auth checks, hydrating session state, and then finally handing off to the agent, all in sequence, all before the first byte of audio went out. On a fast day this was 300ms. On a slow day it was closer to 600ms.
600ms of silence before your agent speaks sounds broken. Users hang up.
So I went through the entire call handling path and asked a simple question for each step: does this need to happen before the agent starts, or can it happen in parallel or after?
Most things can happen after. Or in parallel. The only thing that genuinely needs to happen first is knowing which agent configuration to load. Everything else, logging, billing state updates, analytics events, can trail behind without the caller ever noticing.
After restructuring the call path around this principle, cold start latency dropped significantly. Not dramatically, but in voice, milliseconds compound. A 200ms improvement in first-byte audio makes the difference between a conversation that feels natural and one that feels like a bad phone connection from 2004.
I also moved to keeping SignalWire connections warm instead of spinning them up per call. The SDK handshake was adding ~80ms I was just handing away for free.

The single skill file setup
This is the thing I'm most proud of, honestly.
If you've built agents before, you know the setup tax. You explain your tools across multiple files, multiple configs, multiple places the agent needs to check before it understands what it can do. For something like telephony, this gets bad fast because there's state involved: which number is provisioned, what the call object looks like, how to route inbound vs outbound, what the SMS payload structure is.
AgentLine ships with a single SKILL.md file.
Your agent reads it once and knows everything. How to provision a number, how to initiate an outbound call, how to send an SMS, what parameters are required, what the response shapes look like, what errors mean and how to handle them. One file, complete picture.
This works because agents aren't like SDK users. A developer reads docs and builds muscle memory over time. An agent reads a file cold, at runtime, with zero prior context, and needs to go from zero to making a correct API call in one shot. That means the skill file has to be self-contained and unambiguous. No "see the other docs for more context." No implicit conventions you're supposed to already know.
Writing it forced me to audit my own API surface. If something was hard to explain in the skill file, it was probably a sign the API itself was doing something weird. A few endpoints got simplified just from that pressure.

Agent-centric by design, not as an afterthought
Most telephony APIs are built for humans building applications. AgentLine is built for agents being the application.
What that means practically:
The polling architecture for call transcripts is cron-based, not webhook-based. Webhooks require your agent to expose a public endpoint and maintain state about what it's listening for. Cron polling means the agent just asks "what happened on this call?" whenever it's ready to know. Zero infrastructure setup on the agent side.
Error messages are written to be parsed by a model, not read by a developer. When something fails, the response tells you what went wrong, why, and what to do about it in terms the agent can act on without a human in the loop.
Number provisioning is one API call. Area code, that's it. You get a number back, it's ready to use. No dashboard flow, no multi-step activation, no waiting.

Where it is now
AgentLine is live. There are paying customers using it. The signup to paid conversion rate is higher than I expected for something this early.
If you're building an AI agent that needs to talk to people on the phone or send SMS, give it a try. The skill file is in the docs, the API is straightforward, and if something doesn't work the way you'd expect, I'm genuinely easy to reach at sam@agentline.cloud or just hop into the discord server.
agentline.cloud

DEV Community: Sam Rogers

I Built the Easiest Way for Your AI Agent to Get a Phone Number (AgentLine)