alt Hacker NewsMCP was always a bad idea?
Comments
MCP is like anything else - it has its uses. Use it where it makes sense. Where it doesn't, don't. For my part, I probably rarely want my Agent to waste time writing its own adapter for a particular API that needs to be called, when I can just point it at an existing MCP server. And while context bloat can be a problem if you're using many many MCP tools, not every use case needs that many tools. Making that a non-issue in many cases.
For my part, I wrote an MCP server this weekend for Bugzilla, connected it to ChatGPT and now ChatGPT can help me manage my queue of bugs (and non-bugs - I use Bugzilla as sort of a generic work-item tracker, TBH). Simple, works and gives me a nice natural language interface to the tool. And if I want more than the generic API surface, I can add tools (or modify the existing ones) to add any additional business logic I want.
Can you "get there from here" other ways? Sure, absolutely. But this works quite well for my use case and I'm not anticipating "delete my MCP server" anytime soon. In fact, I plan to deploy one for interacting with my Mediawiki instance as well. I also even have plans to implement MCP for interfacing with all of my LXI/SCPI enabled test equipment!
If I get to the point where context bloat becomes an issue, I'll cross that bridge when I get to it.
MCP Apps[1] also look like a really cool addition to the stack. I've only built toy examples / demos to date but I'm pretty excited about what this brings to the table as well.
[1]: https://modelcontextprotocol.io/extensions/apps/overview
The premise of the article is that the Model Context Protocol (spelling it out to emphasize the core purpose) is inefficient in its current form. We can agree to that.
Now, does it mean agents don't need a protocol to connect to a server and discover its capabilities, tools, and distributed skills? I disagree.
> Agents with terminal access can replace most MCP servers
What should all other agents that don't have terminal access do?
MCPs are winning because within the ChatGPT and Claude apps, there are Plugin stores. These plugins are one-click installation MCP servers, with support for authentication. This is what business users are using.
I think many devs misunderstand MCP because they work in solo mode. In solo mode, you just have your secrets local. You don't care about auditing access. There's no IT managing the infra and third party secrets. You don't have to account for different harnesses and tooling; you just use your own harness and adapt your tooling to it. You're not thinking about revoking/rotating secrets when someone leaves your team. You don't have to deliver capabilities to many different runtimes and stacks.
Back in March, everyone was already pronouncing it dead[0] when in fact, it has only proliferated and become even more essential for both 3rd party systems as well as platform level capabilities[1] as agentic tooling has moved a bit more slowly into the enterprise. It was apparent even back then that enterprises will need MCP.
In a team context? Enterprise? Building web server backed or in-process agents? Not sure how you replicate the control, auditability, accessibility, composability, and security boundary that you get with MCP over HTTPS without a lot of bespoke, point solutions; in the end, protocols almost always win.
Could you do it with just REST APIs? I mean, MCP is just JSON-RPC over HTTP with standardized auth, schemas, and agent specific exchange flows (tools, prompts, resources, etc.). Could you do it with just CLIs? You lose a lot of the control mechanisms offered by MCP (auditing, security, centralized auth, etc.). The context savings are overblown except with CLIs that have good representation in training (curl, jq, cat, sed, etc.; your custom CLI is going to need to produce instructions and add to context all the same)
Heuristic is simple: don't use MCP for local, solo dev. As soon as you need MCP, you'll know it and you'll understand why it exists. Many of the harness level capabilities themselves are implemented as first party MCP (more apparent in the CLIs). MCP is basically REST for the agentic era.
[0] https://chrlschn.dev/blog/2026/03/mcp-is-dead-long-live-mcp/
The title feels clickbaity. Direct API, CLI and MCP all have their uses.
Direct access (Curl/own small function): This requires agent to have full understanding of the API spec. Yes, context can be protected using progressive disclosure, but this essentially means agent needing to understand the API again and again, before every use. Also, a typical API spec may or may not be agent-friendly. If there are nuances when calling an endpoint, where do we put these? Into OAS description? Works, but clunky.
CLI: It works beautifully, especially when a 3rd party CLI already exists for a complex backend. Assumes a well documented, agent friendly CLI, most CLIs are designed for human or CI/CD consumption. Talking about MCP taking up too much context, think about agent starting with my_cli --help, and going down through the switches and parameters one at a time to figure out how the CLI should be called. Less of a problem when calling a well know CLI (e.g. aws), but anything more niche (or custom) requires multiple turns to compose the final CLI command.
MCP: Has its issues, but offers an agent-native solution. Everything agent needs to know about a tool becomes available at once. In an enterprise environment MCPs can be served through an MCP Gateway, providing governance and permission management, this is quite contrast against running a CLI that requires agent to have execute permissions in its shell.
I really don't care about the technical or cleanliness arguments against MCP (which are valid).
What I care about is that many companies didn't have APIs, and didn't see a reason to have them (niche, dev-focused use case, or might produce a competing frontend/app)...
but now, those companies have a reason (agentic but let customer agents access data!). And for me, that means more companies now allow me access to my own data on their platform. This has been a net win!
Wow, this couldn't have been written at a worse time. OP absolutely doesn't know what he's talking about.
I think a most interesting middle ground option is the advent of CLIs specifically with agents in mind.
For example, grafana has a newer CLI called gcx that replaced grafanactl https://grafana.com/docs/grafana/latest/as-code/observabilit...
I originally used the MCP server but after running into context bloat and limitations around MCP I looked and found this. Seems to be a fantastic interface for agents, they breeze through o11y tasks with this thing.
Article is focusing too much on tool use over HTTP. One of the good things about MCP is that it's the same protocol whether the tool is implemented with HTTP or using stdin over a local process. And it doesn't make sense to talk about HTTP headers with stdin.
> There are still some issues, like CLIs returning machine-readable responses (JSON/XML, etc.), which tend to be very verbose and heavy on token usage, but we have ways to fix this.
This problem is also solved by MCP.
Anyway, when building a new tool, I personally try a CLI based tool first, then I'll fall back on MCP if the CLI is not working.
One big reason I see for needing to switch from a CLI to MCP, is if the agent needs to send a lot of data to the tool, and it has to pack and format all that input data as CLI params, and you can start seeing problems with the Bash command syntax being improperly escaped. That problem is solved by MCP thanks to using JSON-RPC over stdin.
Summary.. you shouldn't use MCP for everything, but there is a time and a place for it. Which is what the experienced devs have been saying about MCP for over a year now.
This doesnt match my experience. Yesterday, I was using Microsoft's Power BI Authoring MCP to make a semantic model from some SQL or CSV files. It was magical.
Microsoft has defined how to do that in the MCP. It's trivial to add the MCP to the machine and reliable in execution.
The alternative would be the model having to get the documentation directly from their documentation website, it sounds like. If this was the case, then MS would likely have great docs and probably support that markdown header... but everything hinges on finding a specific web page on the internet? Seems worse in every way than MCP to me.
Related to this discussion, I have written a manifesto against the excessive usage of MCP and other "tools" when using coding agents. I believe sticking to the basics yields the better quality overall in output
It's not just the agent understanding the API, it's locking down the access they have. If I want to give access to an internal service in specific ways that the API doesn't lock down then an MCP that offers very specific queries, with protective controls and transformations in place is very useful.
I don't get excited about the directories listing all the MCPs that do all these random things. However, I used claude to create an MCP that is a gateway to our system and it's enabled some pretty helpful functionality for us. I use claude cowork to create email designs using data and content from our CMS, it can push accepted work straight into our system, evaluate content, and analyze results. All of that used to be a manual tiring process. This removed a lot of drudgery and improved the quality as well.
When I first looked at MCP protocol, I did not like it. Then I realized, I don't have to care about the protocol. Claude can implement that for me and it did.
It would seem that curl + jq represents most of the solution these days. I recently learned that jq programs can be used in the other direction to effectively patch a json document too.
Putting both of these things together, I am running out of problems to solve as a human developer in the space of AI agent integration.
Assuming all your systems speak JSON right now, you are already 100% there with frontier models. You don't need to write a single line of code. Even if your json documents are monstrous in size. Put a size limit around the jq output and the agent will iterate with various filters until it finds a concise view of the problem. None of this behavior needs to be prompted or orchestrated anymore. Give the agent the tools and set reasoning level > 0.
MCP is a solid, obvious idea. The problem is the implementation and roll out. It was shotgunned from the start and made an otherwise simple thing far too complicated. IME, a shoddy foundation always leads to shoddy construction on top.
When done properly, MCP can be really useful as an API bridge. MCP is (or can be), after all, just a JSON-RPC endpoint that returns a standardized response format. "Tools" are just function calls w/ definitions that are LLM-consumable.
But, imo, it's foolish to dismiss MCP outright.
MCP lead to one good thing though
a lot of websites that never bothered to provide a REST API are now exposing MCP server because it has become popular, and you can use those servers to write normal automation for yourself, without plugging in any LLM etc
I’m not sure about some of this — I still think there is some value to MCP as a gateway to private resources when API access doesn’t exist.
But please don’t try to redefine the Accept-Language header. These things are well defined for a reason and redefining things isn’t helpful. Trying to figure out protocols on the fly for LLMs is how we got into the current mess. For all of the cruft that W3C has, I think that working with standards committees could help the AI vendors here.
I think there's at least one thing that MCPs get right, and it's that they make it easier to establish permission boundaries when agents are working with third part services and applications. Even with Claude from the terminal, MCP makes it easier for folks to standardize separate permissions and operations for general agent use than making people have to have multiple complicated API keys. Do I think it's the best solution for that? Not really, but I think it's probably better and on average safer than giving agents unfettered access to credentials to do anything, which seems like it'd be the default without MCP. That said, I can see MCP being replace with some sort of permission and sandbox system that's more generalized.
I don't think MCP is a bad idea, but using them incorrectly is.
CLI tools are great if you always use the same environment. But try using them from your iPhone, and they simply won't work; a remote MCP will work seamlessly.
HTTP APIs solve a different problem. APIs are designed to be predictable and consistent, so the client always knows the response shape in advance. The MCPs are designed to be dynamically discovered. This lets agents connect to new and unknown ones.
Trying to give APIs extra responsibilities so they can replace MCPs would just create more confusion. It's like creating an MCP server but calling it an API.
I have used Unity and Blender MCPs and I am not sure I am seeing why this is not a needed concept (or is a bad implementation).
If Unity updates the version (and the MCP server with it) - my agents immediately see the new surface. They weren't trained on the features of the new version of Unity, but they know about them as soon as they are added.
Context bloat is a thing - but you only turn on the MCP servers for what you are actually working with. If I am only in Blender, I don't need the Unity MCP. So it can be disabled.
These are just two example pieces of software but the concept applies to all of them with MCPs.
The major advantage of CLI is IMHO that you can use a CLI yourself too. It's a universal tool.
One thing I hate is when people write an MCP server for something useful and just that. Like, why don't you tell the same Claude or Codex instance you wrote to also expose the same functionalities as a CLI? The problem is that it's full of technical people with zero CLI knowledge nowadays (or, rather, for the last 20 years or so), and it kinda sucks in general, because lots of stuff only comes in GUIs that are not composable, not scriptable and sure as heck full of stupid bugs and limitations due to how harder it is to get GUIs right compared to popping out a "dowhateverctl" kind of tool
MCPs are indeed useless, they're very limited in functionality and frequently struggle with large requests or get wedged in bad states.
There is no reason not to use the native API directly.
Both MCP and other APIs put you at the mercy of the other party. Often that means that features will unintentionally drift from the "source of truth" human UI. At worst, capabilities will be intentionally limited.
Automating the human UI used to be difficult and fragile, but modern AI makes it much easier and change resilient.
> Recently, a Vercel engineer called on harnesses to send the programming language the client prefers, so documentation sites can serve more specific examples. For example, adding Python could prioritize docs for the Python SDK instead of sending something generic.
I know this is pedantic, but IMO that should just be in the URL if the resource is going to be totally different. Accept-Language is already a bit weird for the same reason in my mind, but I think the intention behind it is the resource itself is attempting to communicate the exact same resource. Obviously, two different languages from two different cultures are going to have different interpretations of the same direct translation, but the intention is the service has at least tried to avoid that as much as possible.
Adding programming language into that same concept just makes it seems like you're serving both /docs/typescript/vx/... and /docs/python/vx/... from /docs/vx/... despite them (in theory) having many more differences in between implementations/context than that would imply.
Agents should read sitemaps. Does anyone's harness do specifically that when looking up documentation?
These articles always assume the MCP is being used by technical people. MCP can be used via plugins on OpenAI/Claude marketplaces by random corporate users who don't know what a terminal is.
Best idea in the article, and I'm going to try it out later today:
We should start to standardize how agents use HTTP APIs directly. For example, agent clients could attach headers to identify themselves as agents, and servers could automatically send them response data as Markdown or text instead of HTML or verbose JSON.
There's probably still value (if you want to call it that) in it as a proxy, both to bypass IP address rate limits and to add necessarily credentials.
There's also another aspect Quite a few API providers provide automatic renewal for MCP server registrations, but not for personal access tokens. This may be less relevant when models just drive the user's browser.
It seems like OP needs to provide a solution to hiding the credentials from the model in order to suggest CLI-mode only, and also a solution to the problem of agents without shell access.
LLMs were a bad idea. MCPs were the band-aid to get them closer to the real world and do something for recursive self improvement. Then LLMs became better suited for everyday use.
I'm tired of these kind of posts. This author is on my black pill list.
MCP's monolithic design always felt like fighting a hydra; one fix created five new bugs elsewhere. Never understood why it gained traction.
Correct me if I'm wrong, but an MCP server still make a lot of sense for remote-controlling a UI application (like a game engine editor) which otherwise doesn't have any 'access points' for remote-control right?
An AmigaOS-style "scripting port" would work just as well, but AFAIK that's essentially what an MCP server is (a socket that implements a discoverable command protocol).
I would actually love if all applications and services could agree on a standard for scripting / remote-control. If the AI hype is what it takes to get there, then so be it ;)
Just have a route that describes your API endpoints in a machine readable format, eventually they'll come to some consensus and in the mean time this works well enough to allow LLMs to plan.
CLI, API, MCP are all useful ways to connect. It just depends on the use case you're going for. I've used all 3 and find that they all have benefits.
MCPs are great when you just want that native out of the box low mistake way for agents to call your services it's great for certain cases.
I also developed a new method of using MCP called ADP (Agent Delegation Protocol) that sits on top of MCP where there is only 1 tool for the MCP, and when the agent wants to do something it just issues natural language commands and the ADP engine handles the rest it does all the routing etc... to the right sub-agents and executes tasks and return the results. (more on this soon).
Internally if you have a good orchestration system you do not need MCPs and can use APIs but those APIs should be designed for agents, IE based on DSLs, that project into internal operations. I do this too.
CLIs are great for testing things out, but agents often get things wrong, it's great for experimenting to see what works out of the box and what doesn't.
For me the perfect medium is a mix of MCPs and APIs. APIs are cheap if designed well, and if your workflow is a DAG then APIs are especially good because you already have a deterministic flow which means you can use small LLMs or even just something like Jev.
So my summary is:
CLI - Great for out of the box, things that are well known, where you want to verify the output
API - Great for low-cost large volume, highly repeatable workflows, that require high reliability you want your agent to execute without you having to hand hold.
MCP - Great for building debugging systems, or as an entry point to more complex workflows that you need your agent to have some ability to orchestrate.
I'm using MCP with ADP to route to large workflows that execute APIs internally for what i'm working on. So it's a mixture.
I don't agree.
The real value of MCPs lays in providing a controlled interface to models.
The benefits of control are multiple; models getting better means that, if necessary, they can go around the limitations, but generally their adherence to it is desired.
The exact same thing has been discussed many times here on HN and elsewhere, yet the author did not bother to just look them up before posting these uninformed opinions, as if they just discovered something new. It seems a complete waste of time to go to a conference on MCP with that kind of understanding.
Surprised WebMCP hasn't come up here.
Of course you can raw dog it with "computer use" and just have the agent click around the UI, but exposing semantic actions directly from the site seems like a much cleaner interface.
I’m not sure I agree that the frontier just know the apis right now, in my experience trying this there’s still a lot of faffing around trying to figure out the right parameters happily burning tokens and bloating context. Also the cost effective models to use in production for real agentic enterprise work absolutely still need the extra help and will do for at least the next 6 months.
MCP is an incomplete abstraction. It solves things in the right direction, allowing agents to interact with some given system via a controlled ingress. It's a fancy proxy, and by itself doesn't really do much to enable autonomous interactions.
MCP is basically RPC, and it suffers all the problems of RPC like mechanisms. It has long round trips times, significant de/marshalling costs, coupling between caller and consumer, versioning issues, etc.
Over time I think we'll see an evolution towards client-side micro models that reduces RTT latency, and a message bus architecture that allows multiple local micro models to push queries to the server, continue working, and receive updates on various topic asynchronously. The channels or topics (like a blackboard system) would be accessible to multiple local agents, as would the results of tool calls.
Message bus systems are easier to version, write adapters for and debug than random CLI tools and web interfaces. MCP interfaces are not going anywhere, they are just evolving.
There are numerous applications that you don't need and don't want to give shell access to an llm.
"[...] built for a time when LLMs weren’t that smart", which was roughly 1.5 years ago - unreal development.
> The MCP Industrial Complex
Was that a real thing? I mean it must've been for it to be mentioned there, but, rephrased: what was the scale of that?
How many individuals were involved in that? 1? 10? 100? 1000? 10000? 100000?
Some people can't appreciate that their local Claude code workflow isn't the only MCP usecase. If you don't need it, then don't use it.
I use myself the DaisyUI Blueprint MCP and it's totally worth it. Not even fable 5.1 without all that context and way of directing could work this well. At least, I feel is worth paying for that MCP.
I always wonder why they didn't use Swagger|https://www.openapis.org. It addresses all the key description and security details.
Isn't the whole point of an MCP is to increase somehow the determinism of how to communicate with a certain external system? MCPs feel to give easier guidance to the LLMs, rather than letting them extracting the knowledge on how to connect to a given system.
Without, I feel they are more confused on how to get an outcome, as they may try, infra or inter sessions, different approaches
I have a tool wrapper that captures the output of anything and allows the LLM to query it later, to save on tokens. It “smartly” truncates the output (basically like Node’s util.inspect) and allows the LLM to expand truncated content.
It basically is called like “capture some-cli” and it… captures the CLI output, outputting a subset of it + a handle to continue querying.
This for me solves the danger of a tool returning tons of content.
Even if the premise is correct, bad ideas are often the first step towards a good idea.
This article entirely misses the value that MCP brings today.
Sure, there's almost no reason to use MCPs if you are running a full-blown terminal agent (Claude Code, Codex, Meta Muse, OpenClaw etc) with unfettered internet access - just let it call APIs directly.
If you want to operate something that's less YOLO than that, you'll find yourself wanting:
1. Control over exactly which external services it can access
2. A way to handle authentication that doesn't allow the agent to directly access API keys
3. A sensible UI to allow users to connect and authenticate further services
4. Strong audit logging for what's going on
MCP makes all of that so much easier to provide.
Thinking MCP is obsolete because full coding agents don't need it misses out on all of the other things we might want to build.