There's a debate running hot on Hacker News right now: Model Context Protocol (MCP) is getting called out for solving a problem that doesn't really exist. A recent post titled "MCP is dead, long live the CLI" hit 59 points and sparked a thread worth reading if you build AI agents.
The argument, roughly: LLMs already know how to use CLIs and REST APIs. They've been trained on millions of man pages, Stack Overflow threads, and GitHub repos. When you give Claude a shell and an API, it figures things out. MCP adds a protocol layer on top of something that already works.
OpenClaw, one of the more prominent AI agent frameworks right now, doesn't support MCP. Neither does Pi. Both went API-first by design.
This post breaks down why REST APIs tend to beat MCP for agent tooling, and how ModelsLab's API fits into that pattern.
What MCP Actually Does (and Why It Promised a Lot)
When Anthropic released the Model Context Protocol spec in late 2024, the pitch was compelling: a standardized way for LLMs to discover and call tools. Every company scrambled to ship an MCP server. "AI first" meant having an MCP endpoint.
In practice, MCP is a JSON-RPC protocol that runs as a local process (or remote server), exposes a list of tools with schemas, and handles tool calls from the LLM. The LLM reads the tool definitions, decides what to call, and the MCP server executes it.
The problem? The tool definitions load into your context window. Connect 10 MCP servers with 5 tools each and you've burned thousands of tokens just on schemas before the LLM does anything useful. On a 128K context window that's still a real tax.
The Case for REST APIs and CLIs
REST APIs don't have a protocol overhead problem. You document an endpoint, the LLM reads the docs once during system prompt setup, and calls it via HTTP. No background process. No JSON-RPC transport. No initialization dance.
Three specific reasons developers are going back to basics:
1. Composability
CLIs and REST APIs compose naturally. Pipe outputs through jq, chain with grep, feed into the next API call. The LLM already knows how to do this — it's been trained on shell scripts and HTTP client examples.
With MCP you're either dumping everything into the context (expensive) or building custom filtering into the server itself (more code, more maintenance). For AI agents doing complex pipelines, this matters.
2. Debugging
When your agent does something unexpected with a REST API, you can reproduce it exactly: copy the curl command, run it, check the response. Same input, same output.
With MCP, something goes wrong and you're reading JSON transport logs, checking if the server process is still running, wondering if the schema got cached incorrectly. Debugging shouldn't require a protocol decoder.
3. Auth is already solved
REST APIs use Bearer tokens, API keys, or OAuth flows that developers already understand. MCP adds its own auth layer on top of existing auth — which means you're debugging two auth systems instead of one when something breaks.
With a simple API key, your agent just sets Authorization: Bearer YOUR_KEY. Works from shell scripts, Python, Node, Go — no MCP client library needed.
How This Plays Out With ModelsLab's API
ModelsLab's API is a straightforward REST API. You call an endpoint, get a response. No MCP server to spin up, no protocol negotiation, no context window overhead from tool schemas.
Here's what calling the image generation API looks like from an AI agent (or a human):
import requests
response = requests.post(
"https://modelslab.com/api/v6/realtime/text2img",
headers={"Content-Type": "application/json"},
json={
"key": "YOUR_API_KEY",
"prompt": "a software engineer debugging code at 2am, neon lighting, photorealistic",
"negative_prompt": "blurry, low quality",
"width": "512",
"height": "512",
"samples": "1",
"num_inference_steps": "20",
"guidance_scale": 7.5,
"safety_checker": "yes",
}
)
data = response.json()
image_url = data["output"][0]
An LLM agent can call this directly without knowing anything about MCP. The endpoint is documented, the parameters are standard JSON, and the response is a URL. That's it.
Same pattern for video generation:
response = requests.post(
"https://modelslab.com/api/v6/video/text2video",
headers={"Content-Type": "application/json"},
json={
"key": "YOUR_API_KEY",
"model_id": "zeroscope-v2-xl",
"prompt": "aerial drone shot of a forest in autumn, cinematic",
"negative_prompt": "low quality, artifacts",
"num_frames": 16,
"num_inference_steps": 20,
"width": 576,
"height": 320,
}
)
Or TTS:
response = requests.post(
"https://modelslab.com/api/v6/voice/text_to_audio",
headers={"Content-Type": "application/json"},
json={
"key": "YOUR_API_KEY",
"prompt": "Hello from your AI agent",
"language": "english",
"speaker": "default",
}
)
These are just HTTP calls. Any agent that can make HTTP requests can use them. No MCP client library, no server subprocess, no protocol overhead.
When MCP Might Still Make Sense
To be fair, there are cases where MCP has a real purpose. If you're building a tool that:
- Needs real-time state (like an IDE plugin that knows which file is open)
- Has streaming updates the LLM needs to monitor
- Requires bidirectional communication that HTTP polling doesn't handle well
...then the MCP transport model makes more sense. Local context like editor state or filesystem access can justify the overhead.
But for 80% of use cases — calling external APIs, running tools, generating content — REST is simpler and works better. You're not adding anything by wrapping a REST API in an MCP server. You're adding complexity.
The Pattern That's Winning
What OpenClaw and similar agent frameworks figured out: give the LLM a rich CLI and well-documented APIs, and it'll figure out the rest. The best thing MCP did, as one developer put it, is push companies to open up more APIs. The protocol itself is optional.
For AI agents that need to generate images, videos, audio, or run inference on models — ModelsLab's API is designed for this exact use case. One API key, REST endpoints, JSON in/out. Compatible with any language, any agent framework, any LLM.
No MCP server required.
Getting Started
The API covers image generation (Stable Diffusion, FLUX, Midjourney-style), video generation (Kling, Seedance, text-to-video), audio/TTS, LLM inference, and more. Authentication is a single API key.
Full docs: docs.modelslab.com
If you're building an AI agent that needs multimedia generation, skip the MCP layer. Call the API directly. Your context window will thank you.