You Don’t Own The Tool Anymore

For most of the history of personal computing, a tool was something you possessed.

You bought the software, installed it, learned how it worked and, within certain limits, it remained the same tool tomorrow. It lived on your machine. Its behavior was predictable. If you did not upgrade it, it did not upgrade itself.

SaaS changed that relationship.

The software moved elsewhere. The application lived in the cloud, the vendor maintained it, and the customer paid for continued access. Ownership became subscription.

AI pushes that transition much further.

With ChatGPT, Claude, Suno, Runway and a growing category of AI-native services, what we rent is no longer simply an application. We rent capability itself.

That distinction matters.

A word processor can be replaced by another word processor. A CRM can be migrated. A project-management application can be exported, rebuilt or substituted.

But when a workflow begins to depend on a particular model’s reasoning, a specific generative style, a proprietary context system or a unique orchestration layer, the dependency becomes less visible and potentially much deeper.

The interface may look simple.

The thing you actually depend on is somewhere else.

The Tool Can Change Without You

Traditional software changed in versions.

You installed version 4.2, and it remained version 4.2 until you decided otherwise.

AI services do not necessarily behave that way.

Models are updated. Models are retired. Safety layers change. Context limits move. Features appear and disappear. Pricing changes. Rate limits change. The same prompt can produce a different result months later because the system behind it is no longer the same system.

That instability is not necessarily a flaw.

Continuous improvement is one of the great advantages of the model.

But it creates an unusual category of tool: one whose behavior can change significantly without the person using it changing anything.

Imagine a camera whose lens was replaced remotely overnight.

It might be a better lens.

It is still no longer entirely your camera.

Your Workflow Lives Somewhere Else

This becomes more important as AI moves from experimentation into production.

A company may begin by using an external AI service to summarize documents.

Then it drafts responses.

Then it classifies customers.

Then it evaluates contracts, writes code, generates marketing material, prepares financial analysis or operates part of a support workflow.

At some point, the service stops being another application.

It becomes infrastructure.

And infrastructure creates dependency.

If the provider changes the model, the business process may change with it. If the provider raises prices, the economics of the workflow change. If access is interrupted, a capability the company has quietly come to regard as internal can suddenly disappear.

The organization may own the data.

It may own the application around the model.

It may even own the code connecting everything together.

But the intelligence performing the central operation can still belong to someone else.

The New Lock-In Is Different

Software lock-in is not new.

Databases, proprietary file formats and enterprise systems have trapped customers for decades.

AI introduces a subtler version.

The lock-in may not be the data.

It may be the behavior.

Teams gradually learn how a particular system responds. Prompts evolve around it. Employees adapt their processes. Integrations assume certain outputs. Quality expectations become calibrated to a particular model.

None of this necessarily appears in a contract or database schema.

It accumulates inside the workflow.

Leaving is theoretically easy.

Replacing the capability is not.

The Return Of Local

This is one reason local AI remains strategically interesting even when cloud systems are technically superior.

Running a model locally can be slower. It can require hardware, maintenance and expertise. It may not match the best commercial systems.

But it provides something the cloud increasingly does not:

control.

The model cannot disappear because a vendor changes strategy. Pricing cannot suddenly alter the economics of every inference. A capability can remain available even when an external service changes.

This does not mean every company should run its own models.

It means ownership is becoming a technical question again.

For some workloads, the most powerful model may be the correct choice.

For others, the model you can control may be more valuable than the model that scores slightly higher on a benchmark.

Capability As A Dependency

The SaaS era taught companies to count subscriptions.

The AI era may require them to count dependencies.

How many critical tasks depend on external intelligence?

How many workflows stop if a particular API stops responding?

How many outputs depend on a model whose internal behavior can change without notice?

How much of the organization’s actual operational capability exists outside the organization?

These are not arguments against AI services.

They are questions about architecture.

The convenience is real. The productivity gains are real. In many cases, building and maintaining the equivalent capability internally would make no economic sense at all.

But dependency should still be visible.

A rented capability can be enormously useful.

It should not be mistaken for an owned one.

The Machine Remains Elsewhere

AI has created a strange moment in software.

We can generate applications faster than ever.

We can automate processes that once required teams.

We can construct interfaces, workflows and internal systems with unprecedented speed.

In that sense, software has become easier to own.

The machine behind it has moved in the opposite direction.

Software once lived on your computer.

Then it lived in someone else’s cloud.

Now the intelligence itself lives there.

You can build the application.

You can design the workflow.

You can own the data.

But when the machine doing the work belongs to someone else, perhaps the software was never the thing you needed to own.