AI agents will run telecom wholesale. Not assist it. Run it. For decades this has been a human-driven market: people negotiate carrier agreements, compare routes, evaluate quality, provision capacity, watch traffic and move it between suppliers. The infrastructure underneath became highly automated. The decision-making did not. That is what changes next.
This post is about what happens when the buyer in a wholesale transaction is software. What an agent actually does, what a marketplace has to look like for a machine to use it, where the humans go, and why TelecomsXchange (TCXC) is positioned to be the infrastructure layer that AI agents use to reach the global telecom market.
Key takeaways
- The buyer is becoming software. An agent managing communications for a business will search the market, evaluate carriers, buy capacity, route traffic and keep optimising, without a human in every decision.
- Automation is not autonomy. Routing engines execute rules people wrote. An autonomous market lets software make and revise the economic decisions itself, inside human-defined limits.
- Price is one variable among many. Agents weigh rate against ASR, ACD, PDD, fraud risk, capacity, history and live network conditions, thousands of times at once.
- The interface is the API. A marketplace for machines needs structured data, real-time pricing, measurable quality, predictable execution and programmatic settlement.
- Humans move up the stack. They set objectives, budgets and constraints. Agents handle the continuous decisions.
- TCXC already runs this way. The marketplace, connectivity and transaction infrastructure is programmable today over REST and MCP. The next step is extending who operates it.
What is an autonomous wholesale market?
An autonomous wholesale market is one where software participants discover suppliers, evaluate price and quality, buy capacity, route traffic and settle, continuously, under objectives and constraints that humans set. It is different from an automated network, where systems execute rules a person wrote, because in an autonomous market the software makes and revises the economic decisions itself.
Telecom already has the automated half: routing engines, provisioning systems, billing platforms and monitoring tools. What it does not yet have at scale is the other half, where the buying decision belongs to software.
The buyer is becoming software
Imagine an AI agent responsible for the communications of a global application. It does not simply send traffic through a predefined provider. It searches the market. It evaluates carriers. It compares price, quality, capacity and risk. It selects routes, provisions capacity and executes the transaction. Then it keeps optimising based on what is actually happening in the network.
No spreadsheets. No email threads. No waiting for a human to intervene in every decision. The agent becomes the buyer.
This is not a distant scenario. Voice AI platforms already run millions of minutes through software that never sleeps, and we wrote earlier about why a voice AI needs a network, not one trunk. The next step is letting that software choose the network.
From automated networks to autonomous markets
The shift is simple to state. Today the chain is company, then human, then supplier. Tomorrow it is software, then marketplace, then network. That changes more than the interface. It changes how the market operates, because the participant that reads the rate sheet, judges the route and places the order is no longer a person with a working day and a spreadsheet, but a process that runs all the time.
| Dimension | Automated network (today) | Autonomous market (next) |
|---|---|---|
| Who decides | A human writes the rule; the system executes it | An agent decides within human-set objectives and limits |
| Supplier discovery | Manual: introductions, rate sheets, email | Programmatic: the agent queries the market |
| Inputs to a routing decision | Mostly price, reviewed periodically | Price, ASR, ACD, PDD, fraud risk, capacity, history, live conditions |
| Cadence | Weekly or monthly reviews, tickets when something breaks | Continuous, per destination, per hour |
| Trying a new supplier | Weeks of onboarding and negotiation | A test call and a traffic ramp, all via API |
| Human role | Operator of every decision | Owner of strategy, budget and constraints |
Price is only one variable
A human buyer might compare a few rate sheets. An agent can continuously evaluate price alongside answer seizure ratio (ASR), average call duration (ACD), post-dial delay (PDD), fraud risk, capacity, historical performance, geographic availability and real-time network conditions.
- It can decide that a more expensive route is worth using because its quality is better for that destination this week.
- It can move traffic the moment capacity changes, rather than after a customer complains.
- It can test a new supplier with a small slice of traffic and increase it if performance meets expectations.
- It can treat a fraud verdict on a route, such as delayed-playback false answer supervision flagged by Open Voice Shield, as a reason to cut a vendor before the invoice arrives.
- It can do all of this for thousands of destinations simultaneously.
That is more than automated routing. It is autonomous economic decision-making.
The marketplace becomes the interface
A marketplace designed for humans needs dashboards, reports, search screens and account managers. A marketplace designed for machines needs something else entirely:
- Structured data for every carrier, route and number.
- APIs for every action a human can take in the portal.
- Machine-readable capabilities: which carrier terminates where, with which codecs, at what capacity.
- Real-time pricing, not a PDF updated monthly.
- Measurable quality per route, so the agent can compare rather than trust.
- Predictable execution: a routing change or a purchase does exactly what it says, every time.
- Programmatic settlement: one wallet, readable ledgers, no invoice reconciliation by hand.
The interface is not the website. The interface is the API. And increasingly, the user of that API will not be a developer sitting at a keyboard. It will be an agent acting on behalf of a business.
TCXC: infrastructure for the autonomous wholesale market
At TCXC we have spent years building infrastructure for telecom wholesale: connecting carriers, buyers, routes, numbers, voice, SMS, APIs, routing and transactions across a fragmented global market. That infrastructure was built for the wholesale market as it existed. But the foundation has an important property. It is programmable.
The same marketplace, connectivity and transaction infrastructure can be operated by software, and today that is not a roadmap item:
- One interconnect, every carrier. A single SIP or SMPP connection to the TCXC Marketplace reaches hundreds of interconnected carriers through one account, one wallet and one agreement, with no markup on seller rates.
- Live, comparable routes. Per-route rates sit next to quality metrics, and every call is attributed to the carrier that carried it.
- Routing an agent can drive. Routing Groups V2 exposes least cost routing, load balancing, failover order, per-prefix sub-rules and hunt-stop codes over the API.
- An agent-native interface. The TCXC MCP server gives AI assistants and custom agents the marketplace, interconnect, routing, billing, messaging and CDR functions as tools. We have measured frontier models operating a live exchange through it, and shown agents managing wholesale routing that does not clock out.
- Programmatic onboarding. An agent can start a membership application without the web form, hand the payment link to its human, and poll for the account to be provisioned. The details are published for machines in our llms.txt.
An agent should not need to understand carrier relationships, rate sheets, routing tables or the mechanics of interconnection. It should be able to express an objective:
Find the best available route to this destination within these cost, quality and risk parameters.
TCXC provides the market, the connectivity and the execution layer underneath. The agent makes the decision. TCXC makes the transaction happen.
What changes for humans?
Humans do not disappear. They move up the stack. Instead of deciding which carrier should handle every route, a human defines the objective:
Maintain 99% reliability while minimising cost, within our risk parameters.
The agent determines how to achieve it. Humans set strategy, budgets and constraints, approve new suppliers, and handle the relationships and disputes that still need a person. Software handles the continuous decisions. That is the difference between automation and autonomy.
The new wholesale stack
The emerging stack looks increasingly like this. The application expresses an objective. The agent decides what needs to happen. TCXC provides the infrastructure to discover, transact and execute it. And the market continuously responds.
What an agent-run wholesale operation looks like in practice
- Objective. A human writes the goal and the guardrails: destinations, reliability floor, cost ceiling, risk budget, approved supplier tiers.
- Discovery. The agent queries the marketplace for every route into each destination, with live rate and quality next to each carrier.
- Testing. It places real test calls or sends test messages to candidate routes and reads back the result.
- Routing. It builds routing groups: least cost by default, quality-first for premium prefixes, a failover order behind each.
- Monitoring. It watches CDRs, ASR, ACD and PDD per carrier, plus fraud and route-integrity signals.
- Reallocation. When a carrier degrades at 3 a.m., traffic moves to the next qualifying route without a ticket.
- Settlement. Spend flows from one prepaid wallet with a ledger the agent can reconcile against its own records.
Every step in that loop is an API call on TCXC today. What is new is the participant making the calls.
The next telecom wholesale market
This is not simply about putting AI on top of telecom. AI is becoming part of the market itself. The next generation of wholesale will be increasingly dynamic, programmable and autonomous, and the operators that win will be the ones whose supply is discoverable and executable by software.
At TCXC we are not starting from zero. We have already built the marketplace, connectivity and transaction infrastructure. Now we are extending who can operate it. Not just people. Machines. Not just developers. AI agents. And not just as tools for telecom wholesale, but as participants in the market.
The buyer is becoming software. TCXC is building the wholesale infrastructure for it.
Connect an agent to the exchange →
Or explore the Marketplace, read the API documentation, or talk to us about running your wholesale operation this way.
