MCP is dead?

https://www.quandri.io/engineering-blog/mcp-is-dead

by nadis • 2 months ago

400 402 2 months ago

is this post old? MCP context poisoning was fixed like months ago

i personally was anti-MCP but they just work better in terms of tool search than a CLI, especially with the idea of tool nudging

JoshGlazebrook• 2 months ago

Update: Since these measurements were taken, Claude Code has rolled out Tool Search with Deferred Loading, which loads MCP tool schemas on-demand and reduces context usage by 85%+. The context bloat described in Problem 1 is largely addressed for users on current Claude Code versions. The performance, debugging, and architectural arguments below still apply.

pretty much

Apocryphon• 2 months ago

Not providing a publishing date is real maddening.

zvoque3• 2 months ago

I've thought that skills and small scripts > MCP for quite a while now, tried out MCP in the early days (official ones, ones i made for scripts i already had), but they always end up using more tool calls/tokens than if i had just written a script + skill for claude.

eikenberry• 2 months ago

MCP seems like what you'd do when you want to encapsulate and share a skill+script in a standard way.

noodletheworld2• 2 months ago

You can share a skill by copy pasting the text file to someone in slack.

Its not that hard.

zvoque3• 2 months ago

personally if i have the need to move a skill/script, etc. to another one of my machines, i'll make a git repo for them (if they aren't already on git)

09074• 2 months ago

I'll kick myself for not remembering, but there was a fantastic article which suggested that MCP works at org level when unified, safe, access to internal utility APIs need to be given to non-technical staff who do use internal agent tools. Codify your workflow(s) via skills and share across instances, anything that needs context aware API access should be mcp...

gk1• 2 months ago

Exactly right. Co’s like Runlayer are growing like wild exactly for this reason. Without a central control plane MCP is a minefield.

09074• 2 months ago

hadn't heard of runlayer, but it does make sense. I'm a huge advocate of skills based on the company/process or project owners perspectives and workflow habits rather than using skills.sh or similar. You will end up cosplaying as someone elses perspective and wonder why you don't understand it..

CharlieDigital5• 2 months ago

This one? https://chrlschn.dev/blog/2026/03/mcp-is-dead-long-live-mcp/

09074• 2 months ago

Yes, exactly that one! thanks

bb882• 2 months ago

So is this in lieu of using permissions to protect apis? Because it seems like API's should have some kind of permission mechanism around them anyway.

09074• 2 months ago

Yes and no -- you can give internal agents access to internal APIs by using rudimentary env var, and org level agentic services tend to offer that kind of permission based access (either roll your own, use an 'enterprise' service, or be knowledgeable that if things go wrong, they'll go very wrong). APIs should, at least from my perspective, always have permission mechanisms. But internal APIs, used by 'internal' agents, have access to those the same way users on the network do, just depends on what flavour of network one is using.

Essentially it's anything that _could_ be on a dashboard, but _might_ be accessed conversationally via an agent.

geysersam5• 2 months ago

But what is the advantage of MCP compared to having the agents access the API directly?

0x000xca0xfe• 2 months ago

Agents are just a stream of text, they cannot access anything. Some kind of interpreter is needed that recognizes special patterns and runs real code.

Do you mean directly == raw shell access on your production server?

tiborsaas• 2 months ago

MPC comes with built in documentation over an API. Thanks to this agents can use it "intuitively".

thenewnewguy• 2 months ago

These AI slop articles about AI are getting especially boring to read.

Problem 1: It Devours the Context Window

Don't harnesses support progressive discovery these days?

Claude (200K).... GPT-4o..........?

every MCP server adds a process layer between the LLM and the underlying API

But a CLI doesn't?

------------------

Measurement: Tool Definition Sizes
MCP Server: Linear, Notion, Slack, Postgres

Oh, so these are the MCP servers that are examples of context bloat we're going to replace! Later in the article:

At Quandri we use all three approaches side by side...
MCP for services without a strong CLI (Slack, Linear, Notion)

kristopolous• 2 months ago

There's a fix for the context which involved an mcp search and execute gateway. Essentially the mcp server queries for desired capabilities, gets search results with execution and requirement details and fires off the actual mcp as subcalls:

https://github.com/day50-dev/mcp-search-and-run

You can call it "rag for mcp". I was pushing it hard a few months ago and nobody seemed to care but I'm all in if the timing has caught up to the tech.

It's nontrivial effort: basically a giant survey of all the mcp servers, running inference over them to figure out how to instrument them, cross referencing to make sure they are the "official" sources (or at least the ones that search engines think are) then using qdrant to do embeddings and reranking and offering it for free.

If people have become interested I'm all in. I'll bring the infra back up. I just don't want to spin my wheels on dead end streets.

The value proposition is solid, the problem is real, this fix works, it's fast, it's free, and people give exactly zero shits. I dunno...

One day I'll figure it out, hopefully...

comrade1234• 2 months ago

So what's this saying? Rather than trust the llm to query external tools via mcp you should handle the external queries yourself? Otherwise the llm wastes a bunch of queries?

speff2• 2 months ago

My mental model for MCPs is that it's like a Swagger/OpenAPI spec for LLMs. Point 2 doesn't make much sense in that context as it's describing MCP as a Swagger endpoint that's unstable.

Chrome/Ghidra MCP does have a tendency of crashing, but I'm not sure why this is. Is my way of thinking of MCP incorrect? If it really is a descriptor of how to talk to another tool, then why do they seem fragile at times? I feel like there's a gap in my knowledge somewhere.

monkpit4• 2 months ago

What is special about MCP to make it any more or less fragile than any other software?

MCP is a combination of a server responding to requests, and a prompt to tell the agent how to format those requests.

dnnddidiej• 2 months ago

I think those are solvable problems. E.g. wrap mcp in skill or seperate forked (non context eating) call to smaller model to ask which mcps are applicable. Iet probably does this. Honestly I have not had issues with MCPs where I felt compelled to debug them.

MCPs are very useful when you don't have a CLI or you do but the MCP can handle auth like a proxy to something (e.g. Splunk). Or just for the USB-C analogy she gave.

bb882• 2 months ago

I was writing MCP servers, now I just write tools for agents to consume. It's often easier to simply write the tool you need and suggest to it to look at the tool to do that thing.

I was also surprised to find out Claude knew how to use the gitlab api with pointing it at the token var in the environment. But for corporations it might make more sense to use a cli to keep the secrets separate from the agent.

didibus12• 2 months ago

now I just write tools for agents to consume

What do you mean? Tool is a pretty generic concept.

willio582• 2 months ago

Using existing CLI directly: No context wasted on tool definitions

Can someone explain this to me? I've seen claude code try to run a not-well-known package and it basically shot in the dark a command, noticed that failed, then ran the help command for the cli tool to get a list of commands and what they do.

How is that different than passing the tools with an MCP? Like how are we saving context?

0xbadcafebee2• 2 months ago

The usual problem is companies write an MCP server with 50 different tools, and each one has a schema, description, etc. Say each tool is 150 tokens, that's 150 * 50, or 7500 tokens, dumped into the beginning of every session. Compared to a text file that gets loaded on demand with command-line tool examples, so you still get close to the same amount of context, but you can control what tool definitions you pull in.

The other thing is the agent gets the entire MCP API response dumped into context as a tool response in JSON, which can be a lot. Compare that to shell commands where agents often `head` or `tail` or `grep` the response (which I kinda hate, but it does save tokens).

It also depends on whether the agent loads them on-demand or not (most modern agents do), and whether your MCP has a ton of tools or not. If your MCP only has 2 tools, and the responses aren't big, it's really not that much context.

The other thing that doesn't get talked about is the non-determinism of shell one-liners. There is a lot more non-determinism in shell tool calls; the AI can mess up commands, options, arguments. It can incorrectly filter output, miss output, miss return status, which results in re-running calls, polluting context, making results worse. Compare that to MCP calls which are more likely to succeed because they have a schema, well-defined errors, etc. Do you want less token use or more reliable results?

The thing is, you don't have to pick a side. I personally use both MCPs and CLIs at different times in different ways. Often I'll have the AI write a small script to do many calls (sometimes with tools, sometimes with libraries) which saves tokens, allows me to review, and is more deterministic.

willio582• 2 months ago

Thanks for the answer! I do see both sides

demorro• 2 months ago

This is also my point of confusion. People in the comments seem to be saying that MCP is necessary due to discoverability, but I fundamentally fail to understand how a protocol can make interfaces discoverable to an LLM in a way that wouldn't also be achieved by making traditional interfaces more discoverable to a human. These things mimic human behaviour after all.

Surely people aren't saying we haven't solved API discoverability by now and need new tech for it.

rgbrenner• 2 months ago

The article has no date on it, but says deferred tool loading is a recent update that occurred after the article was written. Deferred tool loading was added in Nov 2025: https://www.anthropic.com/engineering/advanced-tool-use

So these numbers are at least 7 months out of date. Why is this being posted now?

wild_egg• 2 months ago

Deferred tool loading is not part of MCP. It's a Claude API special parameter that most other LLM APIs do not support.

red_hare2• 2 months ago

OpenAI API also supports defer_loading https://developers.openai.com/api/docs/guides/tools-tool-sea...

And it's not actually necessary for it to exist at the API level. It's a pattern. Making it API-side is just an optimization.

To do it client-side: 1. Define a single tool, tool_search 2. List the names of your deferred tools in context (or tool_search's description) 3. When tool_search is called, match the query against the tool names (or names + descriptions) 4. Append the matched tool def to the context in a new <system>-esque tag

Claude Code (as of the leak) does this client side. You can even see the custom matching function and A/B tests about whether to include the descriptions.

Whether or not that tool definition comes from MCP or a local definition is kind of beside the point.

BeetleB• 2 months ago

On the flip side, Claude is at fault in not letting you choose which tools on which MCP servers to keep in context. When I first starting using MCP about a year ago (not on Claude Code), my tools actually let me selectively turn on/off individual tools.

Crazy that the company that invented MCP is not putting basic features like this in the product.

didibus12• 2 months ago

Deferred cli/skill loading is also not part of CLIs or skills, it's all about how the coding agent/harness is implemented.

red_hare2• 2 months ago

Its crazy that people are still discussing this. It's ancient history. Deferred tool loading, large contexts, and prompt caching have made 2026 completely different from 2025.

Also, the "CLI saves token" debate really falls apart when step one of using the CLI is running "--help". The problem remains: if knowing how to call the thing isn't in parametric memory, it has to be in context.

fooster2• 2 months ago

Build a more specific skill the for the exact workflow you want?

mkl• 2 months ago

Older than that, as it implies GPT-4o is current.

MallocVoidstar• 2 months ago

The article is from May 29 2026, they're lying about that update being 'recent' and coming after the article to make themselves look better.

CSMastermind• 2 months ago

Was this written by AI?

MCP is essentially just JSON RPC with a few special fields that must be included. I have reservations about JSON RPC, but there needs to be some 'service discovery' layer for LLMs to interface with.

It needs to be available in places like websites, desktop applications, backend services, etc. The CLI is only one place that these systems interface with.

Whatever you replace MCP with will be in a similar shape even if you specify a different communication protocol or different fields for tool discovery.

bluegatty7• 2 months ago

It's the way that it occupies the context relatively permanently, that it doesn't come along with nice install/uninstall or discovery etc. is the problem.

'Skills' should all be based on MCP, they should load on demand, be very easily manageable and discoverable by humans and by AI, and then it would work

The scope was too narrow, given how it ended up being applied.

If they layer something on top of it, it may yet be revived.

didibus12• 2 months ago

You do know MCPs are loaded on demand same as skills now right? The only place where sometimes it still uses too much context is if you have too many MCPs (same issue with skills) or some MCP is poorly designed and responds with huge description or MCP calls respond with way too much info, but skills can have this issue as well.

raincole• 2 months ago

Every time I read articles about MCP I feel like the internet (or HN) is having a collective stroke.

People are saying API are better than MCP. But MCP is just API with some instructions for the AI to discover how to use it. Nothing more nothing less. And some people are saying we should use 'CLI'... what does it even mean? LLMs are good with common CLI tools like ffmpeg because the knowledge is solidified inside the weights. If I make a new CLI tool I still need to somehow teach the AI to use it. If one wants the 'teaching' part comes from a server then MCP. If one wants it local and static then skills. How could there be so many debates around these simple concepts?

hhthrowaway1230• 2 months ago

i feel exactly the same its literally the only api standard that we truly made plug and play and even automatically oauth antenticathable with dcr and people are falling over it. also in an absolute record speed thousands of mcps.

cli’s also need to be documented and input/output typed.

its also extremly dsitributable by just pointing to an url.

cli’s are great because they are composable but i really got huge mileage out of mcps

jeroenhd• 2 months ago

My take is that most of the AI related posts are written by AI under instruction of people who hype it up but have no idea about how any of it works.

It all has some form of "the thing I'm doing is the future and everyone who doesn't join me will fall behind" energy that AI/NFT/blockchain/web3/etc. enthusiasts talk about when they're trying to sell you something or when they're trying to convince the world they really are the big money makers they claim to be.

The LLM isn't going to care about where the tokens it's inserting into the context window are coming from. For all it cares the data it's processing came in over fax and was read in with OCR.

clarkdale• 2 months ago

I can't pipe an MCP's output to jq, and I can't ask an AI to write a python script to call an MCP.

sidewndr46• 2 months ago

Paradoxically, I've seen new CLI tools take on usage patterns from existing ones because of the idea of user familiarity. Even if the existing pattern sucked. I could see the same thing happening now under the idea that "the LLM already knows how to use X, so we should make our tool work like X"

CBarkleyU• 2 months ago

If one wants the 'teaching' part comes from a server then MCP. If one wants it local and static then skills

Not being facetious, but why not:

"If one wants the 'teaching' part comes from a server then OpenAPI specs. If one wants it local and static then man page."

sunnybeetroot2• 2 months ago

Agreed, MCP works and it works well. Often I’ll wrap an API in an MCP because getting the agent to interact with an API just wastes tokens with it trailing things back and forth; MCPs just work.

mikekuharuk2• 2 months ago

Yes, feels like person who wrote this was not completely aware of topic

madrox• 2 months ago

MCP is still great if you're running AI in an environment that precludes a shell while needing dynamic tool discovery, but that's a narrow set. People are learning how useful it is to give AI access to a shell. If you're giving them a shell, may as well give them a CLI.

However, I don't think that's what is really hurting MCP, because it could evolve. What really killed it was the standards process and enterprise groups getting ahold of it. It went into spec writing and got adjudicated into uselessness all while enterprise authentication groups were figuring out the best angle to make money on it. I listened to a pitch from Okta on MCP and they wanted to charge out the nose for it for no good reason.

mxstbr• 2 months ago

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.

alexwwang2• 2 months ago

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.

jimbokun7• 2 months ago

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.

bluegatty7• 2 months ago

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.

jimbokun7• 2 months ago

OpenAI should hire you.

jimbokun7• 2 months ago

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?

cle• 2 months ago

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

They have different tradeoffs.

fnordpiglet3• 2 months ago

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.

827a4• 2 months ago

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.

eddythompson802• 2 months ago

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.

varenc• 2 months ago

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.

hobofan2• 2 months ago

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• 2 months ago

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

ford• 2 months ago

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.

throwpoaster2• 2 months ago

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

bluegatty7• 2 months ago

"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.

pjjpo• 2 months ago

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.

rand593843• 2 months ago

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

tulio_ribeiro• 2 months ago

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

mettamage• 2 months ago

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

goalieca• 2 months ago

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

CharlieDigital5• 2 months ago

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...

ProAm• 2 months ago

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

julianlam• 2 months ago

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.

OtherShrezzing• 2 months ago

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”.

sevenzero• 2 months ago

Yup agreed, this reads like massive coping...

jrflowers2• 2 months ago

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.”

shabgzer• 2 months ago

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

tvink• 2 months ago

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?

rvz• 2 months ago

The comment just reads to me as:

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

jurgenburgen• 2 months ago

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.

bshaughn• 2 months ago

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.

jngiam1• 2 months ago

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

tlogan2• 2 months ago

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.

rixed5• 2 months ago

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.

mjmas• 2 months ago

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

js4ever• 2 months ago

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

Groxx2• 2 months ago

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)?

winrid• 2 months ago

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

Someone3• 2 months ago

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.

sofixa2• 2 months ago

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?

hnlmorg2• 2 months ago

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.

personjerry• 2 months ago

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)

holoduke• 2 months ago

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.

ekianjo• 2 months ago

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

debarshri• 2 months ago

Totally agree with you.

mrgaro2• 2 months ago

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.

PunchyHamster• 2 months ago

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.

brookst4• 2 months ago

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.

Gomotono• 2 months ago

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.

hashmap• 2 months ago

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.

slashdave• 2 months ago

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

random3• 2 months ago

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

sunnybeetroot2• 2 months ago

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.

jrflowers2• 2 months ago

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

mempko2• 2 months ago

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.

hobofan2• 2 months ago

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)

zuzululu2• 2 months ago

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

geysersam5• 2 months ago

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

epsteingpt• 2 months ago

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.

meszmate• 2 months ago

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

xeiotos• 2 months ago

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.

the_gipsy• 2 months ago

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."

robotswantdata• 2 months ago

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

baq• 2 months ago

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?

bredren• 2 months ago

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.

j45• 2 months ago

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

coderbants• 2 months ago

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.

Aldipower2• 2 months ago

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.

gobdovan• 2 months ago

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

neya• 2 months ago

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.

MatthewPhillips5• 2 months ago

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).

falcor842• 2 months ago

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?

mhalle2• 2 months ago

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.

docheinestages• 2 months ago

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

noworriesnate• 2 months ago

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).

zingar3• 2 months ago

GraphQL also allows the LLM to DOS your service

bmitc• 2 months ago

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

sd9• 2 months ago

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.

zingar3• 2 months ago

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”

troupo8• 2 months ago

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.

yepyoukno• 2 months ago

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!

qsxfthnkp2322• 2 months ago

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

News at 11.

zimbatm• 2 months ago

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.

delusional2• 2 months ago

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

croes• 2 months ago

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?

delusional2• 2 months ago

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.

btbuildem2• 2 months ago

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.

windexh8er• 2 months ago

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.

Eridrus• 2 months ago

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.

hackrmn• 2 months ago

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.

mikecwang• 2 months ago

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

imp0cat• 2 months ago

Got any tips for building a MCP over CLI app?

listless• 2 months ago

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.

mycall• 2 months ago

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.

0xbadcafebee2• 2 months ago

Man I wish I could downvote stories. There needs to be some way to push back against dark patterns in writing, like clickbait.

Clearly MCP is not dead, as the article itself says. But the article lies in order to play on human sentiment/heuristics and steal your attention. It's like shouting fire in order to get people to run over to see your business.

notgenerated• 2 months ago

Most of the internet is clickbait for a long while now. No one would read a title like "MCP and CLI can both be usefull in certain scenarios. Ask your AI and he'll tell ya" :)

msukkarieh• 2 months ago

MCP is dead

scrolls down the page...

So is MCP really dead? Not entirely

sigh...

adi_kurian• 2 months ago

The vernacular around prompts, text, and docs, is quite amazing. Marketing really is value creation.

insane_dreamer2• 2 months ago

Claude context window is now 1M, not 200K, which significantly weakens the first argument.

DonHopkins2• 2 months ago

And significantly increases the price.

insane_dreamer2• 2 months ago

I'm paying the same $100/month that I was back when the context window was 200K, so, no.

cowlby• 2 months ago

I use all three (MCP/CLI/API) based on what Claude excels at:

* CLI: GitHub & AWS it already knows how to operate the CLIs well. Even learned about a few new CLIs like 1Password's op which it volunteered one day.

* MCP: Supabase, Shopify etc. where the CLI would be non-obvious and the affordances from the tools/descriptions helps Claude maneuver.

* API: Sometimes it just knows an API exists and is able to call it directly with python/curl. I discovered from Claude the Pokemon ecosystem has a free API out there for example.

etoxin2• 2 months ago

Also MCPs for programs like Chrome Dev tools or Playwright.

sodafountan• 2 months ago

Ah, this helped me wrap my head around what actually makes an MCP special.

king_zee• 2 months ago

Besides people with positions relevant to the field I'm weirded out by most of the replies, isn't MCP effectively just a communication standard? Like the only difference between an MCP server and my Express webserver is the supposed logic on how it needs to communicate with the AI, why are we making such a big deal out of it? Eventually we'll all converge into some form of standard to link things to our LLMs and it's probably going to be based in some form on MCP, but I genuinely don't get what the big deal is

ActorNightly• 2 months ago

Everyone is sort of missing the point here.

While the title is quite obnoxious, the author is right.

I don't think that anyone would argue against standardizing training for any model on ways of invoking tools through specific output templates (with MCP being an extension of that). However, the question is what is the best way of having the model use those tools? There are 2 options

1 - Encode actual functionality during training, let the model figure out how to use available tools to do what it needs to. Latest Claude models are a good example of this, when editing files if it encounters issues with the under the hood tool, it will write a bash python command to edit the file

2 - Describe functionality in instruction context. This allows you to define complex sequences of things to do, but at the risk of the model losing context as the conversation continues.

3 - Use tool calling, where every request gets an available tools section appended to it, and define the complex functionality in the static code (whether its local tools or MCP servers)

Ideally, if we are pushing towards smarter models, the answer is between 1 and 2, where you have a model that only has access to be able to run shell commands, and some memory that it can reference on sequences of shell commands to run. An MCP invocation is then a simple echo jsonrpc pipe to local executable or a curl command. Eventually, its probably worthwhile to have your LLM run in a CPU like sandbox where it can execute arbitrary assembly commands from sequences stored in memory to do what it needs to do.

Until then, 2 and 3 are really what we have for adapting with current frameworks.

youre-wrong3• 2 months ago

No. The author is wrong. If you’re still using single model/context then it’s kinda your own fault for using things poorly.

fg1372• 2 months ago

I never understand the "eats context" argument. Why do you have so many MCP enabled in the first place? Do you actually use them in every project?

esafak• 2 months ago

So you have to manually enable/disable every MCP? What fun...

fg1372• 2 months ago

You have MCPs disabled by default but turn on the ones you need in specific projects. Set this up once per project.

I use Playwright MCP, but there is absolutely no reason I'd keep it enabled in a Go project.

tanin2• 2 months ago

If you build connectors for yourself or your team, you probably can skip MCP because you can tell your friends to install CLI or whatever and provide extra prompts for your CLI.

If you have external users, then you have to use MCP, which comes with how to use each endpoint and etc. MCP is what their current apps e.g. Cowork, Cursor support out-of-the-box.

In that sense, MCP is very much not dead

d0mine• 2 months ago

If you need a network boundary, what MCP provides that REST API + llms.txt can't do?

jiggunjer• 2 months ago

Standardization. Who writes llms.txt? Everyone writes their own? Will agents still behave the same?

tanin2• 2 months ago

The AI probably can figure out. However, Claude Code and other tools are built to support MCP. This means MCP is probably more reliable than using REST API + llms.txt.

charrondev• 2 months ago

OIDC? Ease of deployment in a company?

You can have your IT department configure an MCP for the org, and your regular non-technical users click a button and login with their account the service. Then they get all the tool calls authenticated as themselves.

hendersoon• 2 months ago

Claude code basically fixes MCP context usage with tool search, so MCPs are only loaded into context when actually used. Unfortunately codex doesn't support that functionality.

Until that happy day arrives I run every required MCP with mcpc.

[1] https://github.com/apify/mcpc

onesingleblast• 2 months ago

I swear something is dead every week for yall.

dannypdx2• 2 months ago

MCP is just one of many -insecure- protocols that will be swallowed by a runtime governance protocol (like g8e) that is purpose-built for security, not to 'move fast and break stuff'.

monkpit4• 2 months ago

You should disclose that you are behind g8e.

dannypdx2• 2 months ago

Do I need to add a disclaimer to every one of my posts that shits on the wrong way?

827a4• 2 months ago

The idea that MCP tool definitions take up a certain number of tokens is laughable. That's an implementation detail of the agent harness. MCP is just an API specification. Hell, there's nothing in it that makes it much of any different than OpenAPI, except that its a bit more local-dev focused. There's a thousand things harnesses can and do do to optimize MCP beyond just "spit out the raw MCP output into the context window and pray".

iJohnDoe• 2 months ago

MCP is dead. AI bubble. Windows is dead. Linux is dead.

The only thing worse than the people saying it are the people that repeat it.

Aldipower2• 2 months ago

At some point people are dead. Really.

joeyguerra• 2 months ago

Wait. it was alive?

miguelspizza• 2 months ago

I have been working full time in the MCP (& WebMCP) space for about a year now. Half consulting half spec work.

The article is semi right. Local MCPs that are made by enthusiasts wrapping an api they don’t own? Yes that is dead and should never have been a thing in the first place.

But MCP in its current direction and form is really an OAuth Protocol over http. And it has something other that other agent identity protocols don’t: client adoption

TurdF3rguson2• 2 months ago

I just don't see how she missed in her example that the post to linear graphql endpoint needs the model to load the graphql definitions, there's no way it's 65x the tokens. Whatever overage it actually is, it's well worth not having to muck around with graphql.

jaynate2• 2 months ago

Feels like we’re continuing to trend toward deterministic workflows which may actually be okay in 90% of cases. Reality is there’s a lot of unnecessary token burn happening right now. Simple market dynamics will solve that, i.e., when token cost subsidies begin to fade away and we face the true cost of agent applications.

btbuildem2• 2 months ago

Bingo. All this agentic hype is just people discovering POCs. Yes you can hodgepodge semi-reliable solutions where you don't really know what you're trying to build so you wrap it in a layer than can sometimes approximate logic and decision making, so that you don't have to use logic or make decisions. Amazing.

Sooner or later you have to build the real thing, and the cost and slowness of token-based computation become unacceptable.

jaynate2• 2 months ago

Yes, and the free-for-all building of nonsense (and insecure) apps by non engineers is probably going to slow down as well.

figmert• 2 months ago

I don't know about it being dead, but i certainly stopped using it because it kills the context. A huge amount of tokens are wasted to mcp when in use. Skills use far fewer tokens. From my experience anyway. I'm also not advanced enough so maybe I'm not using it right.

OpenWaygate• 2 months ago

I used to compare MCP and Skill in my post (AI-assisted [1]) and also maintain a CLI/MCP/Skill for YouTube.

In my opinion, MCP is not dead. "MCP Belongs to Software Engineering", it ships existing concepts from software engineering into AI. CLI, MCP-tools, and OpenAPI are interchangeable to some degree, but MCP is more than tools; there are mcp-apps[2], lazy load in context[3].

[1] https://log.ifor.dev/posts/mcp_vs_skill/

[2] https://modelcontextprotocol.io/extensions/apps/overview

[3] https://code.claude.com/docs/en/agent-sdk/tool-search

ericyd• 2 months ago

Restaurant analogy:
You sit down and 10 menus (MCP tool definitions) are spread across the table
There's no room left for actual food (your work)
Every time you order, the menus have to be pulled out again

This is a bad analogy. Ordering repeatedly is uncommon except for tapas restaurants. You could easily put food on top of menus, but more commonly, menus are removed after ordering, thereby freeing the table (context??) for the food. If you're going to try to explain things by analogy, it's worth putting effort into making it more relevant.

firasd• 2 months ago

Do CLI enjoyers realize that MCP can be called via curl?

For example I have a no-auth clock for AI deployed from https://github.com/firasd/mcpclock to https://mcpclock.firasd.workers.dev/mcp (anyone is welcome to go ahead and add it to your AI apps as an MCP endpoint)

You can still call it via CLI if you're a MCP hater

curl -s -X POST "https://mcpclock.firasd.workers.dev/mcp" -H "Content-Type: application/json" -H "Accept: application/json, text/event-stream" -d '{"jsonrpc":"2.0","id": 1,"method":"tools/call","params":{"name":"clock_get","arguments":{}}}' event: message data: {"result":{"content":[{"type":"text","text":"[\n {\n \"timezone\": \"UTC\",\n \"iso\": \"2026-05-30T04:05:07.175Z\",\n \"unixtime\": 1780113907\n },\n {\n \"timezone\": \"Alphadec\",\n \"alphadec\": \"2026_K6G7_066464\"\n }\n]"}]},"jsonrpc":"2.0","id":1}

curl -s -X POST "https://mcpclock.firasd.workers.dev/mcp" -H "Content-Type: application/json" -H "Accept: application/json, text/event-stream" -d '{"jsonrpc":"2.0","id": 1,"method":"tools/list","params":{"name":"","arguments": {}}}' 2>&1 | grep '^data:' | sed 's/^data: //'| jq -r '.result. tools[].name' clock_get clock_day_info clock_convert clock_convert_alphadec clock_convert_unixtime clock_shift_utc clock_delta_utc clock_delta_alphadec

The "just use a CLI" crowd is implicitly assuming:

1) You're a developer 2) On a laptop 3) With a shell open Inside an agentic coding harness (Claude Code, Codex CLI, Cursor) 4) Working on a software project 5) That's like... maybe 2% of AI usage.

The other 98% is: Someone on the ChatGPT iOS app asking a question on the subway; Someone in Claude.ai web chatting about their calendar; Someone using ChatGPT Desktop to summarize their Notion; A non-developer using AI in a browser at work; Voice mode on a phone; An embedded chat widget on some company's website...

_puk• 2 months ago

2024. Oh woe, I have to scrape everything, why don't companies just give me an API to consume what I need.

2026. Oh woe, the MCP that all the companies are giving me isn't ideal.

2028? oh woe, the CLI that calls the REST API, that calls the MCP that all the companies are giving me..

Spiritus• 2 months ago

CLIs have to be distributed. Also have to be kept up to date. An MCP doesn't t have to concern itself with backwards compatibility and can be changed willy nilly since it's essentially always up to date.

It's also easier to manage for non-tech people. Try telling the people over at HR or finance to install a CLI.

osigurdson• 2 months ago

> MCP consumes ~65x more tokens than the CLI approach.

For this example, there seems to be no explanation for the LLM to know when to use this curl command, etc. Is the idea that the linear API is known in the LLM weights already and therefore there is no need to include "the manual" in the context window? If so, it's a pretty narrow win.

didibus12• 2 months ago

Not just that, but they retracted this:

Update: Since these measurements were taken, Claude Code has rolled out Tool Search with Deferred Loading, which loads MCP tool schemas on-demand and reduces context usage by 85%+. The context bloat described in Problem 1 is largely addressed for users on current Claude Code versions. The performance, debugging, and architectural arguments below still apply.

Because Claude Code only loads the tools it needs now, so context bloat is pretty much solved for MCPs.

etoxin2• 2 months ago

People who say MCPs are dead don’t understand how MCPs work or when to use them.

tiffanyh• 2 months ago

What comes after CLI?

In the early days of computing, desktop apps and later webapps provided richer human experiences.

What will provide richer experiences for agents, after CLIs?

robertclaus• 2 months ago

A CLI or authenticated web endpoint requires somewhat arbitrary terminal or code access. MCP wraps the functionality in a way that doesn't require nearly the same permissions. Doesn't that enable a whole different class of users?

rixed5• 2 months ago

  > Problem 1: It Devours the Context Window

Like would running `linearcli --help` then `notioncli --help` then `slackcli --help` etc, or am I missing something? At least with MCP your harness could add in the context only the title of each tool and add full documentation on demand, MCP server by MCP server and tool by tool. The equivalent would be for all CLI to feature a "--short-descr" command.

  > Problem 2: Low Operational Reliability

If the tool is also using a REST API I see no reason why MCP should be slower, given the protocols are so close. When that happen, it's probably because MCP was added on top of an API, maybe hosted in a far away datacenter by a subcontractor? I won't argue that most MCP servers are probably awful, but that's an argument against the industry not the protocol.

  > Problem 3: Overlaps with Existing CLI/API

Yes, when a CLI tool already exist. A SQL MCP server sounds stupid to me, and a waste of token. Why not a curl MCP? But in the vast majority of shops, a cli tool does not exist. At best they have an API, which is designed to be used by programs not LLMs (you know what I mean).

  > Provide CLI -> API -> docs, in that order

Sure, and instead of slow and wasteful websites companies should first provide a native client for desktop, then a native client for phone.

Mashimo• 2 months ago

Like would running `linearcli --help` then `notioncli --help` then `slackcli --help` etc, or am I missing something?

I'm not super deep into all of this, but I think except latest Claude Code release the mcp is frontloaded into the context. So if you don't need it that often you have to disable and enabled it again when needed.

And I guess you can put some usage examples into the skill file. Which might migate the first --help.

Also I guess with cli it's easy to spin up a sub agent with their own context that just returns the result?

rixed5• 2 months ago

Yes I believe it is preloaded (from a recent test with latest claude-code actually). But that's an issue with the harness not something that's mandated by the MCP protocol.

binyu• 2 months ago

MCP is what XML dreamed of becoming.

extr• 2 months ago

The points in this article don't really land for me. They are mostly critiques of particular MCP implementations rather than the modality itself. My impression right now:

- MCPs are great for stateless, mostly read-only interactions with document store type things. Notion/Slack/Linear are perfect use cases. I have those MCPs connected to claude code and they work great. These tools never had CLIs or super well used public APIs to begin with. MCP handles the auth for me. Cool.

- MCPs are great but not fully necessary for "function shaped" things where you're trying to run some Function and that Function has a lot of parameters with some subtlety to them and perhaps needs some examples to really help the LLM understand. Though you can get away with a skill + curl, or a hand rolled script even.

- MCPs are not so great for interacting with more complex stateful systems with large surface area. You don't want/need an AWS MCP, for example. And of course Cloudflare is the canonical example here where they do have an MCP but it has a special "Code Mode" because they have a huge product surface and a lot of state.

Most companies are somewhere in the vast space between being a document store type thing and AWS, so aren't really sure what their MCP should look like, or how customers will use it, but feel like they're missing the boat if they don't ship something. So they ship an MCP and perhaps the people who need the document type stuff load it up and get some use out of it, but others are not so satisfied. Or maybe from the other direction, people are trying to use your product but aren't super technical or don't know how to best use it with AI, but "loading up an MCP" seems like a reasonable way to start, so they ask everyone "Where's your MCP"?

I run into this at work all the time. We get a lot of requests for an MCP. But our product is not so simple to just stuff into a bunch of stateless API calls. And we question whether the people requesting the MCP really know what they want it for, exactly, other than to hook up to claude code so they can say "claude go do everything" (which is a valid sentiment, but implies a lot of work on our end to figure out how to make that work well).

kstenerud• 2 months ago

Alternative 1: CLI-First Strategy
Provide CLI -> API -> docs, in that order. LLMs already learned from man pages and StackOverflow.

So how is the agent going to know about your niche CLI? It's still going to use up context to learn your command line interface, same as for an MCP interface.

Agents only excel at CLIs if a particular CLI was part of their training data. The same would be true of well-known MCP interfaces.

Alternative 2: Skills Pattern
If MCP is "spreading all menus on the table upfront", Skills is "asking the librarian for only the book you need".

Or: Layer your MCP help commands, like a directory at a mall. The agent only looks up what it needs at the time.

big-chungus42• 2 months ago

Isn't MCP just a way to give agent tools? When you are building your own agent, you can define the tools manually, but if you're using something existing like opencode, how do you add new tools as a user? You use the API for that which is currently MCP. Saying MCP is dead is kind of like saying tools are dead, which is definitely not true because all modern LLM agents are trained for tool use and you wouldn't have agents without it.

The problems listed on the article are problems with specific tools that have large tool descriptions. This has nothing to do with MCP. There is nothing in MCP that would cause the tool descriptions to use more context than they would otherwise.

helloplanets2• 2 months ago

You can create tools without using MCP for OpenCode: https://opencode.ai/docs/custom-tools/

nicman23• 2 months ago

i mean yeah but is just a spec

crazytweek2• 2 months ago

A good MCP server makes the difference between an agent using 20k tokens and 2 million. It may not matter yet with sponsored Codex and Claude subscriptions, but it will kill many use cases once providers switch to token-based billing.

That may sound like an exaggeration, but it’s exactly what I see in our product.

Humans developing something already have context that agents don’t have yet. Most agents start a task with virtually no prior knowledge. And they start from zero every single time. That may improve in the future, but we’re not there yet.

Can agents get the job done? Yes. But without a thoughtfully implemented MCP server, they are awkwardly inefficient.

geysersam5• 2 months ago

Seems to me that you're saying the MCP is a simplified API with good documentation geared towards agents. But if that's the case, could you not exposes the simplified interface as part of the API, instead of exposing it in MCP?

crazytweek2• 2 months ago

When it is part of the API, the agent still has the choice between multiple options. If it chooses the less efficient one, the request can become significantly more CPU- and token-intensive than necessary.

The problem is that the agent does not care. Its primary goal is to get the job done.

Maybe the agent is smart enough to choose the optimal path, but that strongly depends on the model being used. You also do not know who is on the other side. With a human-facing API, you can usually assume who is using it and what they want to achieve. Humans are generally lazy and tend to look for the most efficient solution.

An agent, however, will happily iterate through 1,000 users and fetch the online state for each one individually, even across multiple paginated requests if necessary.

You can provide an endpoint that returns the online states for all users at once. A human will most likely use that endpoint, but I have seen agents go completely wild on the other side. :D

At some point, you may get a response like “token limit reached.” But what do you do then? You give the agent more tokens and increase your bill, because you cannot even tell whether there was a more optimized way to achieve the same result.

In practice, this is a surprisingly tricky problem. :D

krissvai• 2 months ago

We can't generalize, it depends on the case, and it's not a XOR. I personally go CLI first, and if not possible MCP.

xlii• 2 months ago

Is Betteridge's law of headlines irrelevant today?

https://en.wikipedia.org/wiki/Betteridge's_law_of_headlines

fragmede• 2 months ago

No.

david_shi• 2 months ago

A bit off topic, but I think Google's A2A protocol could be a sleeper hit vs. the MCP protocol.

Not because it's better, but with one switch a significant portion of web traffic can be directed to A2A servers through Google's new search box.

bestony• 2 months ago

It sounds like what we need is a better option for converting an existing OpenAPI into an MCP Server?

konart• 2 months ago

IDK, in my company we are qwen code base agent with quite a few MCP's:

Jira

Confluence

Gitlab

Logs & Metrics platform (inhouse solution)

QA (not sure what this one does)

Context7

mattermost

I have no idea about modern trands etc, but I wouldn't say that MCP is dead. Not the hottest new thing, sure.

pmontra2• 2 months ago

Meta: there is no question mark in the title of the original post.

woodylondon• 2 months ago

I prefer the skill/CLI approach, but with Claude, I have found that building skills or plugins using CLI tools or bespoke code connected to external APIs runs into a problem with what Claude allows in its locked-down sandbox, particularly in Co-Work. The only way out of the sandbox seems to be MCP, and even then, there are timeout issues.

thecopy• 2 months ago

Every mature MCP gateway solution should implement Code Mode (e.g. https://docs.gatana.ai/code-mode/) - it circumvents all the arguments.

In the end MCP is just a protocol for discovering tools. And agents _need_ to do stuff with tools.

rbanffy• 2 months ago

I’m sure Unisys will still support it for decades to come.

Oh. You mean that new thing also named MCP?

ashm1104• 2 months ago

Well, I am not sure why everything is declared dead nowadays, I am actually trying to find the thing that actually die when people claim "x" is dead. Everyone is riding the wave, and so am I tbh...but the dead thing...I mean.. invite me to the funeral then

jedisct1• 2 months ago

When agents don’t encrypt secrets, MCP servers help prevent users from handing their API tokens to AI providers or intermediaries such as Cloudflare and Akamai.

miki123211• 2 months ago

Here's a crazy idea: instead of dealing with MCP servers and distributing all the CLIs for all the platforms, just expose your API... through SSH.

SSH is the perfect protocol for LLMs. Coding agents can use it already, `ssh api@example.com list-users` is all it takes. There's a 90% chance that your users already have ssh installed. It's text-in, text-out (which is exactly what LLMs need). It handles authentication (through public keys), streaming output, interactive I/O, even file transfers (through scp / rsync) if that's something you want.

If your users link their accounts to Github or GitLab, you can even scrape their ssh keys and pre-configure authentication for them, so they just connect and they're in.

shdh2• 2 months ago

Scale this across your organization

vonneumannstan• 2 months ago

MCP will die for the same reason RAG died and why prompt engineering is dying. The models get better at understanding what you want and where to find the right tool or context to solve the problem on their own.

menacingly• 2 months ago

I don't understand how anyone is still primarily thinking about single-user scenarios in 2026

IFC_LLC• 2 months ago

I love those "A coring drill is dead?" article.

"We've done extensive renovations in our apartment and while the coring drill was essential to install electrical conduits it's pretty useless in making furniture installations".

In the world of AI development we are jumping from tech to tech every 20 minutes. I'm in shivers every time when I see "A new claude version was released, do you want to update now?"

The moment you kinda automate something with the AI, the process breaks and you have to build the new thing.

So don't blame a coring drill.

customguy• 2 months ago

(zero value comment following)

Every time I read MCP, I think it means "master control program".

http://mcp.a1k.org/indexe.html

And I know I will forget again. "Model Context Protocol" is so bland I already forgot half of it by the time I'm at the third word, so that even some old Amiga stuff instantly overrides it.

helloansh• 2 months ago

mcp will consolidate, its all stdio fragile and stateless

_pdp_2• 2 months ago

At cbk.ai we dynamically load MCPs into the context when the LLM needs them and unload them when finished. The cost for doing this is negligible and it scales well.

The good think about MCP is the authentication story. It is almost perfect. Compare this with CLIs which mostly piggy back on quirky browser authentication, env files and other bad practices. It is a security nightmare. It is certifiably insane.

So to compare MCPs to CLIs purely on token cost is missing the entire point that at the end of the day these agents need to operate safely and OAuth is the defacto standard where this can be done in somewhat consistent way across different vendors.

_pdp_2• 2 months ago

Oh forgot to mention that each CLI is basically another supply chain issue too. So there is that.

sprakhya• 2 months ago

I think mcp will become more important than ever.

tyingq• 2 months ago

The pro-MCP arguments sound a lot like the same ones for SOAP, J2EE, "Enterprise Service Bus" and other "once-dominant, now dead in favor of dev driven simpler solutions" tech.

Alifatisk• 2 months ago

There is no publishing date on the article.

est• 2 months ago

MCP is based on a lie: Machines are good at read/generate machine-parsable procotols.

Turns LLMs are shit with JSON. Especially those JSON str embeded inside another JSON key-value pairs.

Why do smart ppl design a schema like escape JSON into str embeded into another?

It's based on another lie: AIs favor static typed languages.

olup• 2 months ago

Having implemented a skill to connect teams to our admin system, we ended up recording it as a Mcp. the Mcp exposes only doc grep and api calls so it's completely useless in itself, but the main reason to go this route was distribution. Non technical teams want a UI where to add a url then everything just works and oauth is guided. Mcp permits that in Claude or chatgpt.

Also the calling of the Mcp is nicer in the chat UI, clearer for users.

xurenwu• 2 months ago

I think it is on the way to death because of security .

leowoo91• 2 months ago

i dont think there is anything preventing devs to filter out certain items from the tools list - security is more of a issue for how you are harnessing your agent (at code-level of course)

Voblit• 2 months ago

good to hear!

solarkraft• 2 months ago

It's such a dumb discussion.

MCP is an API with some description. It adds tools to your agent, along with some context.

The (common) complaint is that the principle of progressive disclosure isn't working because all tools, with all their descriptions, are loaded into context right at the start. This is a somewhat reasonable complaint, as the structure makes it hard for the harness to progressively disclose the tools.

This is a fundamental issue with anything that just adds a bunch of tools, whether it be via MCP or HTTP (still sad that MCP won over OpenAI's HTTP based approach).

How might it be solved? Well, we could work with sets of tools. That's pretty much what the CLI approach does: Wait until you need it, then invoke the help command to discover what to do exactly. The caveat of the CLI being that it's a nightmare to secure.

At the end of the day, every capability eats some amount of context because the LLM needs to know when to invoke it.

fireant• 2 months ago

Besides points already mentioned,

- remote mcps are server driven, meaning the producer can introduce new functionality without requiring all clients to update their skills and clis

- remote mcps are safe as they don't require literal code execution privileges on your system. Many times skills even bundle scripts with `npx`/`uvx` which is basically just `curl npm.com | bash` level of unsafe

wolttam• 2 months ago

MCP and shell/bash tool calling serve totally different use-cases, this discussion is... odd.

dev_l1x_be• 2 months ago

It was dead from the get go, agents need tools the do not cate about the details that much

lowbloodsugar• 2 months ago

Fixed with subagents.

shdh2• 2 months ago

MCP’s are fine

They are easy to implement and integrate

You can use OAuth and handle ACL easily

octoberfranklin3• 2 months ago

Editorialized title is not cool, HN.

warumdarum• 2 months ago

A foolish question regarding the context window, cant it be extended using determinist compression? Like you can describe a chess game verbose or compress it down into chess similar to 1.e4 Nf6 2.e5 Nd5 3.d4 d6 4.c4 Nb6 5.f4. Basically you compress the context into deterministic knowledge sequence?

loaderchips• 2 months ago

Mcp works because it exposes primitives to agentic Loop and makes dynamic calls possible which would otherwise require very elaborate deterministic algorithms. I like to think of every mcp tool as a co-ordinate Axis. The more you have the more complex paths your agentic loops can traverse. So while that protocol is a wrapper and can surely go extinct something better with similar abstraction will show up

ascotan• 2 months ago

clickbait. they knew what they were doing.

there's a long history of X is dead posts. PHP is dead, Java is dead, jquery is dead, unix is dead, REST is dead, graphql is dead, microservices is dead. and of course none of those things are dead. but... they're great for clickbait.

g42gregory• 2 months ago

I try to use CLI-based services as much as possible and avoid MCPs.

devil1432• 2 months ago

From my experience, the biggest flaw of mcp is lack of control over your system prompt.

Prompts need to be tailored for specific model (duh). Tool definitions are de facto part of your system prompt. By injecting tool definition from MCP servers into your prompt, you are basically adding prompt that was (likely) not tailored for your specific model. That causes drop in quality of answers.

Other issue is that adding one new feature via MCP can introduce regression into your system and cause other MCP features to work incorrectly (and I am not talking about malicious prompt injection by MCP provider).

Real life example: tools from MCP server for ms outlook requires certain date format for filtering emails. That worked fine in our prod. Until we added another MCP server (built in-house in another department of our company) that required dates in different format. After adding these tools, now our agent started making mistakes: putting dates in outlook format in our internal mcp tool and vice versa - putting dates in our internal format into outlook tool. There is no obvious way to fix it other than separating these prompts. And that goes against standard MCP architecture and consumes way more tokens to cycle through multiple prompts and agents.

If that's already the issue with two MCP servers, then this architecture clearly does not scale.

navs• 2 months ago

As much as I like to hate MCP, it has a place in its accessibility outside terminal based agents and in its ability to wrangle data before it’s consumed by the agent requesting it.

Sure you can use a cli tool and jq. Most cli tools that interact with third party providers are just APIs so you could argue it could be replaced with a curl.

apf6• 2 months ago

old and inaccurate knowledge..

- Skills do take up space in the context. The name and description of every skill goes into the system prompt. You can't add unlimited skills without context pressure.

- MCP context spam is less of a big deal now that there is deferred tool loading.

- If you work with the agents long enough you'll run into situations where using bash CLI tools suck and an MCP works better.

- MCP is not dead and has never been dead, it's the right solution in certain cases.

powersjcb• 2 months ago

MCP protocol layer is for all practical purposes an irrelevant implementation detail.

We need some new layer to handle things that used to be abstracted away by UIs

- filter to 6 of 50 fields for the paginated pipeline views

- show all the important fields on a detail view

- organize for understanding of fields that might have been poorly named in the public APIs

Some of this can be handled by a CLI wrapper around an API, but it really just shifts the complexity into a different system.

One thing that I haven't heard a lot of people talk about is that MCPs are often able to be far more flexible than a traditional REST api. You can ship breaking changes/renames and agents will adapt. Why should we couple the agent tooling locked 1-1 with our calcified systems?

crad• 2 months ago

Perhaps this should be "People don't understand how to implement good MCP servers" as opposed to MCP is dead.

MCP shouldn't be 1-1 to API. It should empower users and LLMs to perform tasks and see data.

CLIs don't improve upon that issue if they're designed the same way people are implementing MCPs.

mikekuharuk2• 2 months ago

To be honest a bit weird. You say MCP is dead and talking about tokens price, then mentioning SKILLS to replace it - which will cost probably more tokens to do it. And not even mentioning that SKILLS has nothing to do with functionality itself MCP provides. To be honest a bit weird article :D

rldjbpin• 2 months ago

it is not dead for my team, but surely if one prefers to replace them with skills, they are most likely wrong. at least outside of personal, one-user scenarios.

has anybody ever use the prompt templates in practice? for what it's worth, these protocols are a product of their time, and unfortunately people lose patience with seeing it through in practice.

in the end it is all text. things are overengineered regardless, but at least this allowed reuse across projects.

MCP is dead?

Related Stories