Agentic Interface Design Is Becoming the AI-Native Mindset

Something is changing in the world of software design. It has been quietly creeping up on us ever since agents entered the scene as users of software.

A Brief History of Interfaces

Everyone in the software industry has heard the term API. We may not always remember that it is an acronym for Application Programming Interface. Today, API is often used almost synonymously with JSON over HTTP.

But there is an important reason we call it a programming interface. It is the point of contact through which other software communicates with a program. The internet is full of these integrations, and we rely on them extensively when building systems.

Because APIs have traditionally been designed for humans to use and integrate with, the industry has spent considerable time discussing how to design them well. The goal has been to make them flexible and broadly useful without making them too complicated for people to understand.

A good API was simple yet powerful.

However much we might want both, there is sometimes a trade-off between simplicity and usefulness. Imagine an endpoint that allows users to submit raw SQL and retrieve data. Such an endpoint would maximise optionality because it could support virtually any operation on the data in the database. But it would not communicate the system’s intent or reveal its intended use cases.

Balancing a high degree of optionality with a clear expression of intent has been one of software designers’ eternal struggles in the search for an ideal middle ground.

That middle ground may now be shifting towards greater optionality.

The DSL Nobody Understood

You may have encountered this situation before: a software engineer works on a system within a particular domain and decides to create a domain-specific language, or DSL. The intention is to support the system’s future capabilities and allow it to adapt to use cases that are not yet known.

When designed well, a DSL can provide an extremely high degree of optionality within a specific domain.

However, the language itself can become highly complicated. Learning it may feel almost like learning the syntax of an entirely new programming language. Designing a proprietary DSL therefore carries significant risk for a company, as critical knowledge about how the system works may disappear when employees leave.

For this reason, open standards have often been preferred over custom DSLs. The probability that someone outside the company already understands an open standard is much higher than the probability that they understand a proprietary language.

Today, this is becoming far less of a concern because agents—and LLMs in particular—can quickly understand syntax they have never encountered before.

Therefor, the case for DSLs is becoming attractive again.

A New Programming Paradigm

Taking this idea to its logical extreme, we may not even need a DSL. Agents can generate and execute code on the fly, which means a general-purpose programming language could become the only interface we need.

There are, of course, practical limitations. For low-latency applications, we may not be able to generate the required code quickly enough.

DeepSeek recently published the DeepSeek Harness and introduced the phrase “Everything is a plugin,” referencing Unix’s “Everything is a file” and Smalltalk’s “Everything is an object.”

The idea is that the agent harness provides a simple DSL for writing plugins for the harness itself and loading them into different states of the runtime. Some plugins may be temporary, while others may be persisted.

This concept seems extremely powerful. If LLM inference latency is reduced sufficiently, the future could look like this:

Natural language → Generated code → Interpreted code → User result → Program garbage-collected

This execution chain could mean that we no longer need static programs for many types of tasks. Instead, we could generate programs as we need them and discard them afterwards.

Of course, not every program can or should be created this way. There will still be a need for fast, statically compiled software. But, generally speaking, operating a system may increasingly become possible through this simple execution chain.

Final Thoughts

The potential for AI and agents to fundamentally change not only how we write programs, but also how we design them, is indisputable.

Interfaces that have traditionally worked well for humans often work well for agents too. However, the optimal interface for an agent is unlikely to be the same as the optimal interface for a human. As agents become increasingly important users of software, this distinction may fundamentally change how we think about interface design.

What this new paradigm will ultimately look like remains unclear. One thing is certain: the change is already happening. Keeping an eye on emerging approaches such as the DeepSeek Harness will be important for leaders and decision-makers who want to stay ahead.