prompt2bot

2026-11-19
by Uri Walevski
Every few weeks someone asks why prompt2bot does not support MCP (Model Context Protocol).
It is not an oversight, and it is not on the roadmap. We looked closely at MCP and made a deliberate architectural decision to skip it.
The short version: MCP is a transitional wrapper designed for human-driven IDE copilots, not autonomous agents. Over time, it is not going to survive as a separate layer. It will simply collapse back into what it really is underneath: a documented API.
MCP assumes a very specific workflow. A human sits in front of a chat client or editor, realizes they want the assistant to talk to Linear or Stripe, hunts down an MCP server, edits a config file, and restarts the client.
Autonomous agents do not work that way.
When an agent in prompt2bot runs on a schedule, handles an incoming WhatsApp thread, or investigates a problem in a cloud workspace, there is no "human pauses to pick and install an MCP server" moment. An agent needs to discover what it needs on its own: search the web, read the service's API documentation, understand the contract, and call the endpoints directly from its own environment.
Whether that call happens through a lightweight Safescript tool or a Linux VM, the agent already has HTTP and a shell. Adding an extra protocol daemon in the middle does not give the agent a new capability. It just gives it a narrower, slower version of an API that already exists.
The most common pushback goes like this: "With MCP, the server holds the credentials and exposes safe, high-level tools, so the agent never touches raw API keys."
That argument falls apart the moment you look at what we already trust agents to do.
We trust autonomous agents to read private repositories, edit production code, run test suites, and open pull requests. An agent with autonomous edit access to your codebase already holds far more blast radius than a scoped API key for a third-party SaaS tool. Pretending we can trust an agent to rewrite production software while pretending we cannot trust it with an API token is completely inconsistent.
Even when you do want strict boundaries around credentials, MCP is the wrong layer to enforce them. You enforce credential boundaries at the secret and runtime layer: scoped OAuth tokens, host-allowlisted secrets, and static data-flow checks like Safescript that verify which domain a secret can reach before execution starts. You do not need every API provider on the internet to maintain a stateful wrapper process just to hold an Authorization header.
The second common pushback is ergonomics: "REST API documentation is messy and built for humans, whereas MCP tool schemas are clean and built for LLMs."
That might have been a fair distinction five years ago. Today, AI writes and maintains the documentation anyway.
The same models generating MCP tool descriptions are the models writing OpenAPI
specs, llms.txt files, curl examples, and SDK references. There is no reason
to assume a company's API documentation is written any worse than its MCP server
schemas. In practice, the canonical API docs are usually better: they cover
every endpoint, reflect the latest parameters, and do not lag behind a
half-maintained wrapper repo.
And when an agent does need repeatable workflows or curated conventions around an API, a versioned skill package from Tank gives it plain-text instructions and verifiable scripts without inventing a new transport protocol.
Every layer you put between an agent and the outside world has a cost: another server to host, another auth handshake to debug, another wrapper that falls out of sync with the underlying product.
Services already have APIs. Agents already know how to read docs and make HTTP requests. If you want agents to use your product well, you do not need an MCP server. You just need a clean API and clear documentation.
← All posts