Why a16z Is Betting $90M on Text Threads Becoming the Agentic Operating System

For about twenty years, the mobile app has been how we get things done online. You tap an icon, figure out the layout, dig through menus, fill in forms, and then do it all again in the next app. And the one after that.

That model is starting to feel dated.

Linq just raised a $90 million Series B led by Andreessen Horowitz. It’s easy to file that under “another AI infrastructure round,” but the more interesting part is what the bet implies. The next big interface for AI agents might not be a new app, a browser extension, or a standalone assistant. It might be the text thread already open on your phone. Linq builds the messaging, calling, and computer-use infrastructure that lets agents reach customers and finish work in channels people already use.

The thesis is simple: people don’t want more software to operate. They want things handled.

The App Was Never the Point

The graphical interface made computers usable. Icons, buttons, menus, and screens turned complicated systems into something a person could navigate by sight.

It also created a hidden tax: you became the integration layer.

To order food, you open one app. To pay rent, another. To reschedule a flight, another. To dispute a charge, yet another. Each time you hunt for the right screen, type in your details, bounce between tabs, and follow up when something stalls.

Linq’s argument is that agents change this deal. Instead of you operating the software, the agent takes an intent (“find me dinner,” “pay my rent,” “book this appointment”) and works out the steps behind the scenes. Linq describes the shift as moving from apps that leave most of the work to the person using them to agents that get context and permission, then finish the job.

That’s the real interface pivot: from navigation to delegation.

Linq Isn’t Selling Chatbots

It would be a mistake to call Linq a chatbot company.

What it provides is the infrastructure layer that connects AI agents to consumers across messaging channels. The platform covers Apple Messages for Business, iMessage, RCS, SMS, and WhatsApp, with APIs for sending and receiving messages, templates, rich media, delivery events, and webhooks.

In practice, a company can deploy an agent that doesn’t live inside its own app. It lives in the customer’s existing message thread.

DoorDash is the clearest example. Through Linq, DoorDash lets customers find food, build a cart, and check out inside a single Apple Messages for Business thread. There’s no hopping between discovery, cart, payment, and confirmation screens. The conversation carries the whole workflow.

That difference matters. A chatbot answers questions. An agentic messaging interface completes a transaction.

Why Messaging Could Become the Native OS

Messaging isn’t just a convenient spot to drop an AI agent. It may be the most natural environment for one.

Traditional app interface Messaging-based agent interface
User learns a new app’s layout User speaks in ordinary language
User performs every step Agent performs multi-step execution
Context is fragmented across apps Context persists in one thread
User opens the app when needed Agent arrives in an already-used channel
Success means engagement Success means task completion
Interface is visual and manual Interface is conversational and delegative

Messaging already has what an agent needs: identity, history, notifications, rich media, and daily habit. People use text threads to make plans, ask for advice, share links, and settle decisions. Linq’s view is that putting agents inside those conversations makes new products feel familiar from day one, instead of asking people to change their behavior again.

The chat thread starts to look like a personal command line, one that understands plain language, remembers context, and can trigger real-world actions.

A Thread That Finishes the Job

Take paying rent.

In the app era, you open the property-management app, find the billing page, check the amount, pick a payment method, enter your credentials, submit, and wait for confirmation.

In an agentic setup, you might just write:

“Pay my rent before Friday. Flag me if the amount changes.”

The agent pulls up the details, confirms the amount and payment method, makes the payment with your authorization, sends a receipt, and follows up if anything goes wrong. You never need to know which screen holds the payment button. You only need to trust that the agent understood you and got it right.

This is why Linq is pushing beyond text. Its new HD Calling product lets agents make handset-quality phone calls, and its computing infrastructure lets agents use software to get tasks done. An agent booking an appointment might need to call the office. An administrative agent might need to drive a browser or a business app. Then it comes back to the thread to ask a question, request approval, or explain what happened.

The thread isn’t the whole system. It’s the control surface.

The $90M Bet Is About Distribution

Vertical diagram of a five-layer distribution stack: a person at the top, then messaging channels such as iMessage, RCS, SMS and WhatsApp, then Linq, then business agents, then models and software at the bottom. The Linq layer is highlighted and labeled "Where leverage sits."

Andreessen Horowitz isn’t simply betting that AI agents will catch on. The bet is about where agents will live and who controls the rails connecting them to people.

a16z argues that agents will become the main way people deal with companies and services, and that businesses will need to support agent-based communication. It also argues that agents work best when they fit into familiar ways of communicating instead of demanding brand-new experiences.

That’s a distribution thesis.

If models keep getting better and more interchangeable, the differences may move to the unglamorous parts of the stack: reliable message delivery, channel integrations, identity, scale, compliance, and enterprise rollout. Linq says its customers have pushed more than a billion messages through its infrastructure, and companies including DoorDash, Town, and Tab run agents on the platform.

Put another way, Linq isn’t trying to own the agent. It wants to own the pathway between the agent, the business, and the person in the chat.

The Platform-Dependence Problem

The obvious objection is that messaging infrastructure sits on top of platforms Linq doesn’t control.

Apple runs Apple Messages for Business. Meta runs WhatsApp. Carriers and industry groups shape RCS. Any of them can change access, pricing, policy, capabilities, or the rules for commercial messaging.

Linq’s multi-channel approach softens that risk somewhat. Supporting Apple Messages for Business, iMessage, RCS, SMS, and WhatsApp means it doesn’t depend on any one channel, and its move into calling and computer-use infrastructure widens the company beyond messaging alone.

Still, the risk is structural. If the future is conversational, whoever owns the conversation surface could hold a lot of leverage over the businesses trying to reach users through it.

What Has to Be True

Infographic titled "The Autonomy Ladder" showing four tasks ranked by risk from bottom to top: ordering food runs automatically, paying rent needs user approval, disputing a charge needs approval and an audit trail, and legal commitments are handed off to a human. Arrows on both sides show risk and human involvement increasing as you climb.

For text threads to become an agentic operating system, a few hard problems need solving:

  • Authorization: Users need clear, granular control over what an agent can access, buy, pay for, or change.
  • Identity: A message thread has to reliably prove who’s speaking and guard against impersonation and account takeover.
  • Reliability: Agents must finish multi-step workflows without silently failing, hallucinating, or doing the wrong thing.
  • Recovery: When an agent orders the wrong item or sends the wrong payment, the user needs a fast, understandable way to fix it.
  • Auditability: Every approval, action, exception, and handoff needs a traceable record.
  • Human escalation: High-stakes or ambiguous situations should reach a real person quickly.

The winners won’t be the companies with the flashiest demo. They’ll be the ones that make autonomous execution safe enough to trust with money, identity, health, travel, and legal commitments.

What Builders Should Do Now

For product teams, the takeaway isn’t “add a chatbot.” It’s to rebuild the product around outcomes.

  • Start with the task the user wants done, not the screens they’d have to click through.
  • Build in explicit approval points for anything irreversible.
  • Design agent workflows that can pause, ask for missing context, and explain what happened.
  • Treat message history as a lasting workspace, not a support ticket queue.
  • Instrument every step so failures can be found and fixed.
  • Keep a path to a human for exceptions, disputes, and moments where trust is on the line.

For brands, messaging shouldn’t be seen only as a marketing or support channel anymore. It’s turning into a transactional service surface, a place where customers can book, buy, resolve, and follow up without opening another app.

From Screens to Delegation

The graphical interface made software visible. The agentic interface may make it invisible again.

You won’t necessarily stop using apps. Their role may just change. Instead of destinations you have to visit, they become services an agent can call on your behalf. You state the goal, the agent coordinates the steps, and the thread becomes the place where intent, context, approval, and confirmation come together.

The next operating system may not have a home screen.

It may have a chat bubble.

Leave a Comment