AI agents become infrastructure when they can run locally

The most powerful thing about an AI agent is not that it can answer a question. It is that it can carry a task across tools, make decisions along the way and return with the result.

That shift sounds small until you compare it with how software normally works. Traditional software waits for us to translate a goal into a sequence of clicks. An agent can start with the goal. “Organize these files, compare the options, update the document and tell me what changed” is a completely different interface from opening four applications and operating each one manually.

I think agents will become one of the most powerful tools for repetitive digital work. But the first wave also reveals what must improve before they become dependable infrastructure.

Give the repetition to the machine

A large part of computer work is not intellectually difficult. It is coordination: copying information between systems, checking whether something changed, turning one format into another, applying the same update many times or collecting details before a person can make the real decision.

Agents are well suited to that middle layer. They can interpret enough context to handle variation without requiring a new automation for every edge case. A useful agent can:

• Monitor routine information and surface only meaningful changes.
• Prepare reports from several sources without manual copy-and-paste.
• Rename, classify and transform large groups of files.
• Draft recurring communication while keeping the person in control of sending it.
• Operate older systems that were never designed with good integrations.

This is not about removing human judgment. It is about moving judgment to the point where it matters. People should define the goal, review consequential choices and handle ambiguous situations. The machine should carry the mechanical burden between those moments.

The long-term version should run locally

I do not think the durable future is paying a remote model a noticeable amount every time I ask my computer to turn on a playlist, rename a download or check a calendar. Cloud models make sense when the task needs their full capability. Everyday actions should not depend on an expensive round trip to a data centre.

If an agent is meant to become part of the operating system, its basic intelligence should be available as reliably as the operating system.

Local models change the economics. Once the hardware is there, the marginal cost of a small request is close to the electricity it uses. They also improve latency and keep personal context on the device. An agent that understands my files, messages, routines and devices becomes much more useful—and much more sensitive. Local processing creates a stronger default boundary for that information.

The practical answer will probably be hybrid. A small local model can interpret commands, route work, use tools and handle private context. A larger cloud model can be called when a task truly needs deeper reasoning or broad knowledge. The user should be able to see which boundary is being crossed and decide whether the benefit is worth it.

Transactions are a different trust boundary

Giving an agent access to a playlist is one thing. Giving it access to a payment card is another. Agents still need significant development before I would trust them to complete open-ended transactions without a very clear approval layer.

The risk is not only a model making a strange choice. Instructions can be hidden inside webpages or documents. A service can present a misleading option. The agent can misunderstand currency, quantity, delivery date or cancellation terms. A small error in a text summary is annoying; the same error in a purchase is real money.

A trustworthy transaction agent needs more than a smart model:

• Strict limits on merchant, amount, category and frequency.
• A separate confirmation screen showing the exact action in plain language.
• Payment tokens that reveal less than the underlying card details.
• An audit trail explaining what the agent saw and why it chose the action.
• A reliable way to stop, reverse or dispute a transaction.

High-impact permissions should be narrow and temporary. “Buy this exact item for up to €40” is a much safer instruction than “handle my shopping.” Trust will grow through constrained successes, not by asking people to surrender control all at once.

Coding agents are already something else

Coding agents are the category that changed my expectations fastest. They are genuinely impressive because software development gives the agent an unusually good environment for learning from its own work. Code can be searched, compiled, tested and compared. Errors return structured feedback. Version control makes changes inspectable and reversible.

A strong coding agent can understand an unfamiliar codebase, trace behavior across files, implement a feature and run the checks that show whether it worked. It still needs direction and review, especially around product decisions and subtle architecture. But the amount of complete work it can carry is remarkable.

The biggest advantage is not raw typing speed. It is continuity. The agent can hold the whole task in view while performing dozens of small steps that would normally interrupt a developer’s thinking. That lets the person spend more attention on the system, the user and the tradeoffs.

Coding also shows what other agent environments are missing: clear tools, reversible actions, automated verification and a record of every change. If we want trustworthy agents in finance, operations or personal computing, we should build those same properties into their environments.

Agents are becoming a new interface layer

Graphical interfaces will not disappear. Sometimes a button, timeline or map is the clearest way to understand and control a system. Agents add a layer above them: a way to express intent, delegate execution and ask the computer to bridge applications that do not cooperate well.

The best products will combine both. Tell the agent what you want, then use a precise interface to inspect, correct or approve the result. Natural language is excellent for goals and exceptions. Structured interfaces are excellent for state, comparison and commitment.

For agents to become a long-term success, they need to earn a place in everyday computing. That means local capability, understandable costs, permission boundaries, reversible actions and honest signals when the system is uncertain. The intelligence is already impressive. Now the surrounding engineering has to make it trustworthy.