Most People Use AI Like Google. That's the Least Interesting Part.

Ask a room how they use AI and most answers are a better search box. Summarize this. Draft that. Explain this error. Useful, worth maybe 10 to 20% on individual productivity, and completely uninteresting as a story about where software is going. The interesting part is what happens when the model stops answering and starts doing.

Three layers, and most people are on the first

• Prompting. You ask, it answers, you act. The model is a consultant with no hands.
• Tool use. The model can call functions: query a database, hit an API, run code, read a file. It now has hands but you are still holding the steering wheel one turn at a time.
• Agents. The model is given a goal, a set of tools, and a budget, and it loops: plan, act, observe, adjust, until done or blocked. You review outcomes, not steps.

The capability jump between layers is not linear. Layer one saves minutes. Layer three removes the human from the loop for entire classes of work, which is a different economic object. It is the difference between a faster spreadsheet and not needing the analyst.

MCP is the boring thing that matters

The Model Context Protocol is a standard for how a model discovers and calls tools. Servers expose capabilities: read this Jira board, query this warehouse, send this email. Any compliant client can use any compliant server without custom glue. Unsexy, and roughly what USB did for peripherals.

Why it matters: before a standard, every agent integration was bespoke. N models times M tools equals N times M adapters. With a protocol it is N plus M. That collapses the integration cost that was keeping agents inside demos, and it means the moat shifts from having the integration to having the data and permissions behind it.

Practical read: if you are building internal tools, expose them as MCP servers now. Not because agents are ready to run your company, but because it makes every future model a client of your systems for near-zero marginal cost.

What an agent actually looks like in an enterprise

Forget the sci-fi version. A real one looks like this. A customer files a ticket. The agent reads it, pulls the account from the CRM, checks the last three deploys against the error timestamp, finds the likely regression, opens a draft PR with a fix and a test, posts a summary to the on-call channel with a confidence score, and waits. A human approves or redirects. Elapsed time: four minutes instead of a day.

Every one of those steps exists today. What is new is stringing them together without a person copy-pasting between systems. That copy-paste layer is a shocking fraction of knowledge work. I would estimate 30 to 40% of what a mid-level program manager does is moving context between tools that do not talk to each other. That is the first thing to go.

The bottleneck was never model capability. It is that nobody knows who is accountable when the agent is wrong.

The real bottlenecks are organizational

I have watched a dozen agent pilots stall, and it was almost never the model. It was:

• Permissions. Agents need scoped, auditable, revocable credentials. Most companies have identity systems designed for humans who log in once a day, not processes that make 400 API calls an hour.
• Data access. The agent is only as good as what it can read. If the answer lives in a spreadsheet on someone's desktop, no protocol saves you.
• Evaluation. Nobody can say what 'good' looks like in a form a machine can check. Without evals you cannot ship, and without shipping you cannot get evals.
• Accountability. When the agent files the wrong ticket or sends the wrong email, whose name is on it? Until there is an answer, the human stays in the loop for everything, and you have built an expensive autocomplete.

None of these are research problems. They are the same problems you would have delegating to a new hire, and companies already know how to solve those: scoped access, ramp-up on read-only work, review gates that loosen with a track record. The organizations that win here will be the ones that treat agents as junior staff with a management process, not as a feature to toggle.

What the next generation of software looks like

Three predictions, with the confidence I actually hold.

High confidence: every serious SaaS product grows an agent-facing surface. Not a chatbot bolted to the sidebar. An API-shaped interface where the primary user is another program. The UI becomes a supervision layer for humans watching agents work. Products priced per seat will fight this because it collapses seat count. They will lose to products priced per outcome.

Medium confidence: the org chart changes before the headcount does. The first effect is not layoffs, it is that one senior person with good agents does the work of a five-person team, and the four juniors who would have learned by doing that work never get hired. The pipeline problem shows up in five years, not one.

Lower confidence, but I believe it: the durable value accrues to whoever owns the context, not the model. Models are converging and getting cheaper. Your ticket history, your codebase, your customer conversations, your decision logs are not. The company that structures its own knowledge so agents can use it will compound faster than the one with a better model and a messy wiki.

What to do about it

• Individually: stop prompting and start delegating. Give a model a multi-step task with tools and see where it breaks. That failure is your education.
• As a team: pick one workflow where a human moves data between three systems. Automate that one thing end to end with a review gate. Measure hours saved. Then pick the next one.
• As a company: write down what your systems can do in a form a program can read. MCP servers, typed APIs, clear permission scopes. It is infrastructure, and it is the kind that appreciates.

Using AI like Google is fine. It is just the on-ramp. The highway is agents doing work while you decide what work is worth doing, and the companies that figure out the management layer first will look, in retrospect, like the ones that got email in 1994.