AI & API. the next revolution of applications

Imagine a world where there are no graphical user interfaces (GUIs). No buttons to click, no screens to swipe through — just an AI interface that listens to you and does exactly what you wish for. This is the next evolution of user interfaces (UIs): a world where AI is the only thing standing between you and the applications you use every day.

As we move toward this future, standardizations like AsyncAPI are playing a crucial role in transforming how we interact with applications. By codifying how APIs (Application Programming Interfaces) should be structured, we can train specialized AI models to understand and interact with these APIs seamlessly. This means AI can become the UI for any application, eliminating the need for traditional screens and interactions.

Standardization of APIs: The Role of AsyncAPI

The rise of standardized API specifications, such as AsyncAPI, allows us to create a shared language for communicating with any system. AsyncAPI is a specification for defining asynchronous APIs — APIs that can handle real-time data or event-driven architectures (like WebSockets).

With such standardized schemas in place, we can train AI models, specifically Small Language Models (SLMs), that are designed to understand these specifications and generate the appropriate API calls. This means that AI models, like Large Language Models (LLMs) or SLMs, could act as the user interface for any application. The model would simply download the API schema (like AsyncAPI or OpenAPI), understand it, and interact with the API on behalf of the user.

AI as the New UI

In this future, you won’t need to touch your phone or click through endless menus to get things done. You could simply speak to an AI assistant: "Call me a taxi," and it would automatically understand the context, make the necessary API calls, and get the job done.

The AI becomes the ultimate user interface — one that can dynamically adapt to any application, from booking a taxi to ordering food, playing music, or controlling smart home devices.

Case Study: Uber API Using AsyncAPI

To demonstrate this concept, let's practice with a simple example: calling a taxi using an Uber-like service. Below is an AsyncAPI specification that defines how you can request a taxi using Uber via an API. This example was generated using ChatGPT and showcases how an AI could understand and interact with APIs in the real world.

	asyncapi: 2.6.0
	info:
	title: Uber Taxi API
	version: '1.0.0'
	description: API for calling a taxi using Uber.
	servers:
	production:
	url: wss://api.uber.com/taxi
	protocol: wss
	channels:
	taxi/request:
	description: Channel to request a taxi.
	publish:
	operationId: requestTaxi
	summary: Request a taxi.
	message:
	contentType: application/json
	payload:
	type: object
	properties:
	userId:
	type: string
	description: Unique identifier for the user.
	pickupLocation:
	type: object
	properties:
	latitude:
	type: number
	description: Latitude of the pickup location.
	longitude:
	type: number
	description: Longitude of the pickup location.
	destinationLocation:
	type: object
	properties:
	latitude:
	type: number
	description: Latitude of the destination location.
	longitude:
	type: number
	description: Longitude of the destination location.
	vehicleType:
	type: string
	description: Type of vehicle requested (e.g., sedan, SUV).
	paymentMethodId:
	type: string
	description: ID of the payment method.
	required:
	- userId
	- pickupLocation
	- destinationLocation
	- vehicleType
	- paymentMethodId
	taxi/response:
	description: Channel to receive the status of a taxi request.
	subscribe:
	operationId: taxiResponse
	summary: Receive status updates for a taxi request.
	message:
	contentType: application/json
	payload:
	type: object
	properties:
	requestId:
	type: string
	description: Unique identifier for the taxi request.
	status:
	type: string
	description: Status of the taxi request (e.g., confirmed, driver_assigned, arrived, completed).
	enum:
	- pending
	- confirmed
	- driver_assigned
	- driver_en_route
	- arrived
	- ride_started
	- completed
	- cancelled
	driverDetails:
	type: object
	description: Details of the assigned driver if available.
	properties:
	name:
	type: string
	description: Name of the driver.
	vehicle:
	type: string
	description: Vehicle model or type.
	licensePlate:
	type: string
	description: License plate of the vehicle.
	nullable: true
	eta:
	type: integer
	description: Estimated time of arrival in minutes.
	nullable: true
	fareEstimate:
	type: number
	description: Estimated fare for the ride.
	format: float
	nullable: true
	required:
	- requestId
	- status
	components:
	messages:
	TaxiRequest:
	contentType: application/json
	payload:
	type: object
	properties:
	userId:
	type: string
	pickupLocation:
	type: object
	properties:
	latitude:
	type: number
	longitude:
	type: number
	destinationLocation:
	type: object
	properties:
	latitude:
	type: number
	longitude:
	type: number
	vehicleType:
	type: string
	paymentMethodId:
	type: string
	required:
	- userId
	- pickupLocation
	- destinationLocation
	- vehicleType
	- paymentMethodId
	TaxiResponse:
	contentType: application/json
	payload:
	type: object
	properties:
	requestId:
	type: string
	status:
	type: string
	enum:
	- pending
	- confirmed
	- driver_assigned
	- driver_en_route
	- arrived
	- ride_started
	- completed
	- cancelled
	driverDetails:
	type: object
	properties:
	name:
	type: string
	vehicle:
	type: string
	licensePlate:
	type: string
	nullable: true
	eta:
	type: integer
	nullable: true
	fareEstimate:
	type: number
	nullable: true

view raw uber.schema hosted with ❤ by GitHub

In this case, the AI would read this AsyncAPI specification, gather the necessary user data (like location, destination, and payment information), and interact with Uber’s API to request a taxi. The AI becomes the intermediary between you and the Uber service, removing the need for you to open an app, enter details, or wait for confirmations.

The Future of Mobile and Application Development

This paradigm shift in user interfaces could fundamentally change how we think about mobile applications. Imagine a future where there are no traditional mobile apps with complex UIs. Instead, AI-powered models like LLMs will communicate directly with APIs, doing everything from booking taxis to managing your personal finances.

In this world, the AI listens to you, understands your needs, and makes the necessary API calls to get the task done. No buttons to press, no screens to navigate — just a seamless conversation between you and your AI assistant.

What Does This Mean for Developers?

For developers, this future means a shift in focus. Instead of spending countless hours designing and refining UIs, the primary focus will be on building robust, well-documented APIs using standards like AsyncAPI or OpenAPI. These APIs will be the foundation upon which AI models will interact with your application.

The future of app development is not app-based at all — it’s API-based. And the future of UIs is not visual at all — it’s conversational. The AI will handle the complexity of interaction, while developers focus on creating the backend systems that power these interactions.

Conclusion

The next generation of mobile applications will look very different from what we have today. The GUIs we are so familiar with will gradually disappear, replaced by AI-powered interfaces that can understand and act on our requests in real-time. With the help of standardized API specifications like AsyncAPI, we are moving closer to a world where AI acts as the ultimate user interface for any application.

In this world, AI will no longer just assist us — it will be the interface we use to interact with everything around us.

---

As we continue to move toward this future, tools like AsyncAPI and LLMs will become critical in bridging the gap between human intent and machine action. Developers should embrace this shift and focus on creating APIs that are easy for AI to understand, ensuring that their applications are ready for the AI-driven future.