The headlines about AI are all model-centric: bigger, faster, smarter, benchmark after benchmark. But the development that actually changes what a single developer can build receives little praise, as the most advanced computing capabilities have quietly become interfaces. Speech recognition arrives via WebSocket, a language model via an HTTP endpoint, and the research as somebody else’s layer to build on.

We recently put this to the test with a small experiment of controlling a computer by voice. Say “computer, open the terminal and type ls”, and the computer opens the terminal and runs "ls", transcribed live locally, interpreted by a language model, executed locally. A decade ago, each third of that sentence was a research field. Our version took an afternoon and roughly 400 lines of Python, and not one of those lines does any AI.

A capability becomes an interface

What does it actually mean to “wrap a capability in an API”? Consider speech recognition. Behind WhisperLive, our open source streaming transcription server, sit the Whisper models, GPU inference engines, and voice-activity detection - years of work. What it provides is simple: stream audio, and it will provide a callback with the transcribed text.

The same works all the way up the stack. We ran llama.cpp in a container and talk to its API. llama.cpp doesn’t define its own interface; it intentionally implements the OpenAI-compatible chat API, the format that has become the industry’s de facto standard.

The API that runs in reverse

The most interesting development, though, is not how we call AI; it’s that AI can now call us. The standard chat API includes a mechanism called tool calling: alongside the user’s words, you hand the model a machine-readable list of functions:

  "name": "open_application",
  "description": "Open a desktop application by name, e.g., 'Chromium'",
  "parameters": { "name": { "type": "string" } }

When a user says “open the web browser”, the model doesn’t answer with prose. It answers in a structured way:

 "name": "open_application", "arguments": { "name": "Chromium" }

Nowhere in our experiment is there a rule for any particular sentence. We define capabilities, the model handles language, and the interface is the glue in between.

Integration is the new implementation

A telling detail from our experiment: every problem we debugged was mainly plumbing, a library mismatch in a container, or a downloader that disliked our DNS setup. Building on top of APIs now feels less like research and more like systems integration.

Curious to see this for yourself? Pick any two AI services with public interfaces; WhisperLive ships ready-made Docker images, and llama.cpp will serve any open-weight model and connect them to something. The distance between “that would be a cool research project” and “that’s a Saturday afternoon” has collapsed. All that’s left is to plug things together. The code for our experiment is available here.