The point here is, MCP is the backbone behind the product and enables regular users to do things without knowing anything about it.

The whole "is MCP useless?" discussion is totally pointless from a regular consumer-user perspective, they even do not know what MCP is sometimes. The Tredict ChatGPT App connects with one click and a simple oauth flow. That's it.

API and MCP all are just buzzwords for customers. What they care about is whether they can get tasks done in our SaaS using Claude or ChatGPT. If that happens, it's a success.

I say MCP is just lightweight layer on top of REST and as long as it works for end users I don’t see any reason not to adopt it.

Like as a deployed component in our customer facing app stack? Not being used in that context that I'm aware of. I think there's a couple use cases being worked on though.

Are devs/engineers using MCPs to do their work? Yeah. Datadog MCP, Atlassian MCP, Gitlab MCP, backstage mcp, and we have our documentation behind an MCP. All used daily.

MCPs can potentially have great value if they cross multiple sources and combine results. For example at work we use an in-house MCP for log/metrics search across five different (legacy) systems. It finds correlation across events in different system within minutes.

Yes, an agent with CLI access and access to making HTTPS calls is a lot more efficient for most tasks, but also a lot more unpredictable and with much higher blast radius if it starts misbehaving compared to one that only have access to exactly the tools and data sources you want it to use.

https://medium.com/@ravi.madabhushi/mcp-is-up-to-32-more-exp...

There are many more aspects, but even with GitHub MCP, where the agent has a huge amount of pre-training on the CLI, there are still reasons why people use it extensively - you don’t hear it a lot here but suffice to say usage never stopped growing to this day.

I think if CLIs are working for you then good, I also like our cli and did some work on it too, like adding gh skill subcommand.

Do use what works, and measure and improve - but this article is not doing justice to the MCP server IMHO.

Is that why I have to constantly remind Claude and ChatGPT that they do have access to a Github plugin that can access my account, instead of trying and failing to use the gh cli?

They do exactly what I want and how I want it. They expose just the information and the features I want the LLM to have. And just like in your case, it combines multiple sources of information into 1 response.

I've read many comments about how good CLIs are, and they are right. But for developers.

For non-tech people, installing the CLI is a hurdle: it involves having the right dependencies installed, controlling how you handle secrets (like API keys), and handling updates (ie. npx with a private registry). But for internal tools, once you create an MCP with OAuth, the installation (in Claude) is straightforward.

I'm surprised how non-tech people in the company use it for ad-hoc integrations, like pulling emails, getting deals from HubSpot, enriching that with the internal MCP, then drafting responses. Of course, this has scaling issues, and at some point it is better to move these everyday automations to a proper system, but I saw how MCP enables what products like Zapier, n8n, or IFTTT try to do: user-friendly ad-hoc integrations.

My only complaint: implementing MCP auth in an MCP server still isn't very streamlined. Some libraries, like Cloudflare MCP, simplify all of that, but AFAIK it's tied to using their services.

It has tools to get real jokes, do math, unit conversion, get stock information, search the web with Kagi, and other things I consider to be essential in a voice assistant. It even got approved by my wife.

At work I use our MCP server to debug and troubleshoot issues with our code too. Just yesterday I used it to figure out why a tag wasn’t showing up in traces; using the MCP server, the LLM was able to see that the tag was present in parent traces, but was lost along the way, and figured out why.

Could I find that without the MCP server? Yes, but I’d take me hours of going through lengthy traces, while the MCP and LLM found the issue in minutes.

I got a Pebble Index 01 ring and it has support for custom MCP servers. I run one on Tailscale and it can interact with Home Assistant, my home issue tracker, my Anki setup, etc.

I've come full circle on MCP. With agents with a shell tool they quickly became unnecessary but these days I've been coming up with more agentic use cases where I don't want to give the agent a shell, and a narrower MCP interface is a great fit.

Now we can point any voice agent platform we choose -- eleven labs, vapi, pipecat, whatever -- at our custom MCP server and it instantly has an understanding of the tools available, their inputs, and how to use them.

Compared to the alternatives everyone on HN champions, like clis and APIs, this is a no brainer. I'm honestly not even sure what the realistic alternative would even be.

Am I supposed to package and distribute a cli to ElevenLabs and ask them to use it? Give them a full API spec to implement for me?

I give them an endpoint and credentials and their platform instantly knows how to talk to mine. No one at ElevenLabs knows or cares about our implementation details.

HN has trouble seeing past the "developer in a terminal coding with Claude Code" use case for using AI. Real production agents have use cases that are very different!

When you don't own every piece of an integration with another system, there needs to be a well defined standard. That's what MCP provides.

Voice transport medium aside, the actual use case is not quite what you described.

Companies like Eleven Labs and Vapi provide a full end to end voice agent platform. They handle the STT -> LLM -> TTS pipeline and infrastructure for voice agents. Think of a customer talking to a virtual receptionist to schedule an appointment.

On the ElevenLabs platform, you provide them a system prompt (or an entire workflow/graph of system prompts) that instruct the voice agent on how to talk to the customer, tone, guardrails, how to answer specific questions, etc.

At some point we need that LLM agent, running on an infrastructure we don't control, to talk to our "CRM" (for simplicity sake). Enter MCP.

The MCP server we build and host supplies the "tools", like list_appointments, schedule_appointment, cancel_appointment-- whatever they may be.

When eleven Labs voice agent connects, it sees all the tools available and can use them per the instructions in the system prompt.

The current framework that solves this the best right now is FiPA.

Establish identity the same way we always have, AS defines the challenges, the client (voice agent in this case) goes and gets them. OAuth from there!

It also very helpful when you need auth. MCP OAuth with CIMD makes it easy instead of cumbersome process of generating API Keys.

If you are technical and already using CLIs, then MCP doesn't give you much.

Why MCP instead of CLI or agent accessing API directly?

Direct access (Curl/own small function): This requires agent to have full understanding of the API spec. Yes, context can be protected using progressive disclosure, but this essentially means agent needing to understand the API again and again, before every use in that context. Also, a typical API spec may or may not be agent-friendly. If there are nuances when calling an endpoint, where do we put these? Into OAS description? Works, but clunky.

CLI: It works beautifully, especially when a 3rd party CLI already exists for a complex backend. Assumes a well documented, agent friendly CLI, most CLIs are designed for human or CI/CD consumption. Talking about MCP taking up too much context, think about agent starting with my_cli --help, and going down through the switches and parameters one at a time to figure out how the CLI should be called. Less of a problem when calling a well know CLI (e.g. aws), but anything more niche (or custom) requires multiple turns to compose the final CLI command.

MCP: Has its issues, but offers an agent-native solution. Everything agent needs to know about a tool becomes available at once. In an enterprise environment MCPs can be served through an MCP Gateway, providing governance and permission management, this is quite contrast against running a CLI that requires agent to have execute permissions in its shell.

I must mention that we also utilise lazy-loading of MCPs. In use cases where 10s of tools needs to be loaded, only the most common ones are pre-loaded, then agent kernel connects the others as an when needed, and release them after a timeout (in case of long running sessions). This keeps the context lean.

It was all largely based off this example https://github.com/nolabs-ai/nono/tree/main/tool-sandbox-exa...

I was trying to find out if the MCP has some sort of lazy loading feature/primitive in the works, but there seem to be a lot of disagreements about it.

Intuitively, lazy loading seems to be somewhere between a CLI and vanilla MCP. In the end, it sounds very similar to tiered/ progressive loading similar to images on low bandwidth connections.

I feel like CLI would probably work too but then I’d end up implementing something similar. That being said, I’ve been bitten by the usual suspects: too many tools will cause context windows to grow quickly and some agents will sometimes skim through a subset of the tool list without querying the entire thing, causing incorrect behavior.

If you have tokens to burn I invite you to check out the source code see how extensively it’s being used: https://github.com/sxp-studio/subjective-zero

(video to see the MCP in action, it’s a bit long so feel free to skip: https://www.youtube.com/watch?v=DcI1tsPJ8eM)

Another kind of cool use of MCP that I’ve encountered is actually from… the French government! They do it for their open data initiative: https://github.com/datagouv/datagouv-mcp

Here's the repository: https://github.com/iodize6399/xuexi-keben

And here's the server itself: https://keben.555420.xyz

I use MCP all the time at work as well from Claude code etc, it's convenient with uniformity inside the harness.

I have no idea about MCP vs API question but I always assumed that the whole point of MCP was an abstration between the model and the tool\service.

As in model does not have to know about a certain API (not to mention a particular version of it) to work with a service.

To put this into perspective, I was a voracious social media user for decades. For me, this is 25 years of data, close to 100,000 posts, spanning everything from LiveJournal in 2001 to Mastodon in 2026. But when put together, it is a timeline of my life.

As kind of a last minute idea, I added an MCP server because why not? Once I wired an LLM up to it, I could ask introspective questions and find new ways of looking at myself and my own history. Simple things like "what was I doing 10 years ago around this time?" to more complex things like researching past thought patterns.

[0] https://github.com/rebeccathedev/afterfeed/

I'm also excited about the upcoming SEP-2640 extension to MCP, which will be allow skills to be delivered via MCP. While the skill format has been standardized, skill distribution hasn't. I know there are tools like Vercel skills CLI, but that's not a good option for non-devs.

I reversed engineered my supermarket API and made a custom MCP to automate my grocery shopping. Now I can fill my cart through ChatGPT.

More details about it on https://ducret.dev/grocery-shopping-with-ai/

I've developed and deployed my own self hosted (on cloudflare / workerd) tool here https://github.com/TAJD/projektor and the key part was to be able to add it as a custom mcp server

And you can't expect an average user to install a CLI on their machine just to search for flights or do shopping for example.

I work at Alpic, where we build Skybridge, a framework for developing MCP Apps. Our users have apps published on the ChatGPT and Claude stores, and they've seen traffic quietly growing over the last few months. Traffic isn't massive yet, but it costs little to stake out ground on a new channel and be ready if it takes off.

By what metric? I would expect that a thin API client (with readable code) is generally going to out-perform a tool-surface which you don't have the ability to manage/edit.

I run a lot of services to track my life and work and theoritically I could hook up their apis or mcp if supported to a harness and pretend like "oh its a talking computer that can do whatever i ask" but in reality, I can go through the native ui of those services esp with things like hot-keys for a faster and more ergonomic experience than talking to a jarvis and having to recorrect it if its wrong

Advantages over our normal API: - Much easier to provide LLM-specific explanations and descriptions to all of the tools and parameters - None of our clients know what a CLI is - We re-use our MCP for our own platform's agent which gives it a neatly defined list - It handles the full OAuth flow in the application

I'll admit though it is VERY similar to a REST API, and I could see them merging at some point.

We're using MCP for virtually all our SaaS and infra providers (CRM, ATS, banking and accounting, Notion, Linear, all dev tools and hosting platforms) it's become a hard requirement in our buy bechmark. No MCP = NOGO

The advantages are:

- baked-in auth: no need to configure anything, it just works with our employees accounts

- one click install with Codex Plugins and Claude Connectors

The current, main driver I see for MCP servers are non-technical people who want to securely connect data sources to their AI application.

For example, even GitHub’s fine-grained tokens aren’t always fine-grained enough for our use cases. In those situations, it’s straightforward to build a small MCP server that exposes exactly the operations we want an agent to have access to.

That gives us a much smaller and more explicit attack surface, without having to manually audit every possible GitHub CLI invocation the agent might make.

The primary reason we have this is because its easier for non-tech people to connect it to their AI Claude/ChatGPT/etc. than it is to have them generate an API key and give it the base url and the openapi spec/etc.

The MCP also allows us to add expose a couple of recipe/skill tools (list_skills/read_skill) which describe common workflows on how to use to do things that might be unclear.

"How many of these shirts sold in 2024" "Build me a chart that displays revenue over time for product XYZ"

Things like that. They love it, and we get to spend time on more pressing things.

Knowing the hell that awaits me in trying to be pixel perfect between about 40 pages, I set up the Figma MCP with my codex, and low and behold... it actually did what I needed, so that's one thing I'm grateful for.

For reference, feeding screenshots to the AI didn't do that well of a job at first.

Notion’s monorepo has 16+ MCP configs with many in opt-in plugins developers choose to activate.

Very useful; i particularly like sending an agent to debug an alert across slack/honeycomb/incident.io/materialize db

It was also pretty handy for importing existing documentation from obscure providers without having to build an integration for each of them.

We also added WebMCP [2] for agents to consume our public documentation/help center, but we haven't seen it used yet.

An API would work for all of these cases too, but since customers are using it in their AI tools anyway, MCP is just simpler for them.

[1] https://www.happysupport.ai/en [2] https://developer.chrome.com/docs/ai/webmcp

For the latter, Cloudflare Tunnels + Zero Trust + Github SSO means securing them is rather easy and with the recent cf cli the agent does all the work. Their native support for base64 encoded images is also helpful to “encourage” the LLM to look at stuff without constant prodding.

It's a very popular part of our platform.

The specifics, now user can ask, "Provision 200Gi PostgreSQL 18 with PostGIS 3.6 and then copy over our most recent Texas set of layers."

Behind the scene Talos, k8s, NiFi, and bunch of things go to work. Big productivity boost vs. the users needing to login to bunch of provisioning web interfaces which is the other method we publish that avoids version drift issues.

Other uses of other people's production MCP I'm using is Dodo Payments' MCP server. It has helped me a ton for looking up their documentation etc. 10xed my OpenCode agent's speed in building payment integration. This was the first serious usage and benefit I experienced of MCP servers.

Reference: My production MCP server: https://www.npmjs.com/package/@sisyphus-consulting/wuwei-mcp

"Why is my site showing an error", "Deploy this project" etc are the key flows, and users have been building on top of them. It's a nice link between dev & prod, and a great debugging assistant. It's been very well received so far.

Implementation was pretty straightforward (tools mapped to our API) with appropriate guardrails for destructive actions.

We do social media community management ( https://trollwall.ai/mcp ) and our customers want to know what their followers are talking about - topics, sentiment, why are people angry, showing actual example comments, comparing to last month.. Having a conversation about this is much better UX than having dashboard or static report (.. your Claude can at the end even generate PDF report on what you talked about).

We tried to build different analytics screens for this and we always found out that different types of customers what their own angle. MCP, together with knowledge/memory of their own ChatGPT/Claude, allows them to super customize it for what they want and need.

the advantage of MCP is that the tool description names what data it has so the agents know to just use it if they want that kind of data. as new data is added, everyone’s tool description updates. with a REST api or cli I suppose we could update a checked in AGENTS.md to ship it to engineers but idk how id get that to colleagues using the it from their claude.ai or co-work.

[0]: setoku.com

https://auditbadger.com/auditable-agentic-compliance/

I wont advertise any commercial mcp I use but to give an example for a well designed and useful mcp server I could name the nixos mcp. Its useful because it bundles all the nix resources to one endpoint which is more efficient than web search and gives you better control over the sources.

https://github.com/utensils/mcp-nixos

Another one would be this filesystem mcp which is in my opinion to prefer over direct cli access. Of course this depends also on your general sandbox strategy but if you just use a generic docker image there are still many potentially dangerous binaries available and such an mcp can restrict the models capabilities.

https://github.com/modelcontextprotocol/servers/tree/main/sr...

And of course there are many service provider offering their mcp with its own llm / agent behind e.g. most web search provider. In this case you most likely already use an mcp without noticing it.

Getting things like this to work well, for me, often boils down to finding out the things I don't know that I don't know in as little time as possible. I worked with Claude to create a basic debugging front-end as part of that - for my own use, inspecting the data, looking for patterns - when, largely on a whim, I asked Claude to create an MCP interface on top: last run status, what's looking good, whats not, where are the coverage gaps in the individual data points.

And I added the MVP to Claude and would check in regularly to ask how things were going.

And then - I'd ask for some nuance about why something doesn't look quite right. Or what happened to councils in general last night? And - out of nowhere, not being prompted or asked - Claude would query the MCP alongside looking at the code. Immediate production-grade insight while I'm debugging from the comfort of my chair.

And I thought "Oh."

And "this is really quite good," because the key detail is, I think, if an MCP is good and works well, and relevant to what you're doing every day at that point in time, it's yet another addition to your toolbox.

And that got me thinking about how I can do the same for my 9-5 users.

In our product, we found it hard to onboard people on our platform because even though the data was rich, our features were subpar and in development. I've opened the MCP API based on our GraphQL API (like 100 lines of code and config, piece of cake), and we got heavy usage day 1. The adoption went from convincing them to use the platform, to them flooding us with new feautres and data requests.

Don't think it would be that useful for non-tech users.

That’s where mcp (and recently webmcp) have their benefits. By design, the protocols provide predictable structure that allows agents to discover and use the tools you provide.

I’ve had success using mcp variously as an agent friendly wrapper to an existing api and as a greenfield product designed for agentic workflows. Agentic workflows can string together multiple api endpoints together into a single tool call and or use their own dedicated backends.

To share my learnings, I’ve released a free tool at https://anc.dev . While It’s still very much a work in progress, I’d love dialog and constructive feedback.

Yeah you could call CLI tools that support OAuth, but then you have two sets tools (CLI plus a skills file) to manage manually instead of a hosted MCP server.

Good for both development and cost reduction, as the agentic harnesses often allow for much greater amount of token usage per subscription, as opposed to API key which always is per volume.

Read more about mcp tools/resources/prompts.

This makes it a little more interesting to me, knowing those results.

It definitely underlines what we already know about the specific weaknesses of LLMs replies/results.

Does it really do that much difference? I mean in the end robots process MCP output the same way they would process API docs.

how about you?

The real experts have a 720° FoV with multiverse time travel.

Corporate still runs lots of bullshit for compliance, though.

It’s not clear, but if you have a handle on how it might go, I’m interested in that take (saying this to anyone).

My phone's AI assistant can talk to it too, so if I remember a task mid walk out in the sun, I can just talk to it and it can write it down.

I don’t really like having to use MCP but we don’t have a good solution for authorizing individual calls outbound from a sandbox without choosing to just not care about the sandbox.

It searches to make sure it isn't a duplicate, writes up the ticket, then submits it.

Because it's a production tool, we want the cheapest possible one without it being too inaccurate. If you used a API etc, you'd end up building what's effectively a MCP-like adapter on top of it anyway so it could communicate in natural language instead of dealing with JSON and such.

Linear's MCP is also very clean and well designed, probably one of their core advantages over, say, Jira. I wouldn't know what the API looks like because the MCP works great.

I was under the impression that Linear's MCP server code isn't public. How do you know that it's well-designed beyond following spec[1][2]?

[1] https://linear.app/docs/mcp [2] https://modelcontextprotocol.io/specification/2026-07-28

A claude routine runs without access to internet except for Slack (API) and Sentry (MCP).

It reads the Sentry MCP, compare the errors to the app source code and post a daily digest to Slack.

The reports are very accurate.

We have received very good feedback from clients across the enterprise and consumer segments, they really like it.

The biggest issues are usually that a third-party MCP server you're trying to use either has misconfigured CORS so the browser can't hit it, has a bespoke OAuth setup which doesn't work with @modelcontextprotocol/client, or they don't support Dynamic Client Registration (DCR) so you can't just point at it and use it. It's nice when none of these apply and it Just Works, the user can auth easily with the third-party and refresh tokens automatically handled in the background by the client.

That's the advantage, really - you didn't have to define the tools yourself, auth is handled for you, and the agent doesn't need to (and can't) access credentials or tokens as it knows nothing about MCP.

(1) https://github.com/dmtrKovalenko/fff

All prove great value.

We built an MCP integration for agentic access to our platform, Proxybase [0]. It lets agents buy and sell bandwidth through SOCKS5 proxies directly from the platform.

The main benefit is simpler integration with agentic harnesses. MCP still accounts for only around 20% of the agents using Proxybase, but it has made the integration process much easier for those users.

[0]: https://proxybase.xyz

MCP is useful because it has instructions to Claude (or the agent of your choice) that tell it how and when to manage the graph. Integrating with Stackography is a one-line operation:

    claude mcp add --transport http stackography https://app.stackography.com/mcp --header "Authorization: Bearer stk_...

invite link: https://stackography.com/invite/8J22NXZSFT

Other then that I've been building MCP's in pretty much all (personal) tools I'm making now, it's very useful to have a central way for an agent to look at production data without having to ssh into a server.

Could I have used an API? Maybe. But Laravel MCP makes it very easy to run a MCP server.

It feels like there is a significant amount of baggage with MCP. It had first mover advantage- coming in at a time when the frontier looked much different. Models were significantly less predictable, would consistently screw up tool calls- and couldn't quickly find a good path to interfacing directly with an API.

Things are much different now- and I'm frustrated to see that new projects on my team still consider MCP as a reasonable first pass solution for getting data in front of a model. Everyone uses Claude Code (cli, desktop; I also am frustrated that so many people use CC over alternatives- that's another rant) and thus, everyone has an harness that'll happily leverage shell + skills to get things done precisely. So- why? Why is it that I see my team-mates all using the same Atlassian MCP server that's flawed- which we don't control the tool surface of? Why not point an agent at the API spec? If the answer is that it's too slow to startup, having to read the API spec to figure out what to do- then, point it at your .claude/.codex/.whatever directory- find where the agent has used tools from the MCP server, and create skills or some thin client surface.

And I will grant that yes, I have observed that a well-engineered MCP server can offer better performance than giving an agent a loosely defined task to perform with an API. However- 'well-engineered' is not easy to achieve. You must run many iterations of benchmarks and evaluations, observe trajectories, and improve the tool surface over many iterations. You also cannot predict users- so you need to monitor the usage, and improve over time. It's a heavy lift.

Additionally- no-one is benchmarking this stuff. They throw MCP at the problem, and call it a day once an agent can achieve the task. Frustrating.

I tried for a while to speak up and suggest that maybe MCP might not be worth the effort compared to improving the UX (or, AX) of API surfaces, or instead putting cycles towards better data storage and presentation. But I find that I'm starting to feel like a dick for bringing vocalizing this consistently when MCP is mentioned.

I realize this is deep into rant territory by this point. However, anonymous posting on the internet can be good for the soul. Anyway- it generally feels as though others are not as interested as I am in eating their pride, generating research, and improving what we know, and how we do things. This goes back to CC- I am the only member of my team that is not using CC as their daily driver. Again- I feel like a dick, but my god, I sound like a broken record suggesting that others try different models and harnesses. I hear constant half-complaints about verbosity of output, or churn- and barely anyone has been willing to give OpenAI models a spin.

I can't bear to hear a group pity-party about how model output is exhausting to read- when the complaints are exclusive to Anthropic models, and no-one has even read the prompting guidance which states clearly how to drop the verbosity/density/flowery-ness of output.

And for the love of god. Stop trying to make models from other providers work in CC. It is not impossible; but it is by nature, a hacking-unfriendly platform. I promise you that CC cli is not the only coding-agent cli tool that you will feel comfortable using. Actually- I'm willing to double down and bet that you will loathe CC cli once you see what the grass looks like out of that orange walled garden. Bah!

-

Edit: AND! What's the obsession with these (https://artificialanalysis.ai/articles/search-api) products? What's wrong with: https://platform.claude.com/docs/en/agents-and-tools/tool-us... and https://developers.openai.com/api/docs/guides/tools-web-sear... (or, OpenAI's alpha/search endpoint)