Telnyx Launches Edge Compute Platform: A Home for Agents

Open weights are winning. Models are becoming intelligent, cheap, and interchangeable, and it changes where the agent era is headed. Success won't be defined by what model your agent uses, it will be decided by the infrastructure the agent runs on: how fast it responds, whether its data stays in region, whether it holds up in production, and whether it runs as one system or as a pile of vendors stitched together.

Telnyx Edge Compute is the layer that completes that infrastructure. This launch brings the agent runtime to Telnyx. This is the place an agent's own code lives, and with it the entire real-time voice agent now runs on infrastructure Telnyx owns, end-to-end.

We already had everything but the runtime

Telnyx did not just arrive at agents. For years we have run the pieces a real-time agent needs. Inference on GPUs we own. We host the leading speech-to-text and text-to-speech models on our infrastructure. A global telephony network that carries the calls. Those pieces are powering growing numbers of real-time Voice AI agents in production, at scale.

One piece always lived somewhere else: the runtime the agent's own logic executes on. The orchestration ran on a serverless provider on someone else's cloud, a hop away from the model, the speech, and the call. Edge Compute closes that gap. The agent's code now runs on the same infrastructure that already hosts the inference, the STT, the TTS, and the telephony. Nothing leaves the platform to reach anything else.

This is the final layer that lets everything a real-time voice agent needs run in one place.

Everything on one network

A voice agent is a pipeline: the call comes in, speech becomes text, a model reasons, text becomes speech, the response goes back out. On the prevailing architecture, each stage is a different vendor, and every boundary between them is a network call with its own latency, failure mode, and bill.

On Edge Compute, those stages are colocated on one network, and now the agent's own code sits inside that pipeline rather than a hop away from it. Functions run the logic. StatefulActor holds the conversation state. Inference, STT, and TTS run on owned GPUs in the same points of presence that terminate the call. The round-trip stays under 200ms because the pipeline never leaves the network.

Two layers, one platform

Message the platform first, then the components. Edge Compute has two layers that work together.

The Agent Runtime is where agents live. Functions run containerized code, deployed with one command. StatefulActor holds durable per-entity state, one instance per entity, one call at a time. KV provides globally distributed key-value storage. CloudFS mounts a shared POSIX filesystem that persists across restarts. Cloud Storage provides S3-compatible objects. Inference runs open models on owned GPUs.

The Agent Primitives are what agents use. The mind: Inference for reasoning, RAG for retrieval, Memory for persistence. The hands: Voice for calls, Messaging for texts, Email for inbox, Payments for transactions, Wireless for SIMs.

Everything runs on the same infrastructure. Functions reach KV, StatefulActor, CloudFS, Cloud Storage, and Inference through bindings, removing the need for credentials, network calls, and egress fees between components. The binding is the connection.

Agent latency is a network problem, not a model problem

You cannot make a distributed pipeline fast by choosing a faster model. The time goes into the boundaries between services: DNS resolution, TLS handshakes, routing, queuing, one set for every hop. A faster model shaves milliseconds off one stage while the network spends them on the joins.

When your Function reads from KV on Edge Compute, the read happens through a binding, so the runtime skips DNS, TLS, and routing because the data sits on the same platform as the code requesting it. When your Function calls StatefulActor, the call routes to the right instance without an API key, auth header, or network call. When your Function calls Inference, the model runs on owned GPUs on the same infrastructure. When it reads a file from CloudFS, the filesystem is backed by Cloud Storage on the same platform, so there is no external API call or egress fee for reading your own data. Zero hops between components, not just between vendors. You do not optimize your way out of network overhead. You architect your way out.

The economics follow from ownership

Because Telnyx owns the GPUs, inference is priced on the cost of running the model rather than the cost of renting someone else's hardware plus their margin. That is up to 75% less than proprietary alternatives. Data sovereignty follows from ownership too: processing stays in region because the GPUs are in region, by architecture.

What is shipping now

Edge Compute ships today with the following live:

• Functions: Containerized edge compute. Deploy with one command. TypeScript, Go, Python, Java, JS. Bindings to every runtime component.
• KV: Globally distributed key-value storage. Accessed through bindings, with no network hops, credentials, or egress fees. Immediate consistency between binding and REST API. Server-side TTL.
• SQL: Embedded SQLite inside each StatefulActor. Every actor gets its own database.

And two components in beta:

• StatefulActor: Per-entity state with single-threaded execution. One instance per name. One call at a time. Durable writes. The keystone of the Agent Runtime.
• CloudFS: Shared POSIX filesystem backed by Cloud Storage. Mount on any container. Files persist across restarts. Concurrent access by design. Open-source JuiceFS client.

These new primitives join existing primitives:

• Cloud Storage: S3-compatible object storage. Regional endpoints in US and EU. Edge function binding with zero-credential access.
• Inference: Open models on owned GPUs, up to 75% less than proprietary alternatives, in region by default, zero data retention. Live across US, EU, APAC, and MENA. OpenAI-compatible.

What is coming

• WebSocket (coming soon): Live connections into durable state. Clients connect to an actor by name. Sequence numbers survive reconnects.
• AgentSDK: Bring LangGraph, CrewAI, or the Vercel AI SDK unchanged and run them in a durable StatefulActor in production.
• Operating Envelope: Govern what agents can do. Developers ship the manifest, operators attach policy. The same code completes or returns a structured policy error.
• Memory: Cross-channel conversation recall across sessions and surfaces.

A home for agents

The teams building production agents now are the ones who will define what the infrastructure looks like for the next decade. They do not need another model. They need a place where the whole agent runs as one system: its code, its state, its inference, its speech, and its calls, on infrastructure that is owned end to end. That is what Edge Compute is.

Try it live. The Edge Compute microsite is a live tour of the platform. Run Functions, StatefulActor, KV, CloudFS, SQLDB, and Cloud Storage in your browser with no signup, on a page that is itself an Edge Compute Function. If you're ready to build, explore the developer docs.