I've implemented an MCP server that supports the latest MCP protocol version 2026-07-28 with OAuth, which I can connect to using Claude and ChatGPT, but I can't get Gemini to connect to it after the OAuth succeeds.

It appears as though Gemini on the web (I'm only using the free version) doesn't support the latest MCP protocol version, but I can't find anywhere on the web that suggests that, just that their enterprise versions and CLI do support the latest version. I get this message when trying to connect:

"This URL does not appear to be a valid MCP server. Check the URL.

From the server-side, I see the gemini client making the old 'initialize' request to the MCP server, which we respond accordingly with to say we don't support that version. But then it goes quiet and we get no further requests. On clients that do support the new MCP version, we'd normally then get additional requests for the 'server/discover' and 'tools/list'.

Does anyone know whether Gemini on the web allows you to connect to an MCP server on the latest 2026-07-28 version?

Anatomed is an MCP server with a UI widget. Ask Claude for “the sciatic nerve and what it runs near” and it calls show_anatomy_region, which resolves a bounded set of structures. The widget then renders them in 3D inside the chat, with a legend to toggle each one.

How it works: the tool returns structured content, Claude reads a ui:// resource for the single-file widget, and the widget fetches only the needed GLB models (whitelisted in the CSP). It never renders a whole body system, always a capped region, so it stays fast.

Try it: Settings → Connectors → Add custom connector → https://anatomed-mcp.vercel.app/mcp

Code: https://github.com/pitfa19/anatomed-mcp

The same viewer also ships as an Obsidian plugin, which passed 2,000 downloads this week. Happy to answer questions about building MCP Apps with 3D.

Disclosure: Benchhand is my project, developed with substantial AI assistance; this write-up is AI-assisted too. It's a released Apache-2.0 desktop app for Windows and Linux, not a waitlist.

The MCP part is a client built around reviewing tool calls. An imported server's call pauses with its arguments visible. You can approve, reject, or edit argument values before approving. The runtime validates the edited values and tells the model what actually ran.

It supports local stdio servers and Streamable HTTP. The marketplace searches the Official MCP Registry and reviews exact versions before installing. Managed npm installs use a private directory and disable install scripts; tokens and environment secrets go in the OS credential store. Each agent can use a different local or cloud model.

Limits worth knowing: local server processes run with your account's permissions, not in a security sandbox. A signed catalog proves publisher identity, not that a plugin is safe. Interactive OAuth and legacy SSE-only servers aren't implemented; those need a compatible bridge. Tool reliability still depends on the chosen model.

Source, downloads and plugin documentation: https://github.com/anshcantcode/benchhand

The video uses sample task data to show the interface. If you try a server that doesn't connect or exposes an awkward tool schema, a reproducible issue would help.

https://reddit.com/link/1xdetep/video/gzc1f1lf38xh1/player

I design with an AI assistant a lot, and the same things kept going wrong. It would tell me a grey was "readable enough" when it was 3.4 to 1, or call a page accessible without opening it, or review a design by praising it. So I built a server that does those parts properly and gives the assistant the method for the rest.

You paste one web address (https://designers.allthepossibles.com/mcp) into Claude, Cursor, VS Code, Codex or ChatGPT. After that it can measure contrast exactly (WCAG and APCA, with the nearest colour that passes), audit a live page for accessibility problems and name the criterion for each, check a whole token file, work out a sample size or a SUS score, and flag generic AI-made design and writing. There are also prompts for a stage-by-stage critique, a Nielsen heuristic evaluation, research plans, handoff specs and a DESIGN.md. Give it a Figma link and it reads the frame through Figma's own MCP, then sends the exact colours and text to the checkers.

It's free for everything above, with daily caps. A $5 tier adds a multi-page accessibility crawl, scored heuristic reports and saved project context. I'm the one selling it, so weigh that.

If you've never set up an MCP server, there's a start-here page written for that, and a doctor tool for when it says connected and does nothing, which was the thing that annoyed me most when I started. The skills are public too, thirteen of them, for Claude Code.

Docs are at https://designers.allthepossibles.com/docs/start. I'd like to hear which checks you'd actually use and which are noise.

Most MCP setups I see are tools the model calls on its own. I'm curious about the opposite case: steps where the workflow should hand something to a person and wait for the result.

If you've built something like that:

• What do you send to a human (review, verification, labeling, approvals)?
• How does the agent wait and get the answer back, a tool that polls, a callback, a message thread?
• How do you handle payment or trust if the person isn't an employee?

Would love to hear what's worked and what turned out to be a pain.

there's been some personal tools i've been building that i think should exist natively - this is one of them.

Sharing an MCP server I built for a problem I kept hitting - a model cites a document, the citation looks perfect, and the quote simply isn't in the file.

claim verifies citations by string-matching against the source itself rather than by asking an LLM to judge plausibility. Expose it to a client and you get tools that:

- Check a quote against a file and return an image of the page with the match highlighted - green for a full match, amber for partial, red for no match.
- Scan a full answer against a set of source files: every shared run of eight words and every figure/number is checked, and figures found in no file come back flagged as worked out which is derived not sourced.

Supported sources: PDF, XLSX/CSV/TSV, text/markdown, images, and web pages. It also ships as a Claude Code plugin that runs the scan automatically on answers in-session, but the MCP server works standalone with any client. Everything runs locally against your own files so no uploads, no account.

Install/config details are in the README: https://github.com/alnaik/claim

i'd love feedback on the matching approach, especially edge cases where 8-word overlap or the shared-words rule for numbers falls over.

both have a review process for remote servers now. anthropic's checklist asks for oauth if your tools act on a user's account, a title plus readOnlyHint or destructiveHint on every tool, a privacy policy and a fully populated test account for reviewers. openai's adds identity verification for the name you publish under and a csp listing the domains you fetch from.

for people who went through it: what did the docs not cover, how long did review take, and did you get useful feedback when something was rejected?

I'm the author. Snipaya is a Mac screenshot annotator I build, and it has a local MCP server so my agent can do the markup.

What the agent can do (it has excatly 28 tools): put screenshots on a canvas, draw arrows, numbered steps and callouts, blur secrets it finds in the image, copy text out of it, export or send the result. There are also 6 prompts like explain a bug in a screenshot and compare before and after.

Claude Code setup:

claude mcp add --scope user snipaya -e npm_config_registry=https://registry.npmjs.org/ -- npx -y snipaya-mcp

Two things I learned: agents need explicit server instructions to keep related screenshots on one canvas, otherwise they open a tab per image. And the registry flag is there because a project .npmrc pointing at a private registry silently broke npx for me.

How am I personaly using it and what it solves for me? Well I previously used similar software but it was single image editor and i couldnt use it over claude. Therefore I've made Snipaya on the side to pretty much ask my Claude to run manual tests of given feature, make screenshots and describe them using Snipaya which later on he posts to my contractor issue tracker.

App is paid with a 14 day free trial, bridge is MIT. Happy to hear what you'd want an agent to do with your screenshots.

Snipaya: https://snipaya.app

Unless your agent loads tools on demand, every request it sends carries every tool’s name, description and input schema, so I wanted to know what that actually costs. I took the 50 most-downloaded MCP servers on npm and counted 1,276 versions of them with Anthropic's token counter, minus the 286 tokens Anthropic adds for tool use itself, so the numbers are just the definitions.

The median is small, about 3,900 tokens. But 14 of them are over 10,000 and three are over 50,000. Hostinger's default command loads 423 tools and comes to 123,813 tokens. That's over Haiku 5.5's 100k line on its own, so every Haiku request with it connected pays the higher price for the whole prompt. It ships twelve narrower commands too, and VPS on its own is 67 tools.

Tool count doesn't predict it well. One server has 16 tools and costs more than one with 276, because a single one of its tools is about 21,800 tokens on its own.

MongoDB's was the one I found most interesting. Same 27 tools and same descriptions across two versions, but it went from 8,497 to 22,353 tokens because the newer one describes every parameter inside the schema. Probably better for the model, and it costs about 14k more on every request.

I also nearly published two changes that weren't real. One server looked like it grew 8x, but its old and new versions had been read different ways. Another looked like it went from 58 tools to 4, and that was just it being started on Linux without Xcode, which it needs. So the write-up only compares versions read the same way, and it says what it couldn't tell.

Write-up: https://smallprint.dev/blog/what-mcp-servers-cost

Scripts and counts (no tool text): https://github.com/gostanos/smallprint-tools/tree/main/lab/context-cost

I built Small Print, which is where the versions came from.

I've been digging into the 2026 MCP spec and just finished writing up how subscriptions/listen works.

The API itself is pretty straightforward. The interesting bits are what happen around it:

• The server has to acknowledge the subscription before sending notifications.
• Notifications tell you something changed; they don't carry the resource contents.
• Reconnecting doesn't replay the events you missed.
• If you're running multiple server instances, they all need to hear about changes somehow.

I also put together some Python examples with the MCP SDK and tested the behavior in memory.

The multi-instance bit is especially interesting because a setup that works perfectly on one process can quietly stop working once you scale out. Classic distributed-systems fun. 🙃

I wrote up the details and some practical caveats here:
https://pournasserian.com/writing/mcp-2026-subscriptions-listen

For folks building MCP servers: how are you handling fan-out and cache refreshes after reconnects? I'd be interested in hearing what approaches have worked for you.

Now that the protocol has ditched mcp-session-Id and moved everything to inline _meta, cloud deployments are a breeze, but refactoring stateful tools is proving to be a bit of a headache.

If you have a tool that requires human approval or multi-round-trip data, how are you persisting context between those independent requests now?

Curious to see how everyone is structuring their architecture for this shift. What's working best for you?

I've been thinking about a fundamental shift in how people interact with digital services, especially on mobile.

Today, when we need something, we search for an app, install it, create an account, learn its interface, and use it.

But what happens when ChatGPT, Claude, Gemini, or another general-purpose LLM becomes our primary interface?

Instead of navigating between dozens of apps, users simply express what they want in natural language:

"Find me the best option, compare prices, and get it done."

The LLM understands the user's intent, determines which external capabilities are needed, and orchestrates agents and services through MCP or APIs.

The LLM becomes the interface. Apps become executable services behind it.

This could fundamentally change how software products are created and distributed.

Businesses might no longer need to build a dedicated mobile app for every service. Instead, they could expose their capabilities directly to LLMs.

But there's a major unresolved problem:

How does a general-purpose LLM discover an MCP service that neither the user nor the LLM knows exists?

Today, most MCP integrations still require manual configuration, preconnected tools, or discovery through specific directories.

Simply publishing an MCP server doesn't guarantee that ChatGPT, Claude, or Gemini will find and use it.

So I have three questions:

1. Could MCP discovery become the next Google Search, indexing executable capabilities instead of web pages?
2. How will LLMs discover, evaluate, and select competing MCP services based on user intent?
3. Could a new business launch an MCP-first service and acquire customers organically through LLMs, without requiring users to discover or install a dedicated app?

The real opportunity may not be building another app. It may be building services that LLMs can discover and execute on behalf of users.

Is anyone working on truly autonomous MCP discovery, where the LLM finds a previously unknown service without the user having to configure it first?

Between September 29 and October 22 we shipped 24 releases of CrawlForge MCP, v6.12.1 through v6.24.0. Most of the fixes came from two live sweeps of all 31 tools against real sites.

00:00 24 releases, 24 days

00:08 Two live sweeps of all 31 tools

00:15 01 Failed calls cost 0 credits

00:25 02 Session page cache: repeat reads for 1 credit

00:36 03 Agent citations you can check

00:46 04 extract_embedded_state reads more frameworks

00:53 05 Browser snapshots wait for the page

01:01 06 Every hop through the SSRF guard

01:09 Upgrade

What changed:

- Failed calls cost 0 credits, on the MCP server and the REST API

- A repeat read of the same page within 10 minutes costs 1 credit (maxAge: 0 forces a fresh fetch)

- The agent tool must source every URL it cites; any it can't are listed in provenance.unverified_urls

- extract_embedded_state reads Nuxt 3, SvelteKit, YouTube, Remix, Inertia and Shopify data, with find and keys_only

- Browser snapshots wait for the page to settle, see inside shadow roots and iframes, and can reject cookie banners

- Browser traffic goes through an SSRF guard proxy; web search runs on the Brave Search API

- No tool added, no list price changed

Upgrade:

npm install -g crawlforge-mcp-server@latest

Full release notes: https://www.crawlforge.dev/blog/crawlforge-v6-24-reliable-web-scraping-mcp-server

Start free with 1,000 credits: https://www.crawlforge.dev

Music: "New Bass 01" by Lily J (Mixkit)

I would like to experiment with using MCP servers without ongoing costs. I've got the Openwork desktop app setup with a local IMAP email MCP server on my Windows machine, it's working well and I can choose the model that I want to interact with that.

How could I do similar on my Android phone? I don't want to have to leave my Windows machine switched on to have it communicate with that. Is there a way I can run an IMAP email MCP server on my Android phone and have it communicate with a suitable Android app that supports MCP servers? I'm not sure that AnythingLLM Mobile supports MCP servers, right?

I'm the dev of Ambrel, a Mac app for saving screenshots and visual references. I added a local MCP server: you choose which boards to share, and Claude, Cursor or Codex can search your captures, view the images, and read their text, links and color palettes.

Example from the video: "Design the hero in the style of my Photography board" → the model calls search_captures, sees the warm tones and the mustard accent, and uses that palette.

Everything is local; nothing gets uploaded anywhere. 21-day free trial, no account: https://ambrel.app. I'd love to hear what tools you'd want exposed.

openprefs.ai

Claude Plugin: https://claude.ai/directory/openprefs

ChatGPT Plugin: https://chatgpt.com/plugins/plugin_asdk_app_6ad84413c884819181dc1ef7043d7cd4

Connect an MCP server to Claude, ChatGPT or Cursor and your agent stops just answering questions. It can create records, update statuses, schedule campaigns.

That changes how the prompt should be written.

Split the instruction in two

Rather than:

Create deals for this week’s orders in my pipeline.

Write:

Find conversations from the past week where customers sent shipping details. Create a deal for each in the Online store pipeline at the Order placed stage, with contact, product and price from each conversation. Show me the full list and wait for my confirmation before writing anything.

Same job. But you see what the agent thinks you meant before it’s permanent.

What actually goes wrong

Rarely a wrong answer. Usually a sensible action applied to the wrong records.

The agent decides “this week” starts Monday when you meant the last seven days. Or it counts a conversation where someone asked about shipping and never ordered.

Rereading your prompt won’t show you that. Reading the list will.

Three things that make it work

1. Be explicit about what qualifies. “This week’s orders” leaves a lot unsaid, and the agent fills the gap with its own definition.
2. Ask for the rows, not a number. “I found 23 matches” tells you nothing. The 23 rows tell you whether it understood.
3. Put the pause before the write. Create them, then show me what you did is a completely different prompt with none of the benefit.

One more habit

Turn on fewer tools than you think you need.

Every tool you enable is an action that can happen, and the agent won’t reliably tell you where its limits are — our own docs warn it may not recognise them. If a tool isn’t enabled, that stops being a problem.

Anyone got a structure they trust more? The confirm step works, but it means reading lists all day, and I doubt it holds up past a certain volume.

I’m the creator of skillEd, an open-source evaluation toolkit with a local stdio MCP server.

The use case is a skill that repeatedly applies a policy, such as refund eligibility and rounding. When the skill changes, I want the agent to inspect explicit cases and compare the results, rather than decide the new wording looks better.

The MCP server starts with:

skilled mcp --workspace /absolute/path/to/project

The default interface supports validation, dry runs, report comparison, and workflow guidance. Live evaluations through the configured engine require starting it with --allow-execution; the host’s approval controls still apply. Model usage is billed by the configured engine as usual.

A practical loop is: validate the skill and cases, inspect the planned run, run the permitted evaluation, revise the skill, and compare the before/after reports. Comparing existing reports does not require another model call. Keep independent holdout cases so a revision is tested beyond the examples it was written to fix.

This provides evaluation evidence, not runtime policy enforcement. Permission checks and approval gates still belong in the host/application. The server is intended for a trusted local workspace; I’m not presenting it as a multi-tenant authorization service.

Code, setup, and the worked refund example: https://github.com/DeadHead04/skillEd

If you maintain agent skills through MCP, try the validation and saved-report comparison flow. I’d appreciate feedback on whether the tool boundaries are clear, especially which steps you want exposed without execution enabled. If it’s useful, a GitHub star would help.

I'm Ben, I built this. JENNi is an inventory network: local retailers connect their store once (Shopify, Square, WooCommerce), and any channel, including AI agents, can sell that stock with same-day delivery from the nearest shelf.

For agents it's a public streamable-HTTP MCP server, no auth, no API key:
https://shop.jennipro.com/mcp

Tools: search_catalog, get_product, get_buying_options (verifies the delivery promise for a ZIP), start_checkout (returns a hosted checkout link). The agent never pays; the shopper reviews the total and pays on our page.

Last night I ran 14 shopping prompts across 14 US metros (Seattle to Miami): all 14 returned local in-stock items and a working checkout link. Median latency: search ~1.2s, buying options ~0.4s, checkout link ~0.4s.

Try it in Claude, Cursor, or any MCP client:
"Use the JENNi MCP at https://shop.jennipro.com/mcp to find [item] near [ZIP] that can arrive today, and give me the checkout link."

It's beta, and rough in places: ETAs are date-only (no hour window yet), sized items are one listing per size, and there are some duplicate results. Break it and tell me what failed, that's exactly what I need.

Discovery: /.well-known/mcp.json, /openapi.json, /llms.txt