Built for Humans

A friend of mine works in a 20-person call center. Lately, fifty AI-generated calls land in the queue at once. Not scams. Legitimate services — companies have outsourced parts of their customer service workflow to AI agents that resolve questions by calling other companies’ call centers. The AI dials a phone number and tries to act like a customer.

The call center was built for humans. The reps inside it interact with underlying applications also built for humans. The AI doesn’t need a human on the other end of the line; it needs the system the humans operate. So it cosplays a caller.

The result: a 20-person team gets swarmed by 50+ AI calls, and the humans who actually need to reach the call center can’t get through. The interface built for humans gets blocked by an AI acting as a human.

The claim

The systems we actually use were built assuming a human is on the other end.

Login flows assume a human typing a password. Rate limits assume a human clicking. Authorization models assume a human reading and deciding. Audit logs assume a human investigator paging through events at human speed. Query patterns assume a human curious about one thing at a time.

AI is going to touch all of it. It already is.

Nothing is ready at the scale and pace this requires.

The work of the next decade is the redesign. Not the AI models themselves — those will keep arriving on whatever cadence the labs decide. The work is everything underneath them. The contracts between systems. The authorization layer that treats an agent as something other than a user with a faster typing speed. The audit trail that captures intent and trajectory, not just events. The dispatch interface that another system can call without pretending to be a person on a phone.

The robocall is not a quirk

It’s a preview.

When a company outsources customer service resolution to an AI service, and that AI service has to reach into another company’s records to get the answer, there are two ways the interaction can happen. Either the two systems talk to each other directly through a proper authenticated interface that handles PII and PHI correctly, or the AI dials a phone number and tries to socially engineer a human into being the bridge.

We picked the second one. Not because anyone thinks it’s better. Because the first one doesn’t exist yet at the scale and trust level required, and the phone number does.

The fix isn’t more AI in the call center, or less of it. The AI doesn’t need the phone at all — it needs to talk to the system directly, through an interface built to know it’s an agent and not a human.

This pattern is going to repeat across industries. Insurance claims. Medical records. Logistics scheduling. Permitting. Compliance attestations. When an organization needs to retrieve, attest, or submit information through another organization’s interface, AI is going to start dialing the phone. The interfaces that were built for the humans who used to make those calls will absorb the load — taking up the capacity that real humans need — until something breaks.

Something is going to break.

What the redesign looks like

The shape is becoming visible if you look at the layers.

The identity layer. Today’s authorization models have two roles: human user and service account. An agent acting on behalf of a human is neither. It needs a persona model that scopes what it can do based on who delegated, what task, for how long, with what aggregation limits. The MCP authorization work happening now is the early edge of this.

The data layer. Most data stores are designed for human-scale queries. An agent can ask a thousand questions in a second, and the aggregate of those questions can constitute a governance violation even if each individual question is permitted. We don’t have good language for this yet. The category of “trajectory-level violation” barely exists.

The interaction layer. APIs were built for developers to integrate. They were not built for agents to discover, reason about, and chain. The current scramble around tool use, MCP, and agent protocols is the first real attempt to build interfaces designed for non-human callers from the start.

The audit layer. Logging was designed so a human could reconstruct what happened. When the actor is an agent operating at machine speed on behalf of a delegating human, “what happened” has a different shape. You need to capture the trajectory, not just the events. You need to know why, not just what.

The operational layer. This is the long tail. Across small business operations — dispatch systems, scheduling tools, routing apps, customer intake forms. All of it built around humans. All of it about to be touched by agents that companies are deploying whether the operational stack is ready or not. Most of it is not.

Why nobody is naming it

The people working on AI safety talk about alignment.

The people working on protocols talk about MCP and tool schemas.

The people working on agentic capabilities talk about what the agents can do.

The people working on enterprise AI talk about deployment and ROI.

Nobody is consolidating it into the plain claim. The infrastructure isn’t ready. Everything has to be redesigned. This is the work.

The reason it doesn’t get named is partly that it’s unsexy. It’s not a model release. It’s not a capability demo. It’s a decade of unglamorous integration work across industries. But it’s also the work that determines whether the rest of it lands or fails.

The cost of skipping the work is already visible. It looks like a 20-person call center too busy answering robocalls to take a call from a human.

What I’m doing about it

I’m building at the governance layer — a runtime that treats agents as a distinct actor class, with their own authorization model, audit trail, and aggregation policy. The bet is that governance is one of the load-bearing pieces, and that the place to enforce it is the protocol layer where agents and data systems meet.

That’s one layer. The identity, data, interaction, audit, and operational layers each need the same kind of work — and most of them don’t have it yet.

The human integration layer is not going to hold. The next step is to build the thing that replaces it before it fails on its own.