[mxstbr]

I run the team at OpenAI that's responsible for the ChatGPT App Store, Codex plugins, and all things MCP.

The thing that all these "MCP is dead" posts are missing is that whether or not MCP is used as a transport protocol is actually completely irrelevant.

The reason MCP isn't dead is because practically ~every company on the planet is building an MCP server. I know this because we interact with all of them. Most of these companies don't have a CLI. Many of these companies don't even have an external API! And yet, they're all building MCP servers.

And that's why MCP is not only not dead, but more important than ever.

Maybe we will turn every MCP server into a CLI under the hood. Maybe we'll use code mode. Maybe we'll implement tool search.

All of those are just implementation details to the much more important point: our AI agents are getting access to services they otherwise would never have had access to.[0] That's what matters.

So, is MCP dead as a direct communication layer for models to speak to? Maybe, maybe not. Is MCP dead as a protocol? Hell no, couldn't be further from the truth.

[0]: Although I will say the Codex app's computer & browser use features have made this statement a lot weaker than it used to be. If you haven't tried them yet—they're mindblowing.

[tlogan]

I would bet that MCP is going to die.

The main reason is that it adds another layer (and human) that can, and probably will, get out of sync with the real-world implementation, whether that implementation is an API, web, or a CLI.

AI should not be using a protocol or set of instructions that is different from what humans have access to (know and use).

Sure, companies want to expose MCP servers because it is the cool thing to do right now.

So the current situation is basically that I used Claude to write an MCP server on top of our API. And then I need to occasionally tell it update it match the public doc.

And my reaction is: really? It is not like our API docs are not public. Claude Code created our MCP server with zero instructions beyond what is publicly available. I just told it to read the docs from the net.

So MCP feels more like a temporary workaround for current model limitations.

[mrgaro]

MCP has a great advantage over agent using cli: MCP is much easier to secure so that it's hardwired that the agent can only call the pre-configured MCP server. We run our agents so that they don't have access to public internet, so they could not run any cli commands. It's all either built-in agent tools, or 3rd party mcp servers. The agents never have access to any credentials, which makes them much more safe to use than a claude code running in yolo mode with fetching random cli binaries from the web.

[zingar]

Can you not just install/ restrict the available CLIs in the same way you do with MCPs?

Or what else am I missing about why MCP is more secure than a CLI?

[rubslopes]

MCP allows you to easily separate API requests from their access tokens, so that the LLM only has access to the requests part. Giving an LLM CLI access removes all boundaries, anything goes.

EDIT: to add an example: I have a personal claw agent that I only use CLI, I don't care. But I'm also building an agent inside a company product, and there we use MCP all the way.

[octoberfranklin]

You can easily do this with simple Unix `chmod x-rw` on a wrapper that makes HTTP requests, adding the access token as it does.

[noplacelikehome]

The point is that you still need to expose a shell or a wrapper around exec to launch those commands. That is t appropriate when I want to lock the model down to working entirely from a sandboxed environment and expose some basic tools which are not “entire posix user space”.

MCP servers are not dead, they’re just overused in contexts they don’t really make sense in.

[mrgaro]

Another examole which is trivial with MCP but hard with cli binaries: blocking certain commands, such as write operations from the agent. With MCP your client can easily have a blocklist for commands, but with cli you would need to code custom logic for each cli separately.

[dropofwill]

Just use scopes in the API key the agent uses? If you’re exposing something publicly that should be a requirement anyways.

That’s how I use gh, aws, etc. No need to modify any of the code in the cli, they’re just wrappers.

[mikojan]

I want the harness to use read freely but require confirmation for write.

[whattheheckheck]

Server implementers have an information advantage than the client coders wiring clis together to do a job

[octoberfranklin]

Access control is the operating system's job, and modern OSes already provide plenty of great tools for doing that.

Just use the existing sandboxing infrastructure like bubblewrap, seccomp, etc. I have way more faith in that than in something than some regex-based blocklist.

[CamperBob2]

With MCP your client can easily have a blocklist for commands, but with cli you would need to code custom logic for each cli separately.

Nah. Just don't let your model do anything potentially destructive until three or four other models have vetted the proposed action.

Filtering individual commands can never provide more than the shallowest semblance of security. If a smart model is hellbent on deleting your production database, it will write its own Python program to do it if the usual commands are blocked.

[zaphirplane]

How do you ensure the cli can use the auth without knowing how to read it ? It’s potentially a bearer Token

[kylling]

It is crazy how the preferred way or securing AI are vibe coded MCP servers which at the same time do access control, credentials handling and HTTP server/client boilerplate. Want to use a new API: just vibe code a new MCP you won't fully review. It is hardly better than yoloing. The security critical parts needs to leave MCP and be integrated with, or be in front of, the API in a way humans will understand and review.

[Dylan16807]

Are there actual people suggesting this or did you combine multiple posts that were arguing different things?

[kylling]

The parent suggests MCP as a way to secure credentials and enforce guardrails, and sibling comments iterate on this. I might be reading a bit between the lines with my comment, but did not intend to derail the discussion.

[Dylan16807]

But the parent who suggested MCP for security didn't say anything about vibe coding it. The person who talked about vibe coding an MCP was the one saying MCP isn't very useful.

[twoodfin]

I think that’s exactly right: MCP provides a capability security model for agents.

[v3ss0n]

How in the world MCP is going to be more secure? It introduce a big surface layers for injection attacks and supply chain attacks..

[PaulHoule]

To be devil’s advocate: if you are just running commands with bash or power shell or the like there is no protection. You might have some rules that ban

rm -rf ~

but sandboxing in general is not an easy problem.

[andoando]

Youd just whitelist the list of cli calls equivalent to what your mcp offers

[skydhash]

It is. The issue is all the weird constraints that usually come up with it. Like I want to use my favorite code editor, I want easy copy and paste, or I can’t bother setting up a separate user account on my computer.

On unix, you can easily create a new user account, switch to it (or ssh or setup vnc), and run the tool there. If users are enough for servers on the internet, they can be for your workstation (unless there’s something like copyfail, but you can make do with a vm then).

[js4ever]

Totally agree, MCP is the WAP equivalent of mobile internet access.

[brookst]

Have you used MCP, at the protocol level?

WAP was dumb and failed because it oversimplified the web, and phones evolved to be real computers.

MCP is more sophisticated than typical APIs. It adds organization, policy, and code vs data (prompts) partitioning.

IMO it’s more likely that non-LLM apps will start using MCP than it is for MCP to go the way of WAP.

[zwischenzug]

I'm old enough to get this reference! Spent years writing WAP... it was really great at the time.

[jmkni]

It blew my mind as a kid

I was maybe 10/11 when the Nokia 3330 came out, and being able to use the internet while not in front of a computer just felt like magic

[rwoerz]

Those were the days of the dotcom era when finding the next restaurant with your Nokia + WAP was THE killer use case.

[rixed]

Soon, if you want the performance of your AI clients to improve (wrt. token count and understanding) you will start to customize the output of the MCP server for more synthetic data, different data types, more permissive inputs, etc. And since most your clients will be AI that might be your API that fall behind, and MCP that will be maintained.

That's at least my experience with my current project: the traditional json, coding oriented API feels out of place, I maintain it out of habit. The real API is the MCP server, which is not designed like a traditional API would; understandability of the output for an LLM prevails instead of searchng for exhaustiveness, orthogonality etc.

[pmontra]

Interesting points. A couple of questions. Do you have a frontend (React, Vue, anything) and if you do, does it interact with the server using the MCP server or the JSON API? Are all your clients AIs or do you expect that most of them will be AIs?

The reason I'm asking those questions is that a customer of mine has a service with a JSON API, a Vue frontend and a score of customers using that JSON API. We know that the newest ones are using bots to code their clients (and they are using them wrong, by the mistakes they do.) I don't see a near future in which all those third party apps become LLMs that would benefit from a MCP server and we retire the API.

[rixed]

I do have a front-end, but it interacts with the server with a specific, private API. It's using a more compact data encoding than JSON optimised for streaming the data that's needed for the front-end.

But yes I agree with your point: for a simpler app with a more traditional web UI it's likely the API used by the front-end would largely overlap with the user-oriented API. Then indeed the REST API has to be maintained for as long as humans continue to use the front-end.

[Groxx]

I have some hope that this'll all lead to a revival of semantic web / microformats / etc. Why write an API when you can just add some markup to your existing API, which already looks like stuff that it was trained on, and won't fall out of sync (because you use it too)?

[troupo]

> I have some hope that this'll all lead to a revival of semantic web / microformats / etc

Why would it? Do you see any agents or models use that? No, instead vibe coders at Anthropic vibe-designed a bespoke protocol that sidesteps and ignores the last 60 years of API development and integrations.

[brookst]

Different levels.

Yes, MCP is a hack that could have been carefully built on prior art, and it would have been better for it.

Yes, MCP is capable of expressing that prior art, and you can do semantic web concepts even if the wire protocol looks different.

[troupo]

> Different levels.

How are they different?

> Yes, MCP is capable of expressing that prior art, and you can do semantic web concepts even if the wire protocol looks different.

What are you talking about?!

[brookst]

> How are they different?

Take a look at Semantic Web[1]

SW is about data interchange and standardizing semantic representations… it relies on formal, structured taxonomies of All The Nouns and then All The Verbs For Those Nouns.

MCP is structured at the protocol level, but its whole value is the bridge from structured to unstructured: natural language agent intents to specific APIs, domain-specific data to fuzzy natural language.

Semantic Web only works if someone has clearly defined the domain you want to operate in. MCP can work without that kind of definition (an API or prompt needs to exist, but it doesn’t need to be modeled in any way similar to RDF)

> What are you talking about?!

For instance, MCP-to-SPARQL bridge[2] that lets agents query SW data.

1. https://www.w3.org/wiki/SemanticWebArchitecture

2. https://pypi.org/project/mcp-server-sparql/

[PaulHoule]

That was exactly my thought when I saw MCP: like we know so much about creating protocols but get a bunch of people together with no experience and that’s what you get.

Reminds me a lot of Microsoft’s WS-disaster of the early 2000s except the latter was thought through a little better.

To be fair a while back I did design an API for a general purpose model trainer which was absolutely atrocious for a few reasons, my own ignorance was a factor but the problem of accommodating everything from “model that can be trained in 30 seconds on a small machine” to “model that takes 30 days of training on a cluster” problematized it.

It would have made so much more sense to build a standard for documenting ordinary API endpoints and CLIs.

[flaburgan]

You mean a swagger?

[Groxx]

It even has a catchy name that certainly won't get confused for the LLM company: OpenAPI.

[PaulHoule]

yes

[iamacyborg]

I definitely see it going that way from a marketing perspective if you want what you send/produce to be machine readable and actually used in intermediated surfaces like email and web search.

[mjmas]

But then there is the other side that companies are adding MCP servers to stuff that has never had a public API.

[IggleSniggle]

They are building them because they can ask an AI to spin it up. They could have asked it to spin up the public API just as easily. The MCP choice is a fashion choice vs an openapi spec with similar documentation (or any number of other human+machine readable tooling). It might accidentally win or accidentally lose just because of the timing / network effects.

[holoduke]

Funny thing is that Claude knows the api of Atlassian better than the mcp they provide. Mcp is limited it doesn't have all api calls described.

[losvedir]

I haven't found this to be the case. I tried to make `acli` work, with CLAUDE.md fine saving the things Claude learns about how to use the API (eg which custom variables to include and so on), but in the end found the MCP to work better. I think I had trouble getting the CLI to update a certain custom field, which the MCP was able to do. Not to mention, I don't think `acli` even works with Confluence?

[2muchcoffeeman]

Is this not just a tooling problem?

[Geezus_42]

As someone who supports Atlassian products; Atlassian is a tooling problem.

[PaulHoule]

Yeah, having two tools when you only need one is a problem. Like one is always going to be full phat and the other will ride the back of the bus.

[winrid]

I usually just generate the MCP server spec from existing openapi/swagger spec, maybe with a filter to omit certain endpoints and so on.

[hashmap]

MCP will definitely not die. It works, it makes things easier for non-technical people, and is extremely inefficient. You can build an entire industry around that.

[PunchyHamster]

> The main reason is that it adds another layer (and human) that can, and probably will, get out of sync with the real-world implementation, whether that implementation is an API, web, or a CLI.

The menial task of updating the interfaces when the code changes is something AI should be really good at, so it's essentially little to no actual programmer time waste

> So the current situation is basically that I used Claude to write an MCP server on top of our API. And then I need to occasionally tell it update it match the public doc.

> And my reaction is: really? It is not like our API docs are not public. Claude Code created our MCP server with zero instructions beyond what is publicly available. I just told it to read the docs from the net.

Updating MCP by AI is one time effort.

Having AI re-create what MCP would do for every piece of code that uses a service is massively wasted effort in comparison

It's not question of "model limitation" but of cost effectiveness.

[Gomotono]

What we really should have is an aligned discovery protocol and a generic globally used sdk which handles negotiation.

You have a client, the client uses the SDK, talks to endpoint x. Endpoint x tells it very efficient that they are now talking protobuf and rpc over quick or http15 and thats it.

Why don't we have this? Right because of people.

Its always people problem.

MCP is now here, it might stay.

[personjerry]

> temporary workaround

I've heard this one before

(Maybe it'll be the first time that a temporary workaround stays around longer than expected then)

[ekianjo]

You can build a MCP server in minutes these days to connect to a REST API. The friction is close to zero.

[random3]

+1 - MCP is a transient effect of current models’ limitations. But the “when” is relevant

[hnlmorg]

That’s only true for the frontier. The moment you start looking at enterprise consumers of AI you’ll see slow monoliths that make decisions by committee and those committees often don’t even understand the tech they’re passing ruling on.

And you’ll also often see CISO-offices that are managed by checklists and yet more committees.

Asking for MCP access is generally easier than asking for an API for several reasons:

1. MCP supports OAuth, so your access conform with numerous CIS (et al) compliance checklists (short lived secrets, MFA, user-specific credentials, user access managed by centralised directory services and thus can have business rules applied, etc)

2. MCP is something a business can make a cooperate decision on. And then you can refer to that decision each time you need an access to new service. Whereas API access isn’t. In some cases APIs are governed by LLDs, and then you have an extra layer of “fun” having to update documentation to describe, in detail, the technical specifications too.

3. MCP defines the interaction better. If you need to request access to an API then the inevitable question from the committee is “where is this code running from?” and so on and so forth. Whereas saying “MCP access for AI to assist the project team with development” is a lot easier conversation to have.

In short: Enterprises are a very different beast to your average business.

[tlogan]

Here is my vision: the future of AI is about truly understanding the real world. The world around us.

Not everything in the real world will expose an MCP server so AI can interact with it.

Eventually, AI will need to move beyond MCP and interact with the real world the same way humans do: by observing, interpreting, reasoning, and taking action in messy, imperfect environments.

MCP tries to organize our messy word to make interaction part with the world easier in the near term, and it will help accelerate very early progress. But ultimately, MCP is a temporary bridge. Not the final destination.

I give it max 3 to 6 years and it will just die.

[hnlmorg]

The problem isn’t that AI cannot do this already. Because it can. The problem is cost.

There are people complaining that MCP costs too many tokens. Parsing the same UIs that humans do would just be insane.

And to be honest, I don’t think that’s the right goal of AI anyway. Most competent engineers prefer APIs to human interfaces. So why should machine-to-machine use that too?

[PaulHoule]

Explains a lot.

[Someone]

> AI should not be using a protocol or set of instructions that is different from what humans have access to (know and use).

Should it? I think it can be very useful to constrain what your AI can do (e.g. read files but don’t delete them). MCP is a way to do that.

[codebje]

Authorisation is a way to do that, too.

[Someone]

Yes, but you often do not have much control over that.

For example try giving a local LLM read access to specific folders in your email account

[otabdeveloper4]

Theoretically you should be creating a "read email" CLI tool and letting agents interact with it in a chroot sandbox.

LLMs are much more proficient with bash and --help than they are with bespoke API protocols.

Treat LLMs like you would a junior programmer - keep things as generic and obvious as you can.

[skydhash]

Easy. What a cron script (that runs as root) that populate a maildir that the agent (restricted user) has access to. The. you restrict network access to the internet, and have it send you its findings by mail (local mail server).

[Someone]

That’s not an example of “Authorisation is a way to do that”, and, I think, not easier than writing a MCP server.

[sunnybeetroot]

If you don’t know how to keep your openapi spec up to date then yes you’ll struggle with keeping an MCP up to date. At the end of the day, keeping APIs in sync with SDKs, documentation, MCPs is a solved problem through automation. It’s not hard.

[sofixa]

> So the current situation is basically that I used Claude to write an MCP server on top of our API. And then I need to occasionally tell it update it match the public doc.

> And my reaction is: really? It is not like our API docs are not public. Claude Code created our MCP server with zero instructions beyond what is publicly available. I just told it to read the docs from the net.

My reaction to this is.. really? Presumably your API and API docs have a release process. Hopefully an automated one. Why isn't the "hey Claude, update the MCP server" step a part of it?

[oldsecondhand]

That wouldn't solve the core issue: if Claude makes a mistake during the MCP generaration, it would poison further agentic use.

It's adding another failure point to the process for no gain.

[sofixa]

No, because as everything which is a part of a release process, you'd have tests.

[slashdave]

> get out of sync with the real-world implementation

You are missing the point. When the API moves, the agent has to adapt. Are you rewriting its skills?

MCP provides the instructions. When the API moves, MCP adapts. You need to do nothing.

So, basically the exact opposite of what you are claiming

[debarshri]

Totally agree with you.

[brookst]

MCP is a higher layer than your existing API.

It’s like saying APIs are dead because you can just use HTTP. They’re not the same thing, though of course you can hand-roll the higher layer in the lower one. It’s just more work, less standard, less valuable.

I don’t think models will ever prefer a low level API to a decorated index of API features and how to use them, same way developers will never prefer a list of HTTP endpoints and bespoke headers + query strings + POST bodies over a structured API.

[IggleSniggle]

Right; isn't this already captured by an openapi spec with RBACs? Plus the benefit that your ai agent can keep using all the pre-AI tools that already interface with those specs. What is MCP bringing that an openapi spec doesn't?

[ok_dad]

You can build an MCP client really really easy today with libraries and it integrates with inference calls very well. If you want to give a cloud agent access to another api, you need to bills a connector or give it shell access or some sort of sandbox with tools to access that stuff. That’s fine, but how do you then give it auth access? How do you ensure security boundaries? MCP builds those in and the shape (prompts, resources, tools, etc) are good for agentic work.

It’s like asking why we needed browsers when we had BBSes; they serve a different but similar purpose and are build on different abstraction levels.

[ford]

Basically MCP is little more than a brand name for "APIs LLM's can use". This means more services are creating APIs, because xyz company who's never been super tech forward doesn't want their tools to be obsolete when everyone uses agents.

Overall, I am in favor of this goal. I'm not sure this is the protocol I'd choose to accomplish it, but it's the one people hear about, and the one they're using.

[pjjpo]

Yeah it was quite weird seeing "Many of these companies don't even have an external API!" given MCP is literally a protocol for an external API. Not a good one in my opinion but it indeed has mindshare.

[bluegatty]

"and the one they're using." no it's not.

Agents are just making REST calls and that's it.

The best thing a company can do to make their stuff 'agent ready' is to make sure the lllm.txt docs are clear-cut and ready for the AI with clear instructions for agentic use.

'MCP' is frankly a hurdle.

Now - it probably does make sense to add MCP, because it's not expensive at all, and some will like that use case, it maybe garners a bit more attention .

MCP is a 'weak externalization' - people are using it because others are using it, and it's a 'workable' but 'not strong' solution.

It could very well entrench itself however.

[Aperocky]

It's that extra amazon box that wrap the actual box that wrap the thing you ordered. Except you're doing the wrapping.

[bostik]

I would say the truth[tm] is likely somewhere in the middle ground. Right now corporate MCP deployments happen to satisfy two very specific stopgap niches:

    * Internal services that never had real APIs are getting them retrofitted via the MCP layer
    * MCP servers can run with dedicated service accounts that assume-role to a safe(r) subset of the calling user's permissions

The first one is a business benefit. Enterprises tend to have a lot of data siloes, and coordination between teams/departments/units just to learn that a given data set exists takes a LOT of time - even before you start to arrange suitable access to any of them.

The second one addresses a much deeper architectural chasm. We want to have our agents carry nearly-the-same-but-not-the-most-dangerous permissions as we do. No regulated business can risk unleashing agents with zero judgement capacity to wreck their systems, and on the other hand the existing identity systems are not geared for real-time dynamically adjusted user permissions. The need for so called "agent-aware IAM" is urgent. So instead of letting users connect to the internal APIs directly with their full suite of powers, MCP servers act as stand-ins for API gateways.

MCPs are not as flexible as full-fledged CLI tools, and that's a bit of a shame. But they can also become identity-aware proxies that enforce the intended permissions for agent-safe use. It will probably take years before IAM systems can adapt to the needs of the new world, and it will take another DECADE after that for the improved IAM systems to become universally available across the larger enterprises. So in a big way I agree with you:

> MCP is a 'weak externalization' - people are using it because others are using it, and it's a 'workable' but 'not strong' solution.

"Workable" is a load-bearing term. MCP servers are by no means perfect, but they are good enough for specific needs and allow to move the balancing point as needed while the world catches up.

I'm an engineer and prefer CLI or raw API access 99% of the time. But I also have decades of scars from infosec. The single biggest security threat for a business used to be an employee who could not get their job done. They found ways to work around the roadblocks. These days the single biggest threat is an employee who can not get their job done, but has an infinitely patient agent with vast latent capabilities at their disposal.

[bluegatty]

So this is thoughtful - but - MCP isn't actually a very good solution for corporate automation either.

Corporate automations face the same problems human driven agents use:

+ The 'tool' section of the chat is not the right place, and it's too limiting + The very concept of MCP server introduces a brittle layer - for what purpose?

CLI for local calls, REST for remote.

That's it.

We build security around that the same way we would otherwise.

Now -> 'better / standard' json type calling for both of those!

Sure! 'Agent Calling API' or something. Yes.

'Agentic Identity Standard'? Yes to that as well.

But MCP was 'the right solution for a period in LLMs that has been superceded.

If MCP did not exist today - we would not invent it. That's the strongest argument I think.

[PaulHoule]

That mimetic thing…

I remember 10s of HN submissions where handlers were trying to get conversations about MCP going on HN back when there was almost nothing known about it and nothing to say.

It was always about tricking people into thinking there was authentic interest in it and it still is.

[rand593843]

Yes. But that's dangerous for end users. It enables lock in. All it does is context management, so skills are much better choice

[throwpoaster]

I suggest you implement an MCP server before adopting this as a firm technical opinion.

[lazyasciiart]

The opinion that more companies creating APIs is good?

[throwpoaster]

No, the technical opinion. MCP is an interesting integration pattern. Calling it "more APIs" is like calling software "just some code". It's true, not interesting.

[julianlam]

> The reason MCP isn't dead is because practically ~every company on the planet is building an MCP server. I know this because we interact with all of them.

Wow if that's not an echo-chamber comment I don't know what is.

[jurgenburgen]

> Wow if that's not an echo-chamber comment I don't know what is.

Wouldn’t expect anything less from someone working as a manager at OpenAI. I don’t think their org culture is survivable if you’re not 200% all-in on LLMs eating the universe.

[jrflowers]

Trying to imagine my boss telling me that I’ve talked to everyone on earth in a convincing way and can’t stop laughing

Like imagine somebody saying “you’re the most handsomest boy in the world” and thinking “Shit, nobody would just make something like that up.”

[rvz]

The comment just reads to me as:

"Person working on MCP tools says MCP is not dead."

[robot_jesus]

Or, "Person who sells tokens responds to article claiming MCP spends too many tokens says please keep buying tokens."

[sevenzero]

Yup agreed, this reads like massive coping...

[tvink]

Yeah this is copium. Everyone is sprinting to adopt everything that is useful, and it just haven't happened with MCP.

Also, what's the hold up? If they all are building one, presumably using AI, shouldn't they all be done already?

[shabgzer]

Resist the urge to nitpick and accept that the poster simply means "a large number of high-profile companies".

[OtherShrezzing]

It’s definitely an outlandish statement to make. There’s 200-400mn companies in the world on a conservative estimate. I assume the poster means something like “all listed companies”.

[jimbokun]

You failed to describe what value the MCP protocol provides.

If all of these companies spent equivalent time writing a CLI for agents to consume as they spend on MCP servers, would they be any worse off in terms of agents being able to interact with their products?

[fnordpiglet]

One advantage is the MCP advertises itself to the agent with its schema and api shape. Unless your CLI is in the corpus with lots of examples the agent has to learn every time. Skills help a little bit but I find the recall on skills pretty low. However I also find codex will reliably use MCPs advertised while Claude always reaches for tools like Bash() likely because it’s aligned so heavily on its own tools and is very hard to get to use an MCP if literally any Bash() approach is possible, including breaking glass to find creds, even when an MCP is clearly advertised in CLAUDE.md, skills, and explicit user instruction. I find it fascinating that Anthropic makes a product that seems to be really poor at following instructions and OpenAI seems to generally follow guard rails.

[ex-aws-dude]

Isn’t that basically just a —help flag though?

Still easily doable with CLI

[0123456789ABCDE]

> Isn’t that basically just a --help flag though?

mostly, but not enough — i have been experimenting with this, and what i found to help is:

  - help menu is the default, not an error message to stderr. ex: `gh pr` and `gh pr --help` are byte identical
  - if the subcommand, or the options passed are wrong, present suggestions. ex: `gh gists` -> "Did you meant this? gist"
  - the help menu should provide examples like `tldr`. sprites.dev tool `sprite` does this well, `gh` is in the training set so theirs is shorter
  - can you append the docs url to the bottom of the help menu?
  - you're serving llms.txt, right?

[troupo]

> One advantage is the MCP advertises itself to the agent with its schema and api shape.

So, OpenAPI/Swagger for REST? GraphQL? SOAP schemas? All of these (and more) exist. What does MCP add that these don't have?

[fnordpiglet]

I’m confused by the question. You listed a bunch of standards over time, all of which reach to solve a similar problem (you left off XDR/RPC, CORBA, and about 10000 others), and unironically ask why is there a n+1 standard? Are you genuinely confused?

https://xkcd.com/927

[troupo]

You wouldn't be confused if you actually tried to understand what I was saying. .

Your claim was: "One advantage is the MCP advertises itself to the agent with its schema and api shape".

This "advantage" has already existed, as you correctly pointed out, in about 10000 other standards and protocols. MCP is not special, and doesnmt have some advantage. It's a vibe-coded hype-driven n+1 standard that is busy ignoring anything that came before it, for no reason.

[jimbokun]

Then give the CLI a man page.

[dnautics]

i mean you can surface an openapi schema too.

[CharlieDigital]

MCP is more than is more than tools. Tools is one of three major features: prompts[0] and resources[1] being the other two.

Prompts are effectively "server delivered skills" which are are quite powerful because it solves a distribution and synchronization problem. It also allows server materialization and dynamic construction of skills.

MCP also has a few other under utilized mechanisms: elicitation[2] on the client side and completions on the server side[3]. It is an API of sorts, but specialized for agent harness <-> server interactions.

[0] https://modelcontextprotocol.info/docs/concepts/prompts/

[1] https://modelcontextprotocol.info/docs/concepts/resources/

[2] https://modelcontextprotocol.io/specification/2025-11-25/cli...

[3] https://modelcontextprotocol.io/specification/2025-11-25/ser...

[nostrebored]

this is bad. Anyone doing any cursory work with agents will realize how brittle <<just managing your own prompts>> can be. Adding an extra layer of indirection isn’t helpful, it’s a gigantic hindrance that gives you a moving eval target. Being an MCP developer means you have a moving target of model optimization. It is a win for nobody.

The tools we need to solve this problem exist and they are boring. Types, jsonschema, openapi, all of it is a better integration point than MCP.

[usrusr]

It keeps people employed, yes?

And with people I guess I might actually mean not people but tokens everybody has to spend on keeping their environment self-adapting...

[fnordpiglet]

For those of us who lived this wild arc from the advent of normative protocols widely adopted, standards, open source, and the variety of “paradigm shifts” over the last several decades it’s not surprising to see a profusion of attempts at standards with poor adherence across tooling, and fits and starts along the way. Those using the modern web, but not old enough to have built it, which has largely calmed down, probably look about them at the relative order of things and sigh in contentment then squint at the AI agent standards and huff at the confusion. Those few other gray heads who went through the various fits and starts look about at what’s going and recognize it quite clearly as “this is how things look at the beginning.”

We are really only a few years into all this stuff, and the real taking it very seriously has only been about 8 months. Web standards took 8 years to be barely usable. That was built on 30 years of internet standards that were barely usable.

Relax padwan and enjoy the ride.

[CharlieDigital]

That's because you're not thinking about how teams and enterprises work. You're thinking about how individuals work.

An enterprise has 20 services that each have a secret key (Datadog, Snowflake, etc). I want my team to have access to those services via coding agents. How do I guard those keys from both developer and agent? Put it behind MCP; neither dev nor agent ever sees the key. If developer leaves, revoke one OAuth cred.

I want to add access to internal and external services from one entry point without developers across hundred of teams having to sync or update their workspace. Put it behind one MCP interface.

I have enterprise skills and resources that I want to standardize and deliver to every team. But it has to vary in 10-15% of the skill body. Think same heuristics, but different specifics. MCP delivered prompts and resources can do that by dynamically templating them.

I want telemetry and data on how skills and tools are being used and I want to capture them using standard tooling like OTEL regardless of agent harness because I don't want to have to rebuild a solution on hooks if I charge vendors. MCP does that because I can capture all of the telemetry there.

    > jsonschema, openapi, all of it is a better integration point than MCP.

MCP is schema + interaction model. If MCP were built on OpenAPI, it would still need another layer to describe interaction. It is effectively JSON schema + interaction flow + standard surface area.

Your argument feels like asking why do we need OAuth and OIDC when we already have usernames and passwords. They solve different problems. A simple service can just use a secret key or username + password. But more complex enterprise scenarios need the structure and flow of OAuth, SAML, and SCIM.

[dnautics]

can these not be surfaced in an api and accessed using curl, with instructions in a SKILLS.md?

[CharlieDigital]

Sure. It would be great if they were portable as well.

To make them interoperable so that the APIs have similar surface areas and can just be used without special skills, we could even come up with a standard API surface area and create a...protocol.

If you squint, the SKILL.md and the context that it takes up is literally the same thing as the MCP server and tool description. They are literally the same thing except one is server delivered and one is not.

MCP is "Let's use Google Sheets and have a server-managed experience". Everyone sees the same thing on the server in real time.

Skills is "Let me download the Excel and send it back to you". Why? How is this better? Every time I update the Excel, I have to add a `.2026.final.final2.xlsx` and everyone updates their copy...how is this the superior experience?

[827a]

Yes, in the same way a programming language would be worse off if they focused all of their effort on building an implementation instead of a language specification.

You could literally, deterministically, zero AI, code-gen a CLI from an MCP specification, just like you can with an OpenAPI specification. I'm sure tools exist that do this. So if you want a CLI, there it is.

But the problem with a CLI is that it requires a shell environment, and not everywhere you may want to run an agent should or can have access to a shell. MCP enables the harness to tightly control that access. MCP allows the user to easily allowlist/denylist specific tools, or categorize tools into "ask me every time" versus "don't ask me just do it". Doing any of this with a CLI is really hard because CLIs are all very different; yes, AIs can easily learn how to use them, but that might be exactly what you don't want, hey AI don't issue that aws ec2 delete-instance command ah crap there it goes I wish I could have just denylisted its access to that tool.

[_flux]

Not having access to the shell is a big hindrance. I have my agent access Gitlab and Jira via CLI tools and in so many cases jq or python is used to manipulate or combine the data into a more useful format, making use of pipes and temporary files. You can of course limit what an agent can do, most easily by not giving it access to things it shouldn't do. I suppose there are no existing easy gateway methods to grant fine-grained OS-level permissions to add such things back, except perhaps `sudo` and similar tools.

MCPs are impossible to combine this way: everything you feed or get from them goes though the model and consumes tokens.

[827a]

You’re right that having a shell is the ultimate tool, and an agent with a shell seems to perform better than one without one. But, making shells safe is really damn hard; e.g. in the context of running an agent on behalf of a SaaS customer in your AWS environment. For now some companies are accepting the performance/security tradeoff of disabling the shell and focusing on specialized tools.

Remember: jq can always be a tool (MCP or otherwise). In this way you can allowlist specific CLI programs and give them to the agent via tools. Making python a tool is more difficult; that would have all of the same RCE injection issues that the shell would have.

There are isolation stacks that help make “running an agent with a shell on behalf of a customer in the cloud” possible. It’s just very risky. There’s a thousand attack vectors, and to a very real degree companies that are getting to this point are re-thinking their cloud infrastructure and architecture from first principals.

[_flux]

jq cannot be just an MCP, unless it's acceptable that yuo pass all data through the context. If that's not acceptable and you want to have it as tool, then you need some other way to handle the data.

I think the basic solution to this is to have a "static shell" but with modern tools for the agents, not actually executing other binaries. It could have things like jq, curl, piping and redirection to/from session files. Maybe even Python if it can be made safe. If not, then there are a lot of languages can be.

[yencabulator]

> Maybe even Python if it can be made safe.

https://github.com/pydantic/monty

[827a]

jq can 100% be an MCP tool. Remember: Agent tools do not have to involve a network boundary. They can be natively implemented inside the agent harness, and/or they can be provided via a local MCP server. The point of making it a tool is to tightly allowlist what the agent is capable of executing; it can only execute jq, not any shell program, and moreover it isn't allowed to do things like redirection, pipes, etc; all it has at its disposal is `jq (filters) (data)`.

People seem to think that MCP exists to give agents more capability. That could not be further from the truth, which is actually the opposite: MCP exists to take capability away from agents. It exists to control them.

[ithkuil]

Can an MCP provide prompts for your model to download and use CLIs (and ensure they have the right versions of those tools) in such a way that the data flows through the client side tools?

The more I read this thread the more I'm convinced that the main value of MCP is to provide a server managed release process. This is the same advantage that SaaS has over client side apps.

However MCPs couples with a client willing to run tools locally can provide the best of both worlds

[_flux]

As far as I know, the only way an MCP can provide you data that doesn't go into the context is by providing URLs to the data, and then the model uses e.g. curl to access that data for data manipulation purposes. You could also return result set ids and provide accessors to such data, but ultimately you'd need to provide powerful accessors to that result set to avoid polluting context. Things like shell with all its power already provides.

It seems like there's little point in MCP in that case. Maybe more point if it was a standard mechanism for MCP to provide additional data, in a completely compatible fashion with all other tools? You could perhaps even pass such URLs to other MCPs. You could have an MCP for jq for doing stream processing. Starts to look a lot like a shell, though.

Seems like MCPs could also be extended to store auxiliary data to your memory (or filesystem..), and then an additional extension to provide that kind of data as auxiliary data in the calls to MCP.

Well, even as is, MCP still provides a standard method of using OAuth for accessing such services. And you must use MCP if you wish to add something to the ChatGPT.com web service, so it's easy to see why OpenAI folks are seeing companies going that way.

[dorgo]

>to manipulate or combine the data into a more useful format

why not build this directly into MCPs?

[_flux]

Hmm, indeed, so maybe I could have all this as an MCP, so I can just easily pass any imaginable data manipulation inside it, and then also have it support calling other MCPs, all inside that one MCP, to avoid filling context with intermediate data..

Sounds a lot like a shell to me.

[jimbokun]

Go idea. We will call this new MCP “bash”. It will allow you to stream the output of one command to the input of another incrementally as the data is generated.

[fmbb]

You prevent the LLM from deleting your instances by not granting its AWS user that permission. Whatever tool you let it use to talk to AWS is irrelevant.

[jimbokun]

So the permissions model h is a the main advantage MCP has over CLIs?

[usrusr]

Is that so surprising? I thought that was a given. And as soon as remote resources are involved, the old "it's in a docker" peace of mind does not apply.

[eddythompson80]

Not a fan of MCPs for my personal use, but I still think the value for companies is obvious. The first value for their downstream (OpenAI, Anthropic, etc) is REST call vs arbitrary code execution. You only need to "trust" the MCP client implementation, not a thousand different CLIs. Also being a standard HTTP endpoint, a lot of logic can be offloaded to proxies and such.

The second value is more about how business works. There is no chance you can convince someone at WalMart to fund and release a `wmctl` that allows you to search and buy products. Now try to convince your regional Pizza chain to release a CLI too. WalMart and such are incentivized however to create "Whatever OpenAI and Anthropic integrate with". Shopify can create an MCP for every shop and allow the shop owner to customize it. Creating a CLI per shop makes no sense. OpenAI and Anthropic prefer MCPs because of the first benefit. So it works out for all parties involved.

[wren6991]

> The first value for their downstream (OpenAI, Anthropic, etc) is REST call vs arbitrary code execution.

Is this an advantage? Phrased differently, every MCP that could have been a CLI call is a new opportunity for sandbox escape.

[eddythompson80]

I don’t follow. It’s the other way around. Would you rather run an arbitrary binary blob (aka: a random cli) or `curl`?

Edit: Maybe to clarify, I’m talking about remote MCP. Local MCP is obviously nonsensical. Remote MCP is very much thriving aggressively.

[wren6991]

If the random blob is running inside of a real sandbox (Landlock/Bubblewrap, VM, ...Docker) then I would take the blob, because I can reason about its capabilities without inspecting its internals. The LLM can run curl as much as it wants if I've `unshare()`d its network access. MCP is an instant obligatory sandbox escape unless I also manage to deploy all the MCP servers inside the sandbox.

And yes, sorry, I was talking about local MCP. I should have made that clear. I do see people using local MCP quite a bit (Ghidra MCP, Playwright MCP, etc), but maybe this is more of a hobbyist thing.

[cle]

The security model and runtime requirements are completely different between making an HTTP request and executing arbitrary code.

They have different tradeoffs.

[lostmsu]

You nailed it! There are established tools that handle the security model. MCP is the 5th leg.

[hobofan]

Yes they would be.

MCP servers on the side of the consuming organizations fit into the existing IT landscape, with centralized safeguard on who can access what a lot better and are easier to administer than letting their employees run arbitrary agents against arbitrary sources and destinations and cause chaos.

[0x696C6961]

I have a couple MCP servers connected to my Claude web & mobile clients. How would your clis work there?

[varenc]

The value is that many companies like building MCP servers much more than CLIs. For whatever reason.

Here's some companies that offer MCP servers but don't seem to offer an equally featured CLI:

   - Asana
   - Square
   - Linear
   - Dropbox 
   - Canva
   - Slack (sorta)
   - Figma (sorta)

and many more that offer both, but support their MCP more.

Should they all be offering CLI tools? IMHO, yes absolutely. But an MCP server gets much more interest. I'd rather encourage them to keep improving and supporting their MCP services than telling them to drop it for a CLI.

There's lots of things like this in technology where you end up stuck with the first thing because its popularity perpetuates itself. The QWERTY keyboard I'm typing this on is a prime example. x86 is another one.

[didibus]

A CLI needs to work on windows, mac, linux, android, iOS, etc. And it still needs some backend APIs to call. So creating one is a lot more work than just making an MCP.

[PaulHoule]

That kind of code is easily portable in C or Rust or Go or Java or Python so long as it is a CLI and not GUI.

[oliculipolicula]

Again, tangential, relevant only in that CLI "portability coolness" captures only some of the meaningfulness

Having slept on the poorly made point I was trying to stick. I'm aware its still all tell no show )-:

  A comment worthy of hacker news highlights, Amish-made, fully earnest!

Would appeal to people with money, all manner of handlers, enbies born to embrace struggle, not to mention portability porn addicts. All things to all people but without the messianic contingent

  An Amish who might well have built a Space Lasers Platform  at Bell Labs!

Should perhaps be the character to learn how to play. This same Amish character would only use CLIs, on a wooden nonelectronic keyboard

I credit the obvious (to you) people here (incl you again) for this concept of an idea. Molon labe

Update: backrooms is getting serious traction in Indonesia. Ask me in a year if it was only meta-interest

[didibus]

The language barely matters, the issue is packaging, distribution, platform permissions, pushing updates, keeping client/server versions in sync, shell support, etc.

Where-as if you just expose HTTP endpoints, all that doesn't matter, you just need cURL or any app, like the chatGPT mobile app, can just call into your endpoint.

[fooster]

The mcp support gets more support because there is no cli.

[windexh8er]

This is a classic PM take IMO, no disrespect.

"Everyone is building this!"

Except... Few are actually using it. So what, exactly, is the value in MCP?

Especially that there are simple ways for anyone to spin their own MCP based on standards like OAS. I talk to dozens of new clients in a given week. Our product should attract users who want MCP. And in the last month only one conversation actively asked us if we had an MCP server. Surprised, I asked about use case and the response was as I'd expect: "No specific use case, we're just playing around with it". Seems to be pretty standard for AI conversations these days.

[hackrmn]

The point is that MCP solves a problem that doesn't _really_ exist. While consuming context, which is still at a premium. Claiming that services wouldn't be accessible to agents without MCP is at best misleading -- they certainly do [have access] through exactly what article sheds light on -- command-line tools, including but not limited to, input and output of said tool(s). Also, from a purely technical standpoint, MCP is "non-compositional" compared to command-line tools, and those who don't value composition are IMO doomed to discover so at their own peril, sooner or later.

And to be blunt, a) you're investment bias'ed and b) whether you're selling the product (MCP) to a gazillion companies doesn't exactly disprove a).

Just look at Microsoft -- they've buried more technology than most, and there's little correlation between usefulness and how deeply buried it is, and some would claim that the correlation is _inverse_. Organisational factors are what drive them, just as I suspect they are now driving OpenAI's insistence on MCP. I understand it's hard to see that from inside.

[CharlieDigital]

It would be really, really great if Codex could support MCP Prompts[0]

This would allow us to deliver standard prompts across the team without having to sync manually or with scripts; keep everyone up to date. Even allow per-user customization of "skills" via server rendering of the prompts.

AFAIK, Codex is the only major harness to not support this.

[0] https://github.com/openai/codex/issues/5059#issuecomment-453...

[alexwwang]

I agree. Mcp might be useless in a personal scenario but it absolutely plays a role of service infrastructure in organizations. It is another form of api for those abilities that are not wrapped with rest api yet. But when they are wrapped in mcp, it seems not necessary to wrap them into rest api or cli again in near future. So these mcp services survive. The only thing matters is how to import these mcp services into agent context on demand or say by the gradual disclosure principle.

[jimbokun]

Unless you also want humans to also interact with your tools.

That’s covered in the article: a human can modify the commands generated by the agent, or vice versa, to debug problems or transfer knowledge.

[alexwwang]

This, IMO, is another scenario. MCP is designed and played as a part of the automatic tool chains. These are two different types of needs. But in the case you mentioned, when some parts of the work should be automated, it’s also possible to utilize mcp there.

[btbuildem]

> practically ~every company on the planet is building an MCP server

That's just because no one knows what they're doing and everyone is trying to copy everyone else. It's a giant mud hut made of shit.

MCP will go away, and something much simpler will play the same role.

[delusional]

> Maybe we will turn every MCP server into a CLI under the hood. Maybe we'll use code mode. Maybe we'll implement tool search.

Its absolutely hilarious to me how tech people keep imagining that "this time it will be different".

This has been done 100 times before, it's COM, it's the remote Java object marketplace, it's the semantic web.

You are imaging a world where businesses are OK being marginalized into a nameless, faceless api provider with no control over their product. This will never happen. You might get a couple of years while they chase investment frenzy, but it will fragment. They will lock you out of their services. They will interact directly with their customers.

[jrflowers]

> practically ~every company on the planet is building an MCP server

I work at Taco Bell. Every company on earth is working on Doritos Locos Tacos. I know this because I interact with every company on the planet, and they all tell me that Doritos Locos is in their development pipeline. When I see all of these “not everybody eats or wants Doritos Locos” posts I know that they are wrong because the appeal of them is universal, especially when paired with Baja Blast, mankind’s foremost favorite fluid

[Eridrus]

You should probably consider that your perspective is also biased and you see all the companies that are in esting.

IME, MCP has often lagged APIs in terms of complete ess, so as a user, if there was an API, I would be better off using that because Codex is already so good at calling APIs.

Now, the API story sucks for non-coders, but I'm not really bullish on MCP for dev tools atm.

[Aldipower]

Off-topic question: Where is this an "App Store", as this is basically just a curated list off apps? I wouldn't exactly call it a "store". I have an approved ChatGPT App myself, but those do not surface anyway on the chatgpt.com domain. So, this isn't a "store", but a "curated directory". Calling this a store is misleading to a lot of us developers as you can see in the openai forums on this topic, where you find a lot of confusion around this. People put a lot of energy into developing a ChatGPT App, just to find out, they are completely on their own afterwards.

[yepyoukno]

What is so very strange is that MCP is what we have always wanted, for ourselves!

Haven’t we devs always dreamt of a common interface to query and introspect foreign APIs? Aren’t we lucky we stumbled into an “AI” that is founded upon human language and not some incomprehensible machine code? It seems to me LLMs only made the need for such a universality attractive. Such as so many circumstances where we will do things for our progeny which we would not (yet should have) done for ourselves !

I’ve felt the same thing about skills files, the first things juniors or onboarders should read to explicitly understand their own jobs!

[mikecwang]

So because people are doing it, it's the right thing to keep? There is a long way to go before we know the shape of the real solution. Don't let things like MCP slow down the exploration

[troupo]

> All of those are just implementation details to the much more important point: our AI agents are getting access to services they otherwise would never have had access to.

As in: if your models and agents were as good as you claim them to be, we wouldn't need to re-implement half if our tools and a significant chunk of the web to conform to this vibe designed protocol.

In 99% of cases your AI agents already have all the access. They are just too stupid to do so.

[croes]

> The reason MCP isn't dead is because practically ~every company on the planet is building an MCP server.

Didn’t ~every company also jump on blockchain and NFTs?

[zimbatm]

Another aspect is access control.

CLIs live in the same namespace as the agent, so any secrets the CLI needs access to, the agent can also exfiltrate. And access control is lightly gated by the agent's tool call policy.

For an enterprise-level deployment, it becomes quickly desirable to have a centralized MCP backbone, on which each MCP is attached to. A place you can attach policies to, log activity, and reason about access control.

[delusional]

To the extent this is true, and it isn't with setuid binaries, it's a limitation of operating system apis.

[listless]

Oh man - hearing that we’re building MCP’s where there is no CLI makes me super nervous.

It’s one thing to dupe the functionality of your CLI for better agent integration. It’s another to make it the sole method of interface locking everyone into a spec that we may decide we can do better at some point. Then we gotta pay off all the MCP debt and it will be cheaper to just not.

[bshaughn]

The number one value of MCP's is that it forced everyone align on an API protocol, but the protocol itself has room for improvement.

[bmitc]

MCP is not an answer to the lack of a CLI or API.

[mempko]

Have you heard of the Ask Protocol? (https://abject.world/ask-protocol/).

I might be biased because I came up with it, but we are over complicating these systems. There is a simpler way, and it appears to work well since I built a system using it to test the idea.

[hobofan]

Main points that came to my mind:

- I think the comparison to TCP/DNS/BGP is the more apt one compared to MCP/A2A

- Those protocols negotiate capabilities and exchange information about themselves, but not in a self-serving manner of just talking about themselves, but with the goal of ultimately transporting data for a higher layer. Ask Protocol lacks that.

- Objects don't exist in a vacuum, but in a context. As the objects will only know about themselves they will always be limited in how to describe themselves best. An LLM that lives on the outside and just gets a static description of an object will be in a much better description to answer an "ask" query.

- Given that the existing agent protocols you are putting it in a context in already come with "description" fields and the like, the protocol seems too little of a value add to actually target. e.g. there is no benefit for a MCP server to conform to the prescribed manifest rather than implementing a freeform "ask" tool.

- If you want to actually bring the point across that it "occupies a different position" than transport/agent protocols, don't put it into a comparison matrix where you force it into the same schema

- ("Open Source" doesn't count as governance)

[mempko]

You made some good points, let me address them.

The reason comparing to TCP, DNS doesn't make sense is this doesn't replace those at all. The reason I compared against other agent frameworks and things like MCP is because that's the common question people have.

You are right objects don't exist in a vacuum but you are wrong an object that just exposes a description and an LLM reading it from the outside does better. Think about object oriented programming, objects expose and interface but don't reveal all of their internals. Calling the Ask handler could change internal state. Maybe response depends on what object is asking. Maybe the Ask handler might want to call the callers Ask handler too. You can't do that by just exposing a description.

You said the goal is to ultimately transport data to a higher layer. That's not the goal. You are thinking too hierarchical. The relationships between objects is dynamic and the concept of a higher layer makes no sense here since the point is to get rid of the hierarchical nature current agent protocols have.

Keep in mind I built a working system to test the concept. You can download and try it.

[xeiotos]

On browser/computer use: I wish I could try them. But since OpenAI is going down the Apple path of cherry-picking random features to block in the EEA, without much explanation or timeline as to when they will be available (or even why they are blocked in the first place), I am unsure if I will be able to in this lifetime.

[mettamage]

Based on the corporate I work, MCP is definitely not that. Not sure if it's useful, I just joined. We'll see.

[robotswantdata]

I agree, codex app’s computer use agent feels sci-fi. Closest we’ve seen yet of a general purpose virtual worker.

[mycall]

Wouldn't it be easier if MCP supported vector embeddings as input/output? It would shift its integration from a Broker Agent to a Deterministic Semantic Router. That by itself would prevent context bloat.

[gobdovan]

Remember when practically ~every company on the planet was building an NFT collection?

[epsteingpt]

Agree. But Word of caution: MCP will become the 'company wiki' of the 2020s unless you enable monetization and distribution.

Right now you have to create an MCP but v1s are always easier to maintain than v10.

We're speed running a trap.

[baq]

MCP vs CLI is the same discussion as between a GUI app and a web app: it's all about the distribution. There is approximately no difference in functionality except whether you're hitting a dedicated service or running a local tool which connects to a dedicated service.

With saas is turned out that distribution to a browser solves a pretty major pain point and I expect MCPs to be treated the same. Can you trivially replace an MCP server with a CLI tool which accepts a token? Yes - but why do that to yourself when you can hit the endpoint directly?

[zuzululu]

great post

I find a lot of HN content seems to be doomer farming

i was a big skeptic of MCPs

now i build em

[geysersam]

What advantage did you find in MCP vs a traditional API?

[brabel]

No OP, but MCP really is just a logical next step once you've got an API. The API is the "low level" protocol, the MCP is the high level one, suited perfectly to an LLM that can call tools (since MCP essentially turns an API into a LLM tool).

With just an API, the agent needs to "read your API docs" to know how to call it (that can be an OpenAPI spec or even just text).

With MCP, the agent sees a bunch of tools it can call, and they've been trained to call tools so they nail it.

One more very important factor is authorization, which no one seems to mention in these discussions. CLIs were made for humans and use primitive mechanisms for authorization: either an API key you hardcode in your environment, or they literally run a background HTTP Server to get a callback OAuth call to receive a token from a browser authentication flow. Incredible that people are happy with that, appparently. With the MCP Authorization spec, you solve authorization across multiple MCP servers in the same standardized way, the LLM client you use just need to know the protocol, not how to login for every single MCP server.

Very importantly, if the MCP client does the authorization, the MCP provider has auditability: is this a call from a human or from a LLM? That's important in Enterprise! People think it's ok to let an LLM act on behalf of the human but that will eventually bite a lot of people. Did the LLM just try to hack the API while you were mindlessly clicking "yes" when it asked if you wanted to let it do something? Tough luck, there's no way to distinguish an LLM making a mistake from a human maliciously running some attack.

And as the post mentions, there's also more benefits like being able to "elicit" user input (not just request/response cycles) and the ability to have documentation and assets (skills also have this though).

[troupo]

This is a great example of the AI-hype-induced reply.

> to an LLM that can call tools (since MCP essentially turns an API into a LLM tool).

"Tools" is literally an API call

> With MCP, the agent sees a bunch of tools it can call,

Yes, the agent first calls a specific API that returns the schema for that particular server. It's literally the same.

> One more very important factor is authorization, which no one seems to mention in these discussions.

Yes, API calls to services are often gated behind auth. OAuth that MCP uses is from 2006, and its version 2 is from 2012. What do you think it was created for?

> the MCP provider has auditability: is this a call from a human or from a LLM? That's important in Enterprise

We had "differentiate these two accounts and audit log their activity" probably since the 1950s

> there's also more benefits like being able to "elicit" user input

Two-way communication is also a thing since the 1950s, probably.

[brabel]

If you think tool call and letting the LLM call an API via curl are the same thing, you haven’t a clue how LLMs work and honestly shouldn’t be commenting on the topic at all.

[troupo]

A "tool call" is literally a JSON-RPC call with a predefined schema.

You'd know that if you actually did any of the following:

- read the specification

- implemented an MCP server

- observed communication between client and server

- had any experience beyond what LLMs tell you

[zuzululu]

sometimes I remind myself HN is reddit now except when Dang is awake

[meszmate]

A lot of companies will never build a great CLI, and many will not prioritize a clean public API unless there is obvious demand.

[sd9]

> I run the team at OpenAI that's responsible for the ChatGPT App Store, Codex plugins, and all things MCP.

> The reason MCP isn't dead is because practically ~every company on the planet is building an MCP server.

You have drunk the kool aid. No shot ~every company is building an MCP server.

[zingar]

It was obvious hyperbole. I can believe that there are many companies where the boss heard about MCP and put it on a roadmap before anthropic decided that it wasn’t a good idea… and now the team is implementing this in the name of “we need to do some AI”

[jngiam1]

I totally agree, we’ve been working with enterprises and MCP is the defacto way they are using agents with data.

[docheinestages]

Agreed. I think MCP should stay abstract in the sense tool-calling is. JSON-RPC could be one way to do it.

[bredren]

Isn’t this just a lagging indicator of popularity at the early liftoff of cli ai?

A sign of weariness in the rapid evolution of tooling, where people got off the train a stop too early?

A confusing overloaded acronym (cli) and term (skill) lacking the marketability / easy mind share of a unique acronym?

These all fail to establish a hearty reason to be.

The walking dead are still dead.

[noworriesnate]

I think graphql backed by mcp is the technically best solution. Graphql allows an agent to select which fields it wants in context. Graphql is easy to generate clis for / easy to generate libraries for (if we want llms to generate scripts that call tools).

[zingar]

GraphQL also allows the LLM to DOS your service

[bluegatty]

It's not 'who is building' but 'who is using' that's the concern.

AI is a bandwagon tech, a lot of people will 'build because others are' adhering to an ostensible standard.

Most of the people that I know are moving away from MCP in favour of skills where the advantage of MCP goes away if the REST API is clear enough.

Also - I'm sorry to say but MCP management on Codex (and Claude) is just really bad. Everything from discovery, to management, to context window, to documentation - it feels unfinished as a 'feature' even if the protocol is supposed to be narrow.

1) I have a big popup and yellow warning every time a window is opened or a sub agent is launched warning me that 'SkySomething Computer Use' does not work. I had to Google to find out that has something to do with Codex MCP. So already the externalizations of problems, resolutions ... not very well done.

I'm not even sure what to do - and I'm honestly not interested in 'fixing' something I didn't cause, I'm not sure of, and don't want to deal with.

2) Just listing the current MCPs, knowing really what the are for (clearly, concisely) is hard.

This is what you get if you type /mcp in Codex:

/mcp

  MCP Tools

  • No MCP tools available.

  • codex_apps
    • Auth: Bearer token
    • Tools: (none)

  • computer-use
    • Auth: Unsupported
    • Tools: (none)

What's that supposed to mean? What is 'codex_apps'?

As presented - it resolves to 'nonsense gibberish'. Those are things that I did not even install.

Do you expect people magically know what 'codex_apps' is?

Here is what 'AGI!' Codex 5.5 answered when I asked about 'codex_apps' is:

====

" codex_apps appears to be Codex’s own internal cache/tooling area, not part of J1 (my project).

"I only found it under .codex, e.g.:"

" I did not find it referenced by the J1 source. So unless you saw it somewhere specific, treat it as Codex runtime metadata for app/tool integration, not project code."

====

So even Codex itself has no idea what it's own MCP tools are, and after a full '1 minute of thinking' on 'xhigh' it responded with nonsense.

This whole experience fundamentally deflates my perception of AU, OpenAI, Codex and MCP.

This is supposed to be the 'future' but it feels like 1982 dialup.

This is where 'traditional UX' really starts to show it's value obviously, but you really need to consider enhancing this experience, possibly with some traditional ux mechanisms.

3) Knowing the 'state' of the MCP is totally opaque. Is the 'MCP server' running? Can I restart it? That might be outside the scope of 'Codex' but you're offering the product so all of the underlying stuff is essentially 'your responsibility' as well at least from a UX perspective. Why isn't the 'state' of the MCP listed.

4) How can I not just easily enable/disable individual MCPs so they don't chew up context?

5) How can I not discover MCPs from codex itself, so that I can find solutions to problems? MCPs are all a bit different, and awkward to install and manage. Like with VS Code, we can 'discover plugins'. Even from the Web we can search and discover plugins.

While I realize that most of this rant is oriented around MCP tooling management, and not the standard, I do feel that these issues are 'fundamentally at the crux' of the situation.

Our team has moved away from MCP into Skills - and after doing so, it's hard to see why MCP is going to be valuable - other than plausibly as defining some 'jon calling conventions'.

There's a lot of obvious things to improve, please do that.

[jimbokun]

OpenAI should hire you.

[bluegatty]

This is not even 'basic product design' - it's just 'product common sense'.

That the 'smartest people in the world' have $100 Billion and are are totally scattered on so many issues completely blows my mind but it speaks to how systems are organized.

They don't need to hire anyone for this stuff, they need to have some basic product discipline and prioritize it, that's all.

If they don't do that, all the money in the world and all the best product people wouldn't be able to help.

I totally respect that 'Codex is young' - but it's been kind of a year now. That's a long time - and AI is supposed to 'accelerate time scales' and make people 'super productive' remember?

I hope they improve.

[imp0cat]

Got any tips for building a MCP over CLI app?

[goalieca]

What do you think about MCP security being limited as it is. Frankly, it seems mathematically impossible.

[neya]

Just because everyone builds it doesn't mean it will take off. Case in point: All the cloud serverless BS. Everyone in the industry are now switching back from server less because the math didn't work out.

I think it's just a fad and eventually you'll need to address the math no matter how much you sugar coat it - the 3x slower metric, eating of context window is all beneficial for LLM companies but not for the end user.

Ok, how many AI tools do you even use from 3 years ago? Funnily enough, I stopped paying for my chatGPT subscription a year ago.

[the_gipsy]

Hank Hill: "Excuse me, are y'all with the cult?"

Jane #2: "We're not a cult. We're an organization that promotes love and—"

Hank Hill: "Yeah, this is it."

[coderbants]

I get the debate in this thread but this is IMHO the detail that matters:

"Many of these companies don't even have an external API! And yet, they're all building MCP servers."

Whether or not MCP is a temporary means to an end or a more permanent standard is kind of missing the point that the overall callable API surface is expanding rapidly. How it's called by the agent is an implementation detail.

[qsxfthnkp2322]

Mcp is not dead says the guy who gets paid half a million to work on it.

News at 11.

[j45]

Maybe MCP doesn't have to be the entire or only solution, or judged as such, and another tool in the toolkit.

[ProAm]

No offense but you are paid to say these things. Your paycheck depends on it [1]

[1] “It is difficult to get a man to understand something, when his salary depends on his not understanding it.” ― Upton Sinclair, I, Candidate for Governor: And How I Got Licked

[tulio_ribeiro]

What’s up with case 09058169? Seems like a 5 minute fix

[MatthewPhillips]

Please keep in mind that CLIs do not run on mobile and never will. This is the elephant in the room that nearly everypne seems to be ignoring. This "debate" is built around the assumption that AI is only for at-your-desk work. It's obviously not. Having the ability to mix/match the services you use for everything in your life, whether that's email or social networks or managing your book collection, is going to be a normal thing everyone does in the future. It's just not today, because AI companies are almost exclusively focused on the programming use-case (and related desk job stuff).

[mhalle]

CLIs do work on mobile when they are packaged in skills that run in an appropriate VM behind the LLM.

Claude on the web does this. The only issue is controlling network access, which could be fixed by per-skill ACLs.

[MatthewPhillips]

Walk me through how a user installs and then uses these CLIs from their mobile phone.

[mhalle]

Create a skill that has the CLI in the scripts sub-directory. The implementation language depends on the LLM and the VM it uses. Claude includes shell, python, and a bunch of other interpreters in a Linux environment.

A skill's instructions can direct the LLM to call the CLI.

Claude skills can be installed into Claude web from a web browser. Those skills can then run on the Claude app on your phone.

[MatthewPhillips]

Ok, I can see there's a new (to me) Customize section where you can install skills. You have been able to connect MCP servers for quite a while.

The UX here isn't great, but let's assume it can be improved. How would auth work with this alternative method? I want to connect to Puma store and that's done using a skill with a CLI. Can the CLI launch your web browser to do oauth from the skill (on a phone)? And then the credentials are saved where?

Not challenging you, I'm open to alternatives to MCP for sure. But MCP seems way more mature especially for non-programming use-cases.

[falcor84]

> CLIs do not run on mobile and never will

Can you clarify why the never? What's the issue with giving a phone-based AI a sandboxed file system and bash shell?

[MatthewPhillips]

How is the user installing the CLIs? Proprietary app store for each chat app?

[falcor84]

I didn't mean that users would install them. I meant that if mcp and AI agents continue being popular, then Google and Apple could choose to provide apps with cli sandboxes with the proper permissions. It is a big change, but I just didn't understand the "never"; we've had bigger changes.

[MatthewPhillips]

Ok sure, the "never" was a bit strong here. Running CLIs on phones is not a normal thing and not as simple as it is on desktop. Apple prohibits apps from downloading and executing code, so some sort of new Apple-approved thing would be required here. That's a very heavy lift.

Of course anything is possible, I just don't think that people advocating for MCP's death have really thought through these problems, and are mostly focused on the desktop productivity use-cases.