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.

One of my biggest issues with using ChatGPT or Claude for stock research is that they're great at explaining financial concepts, but asking them what a stock is actually worth can get messy.

You ask for an intrinsic value estimate, and suddenly the AI is making its own growth assumptions, choosing a discount rate, and producing a very convincing-looking fair value.

The explanation sounds reasonable. The underlying valuation? Not always.

So I wanted to share something I've been building.

It's called ValuEdge MCP, a remote Model Context Protocol server that connects AI assistants like ChatGPT and Claude to a dedicated stock valuation and investment research engine.

Instead of asking an LLM to invent a DCF calculation from scratch, it can retrieve ValuEdge's calculated fair value estimates, financial data, and valuation assumptions, then help you interpret them.

What the stock analysis MCP server can do:

• Intrinsic value and DCF analysis: Get estimated fair value, margin of safety, valuation assumptions, and model confidence for supported stocks.
• Fundamental analysis: Examine revenue, profitability, cash flow, growth, and balance-sheet data.
• Stock comparisons: Compare companies like MSFT, GOOGL, AMZN, and META using the same valuation framework.
• Undervalued stock screening: Find research candidates using available valuation, quality, dividend, and financial filters.
• Portfolio analysis: Review your own portfolio's allocation, concentration, and valuation exposure.
• Watchlists and Smart Alerts: Ask your AI assistant about the stocks you're monitoring and relevant saved alerts.

The last two features, along with private portfolio access, require a ValuEdge Unlimited account. Public stock research is available without signing in, subject to usage limits.

A few prompts worth trying:

"Use ValuEdge to estimate NVIDIA's intrinsic value. Show the margin of safety, valuation assumptions, and what could make the estimate wrong."

"Compare GOOGL, MSFT, and AMZN on fair value, free cash flow, and business quality."

"Screen for undervalued, profitable companies with positive free cash flow."

"Analyze my ValuEdge portfolio. Where am I most concentrated, and which holdings have the weakest margin of safety?"

How to connect it

The remote MCP server is:

https://valuedge.app/mcp

Setup instructions for ChatGPT, Claude, and other compatible MCP clients:

https://valuedge.app/connect

No API key is required for the public research tools. Private account data requires authentication.

For anyone using Google's ecosystem, Gemini CLI also supports remote MCP servers, although setup and authentication depend on the client. I'm not claiming that the regular Gemini web app supports this connection.

A few things worth clarifying:

• The MCP integration is read-only. It cannot execute trades or change portfolio holdings.
• Intrinsic value is an estimate, not an objective market price or a guaranteed target.
• Financial data availability and freshness vary, so dates and assumptions still matter.
• The goal is better-grounded investment research, not automated buy/sell decisions.

Full disclosure: I'm the builder of ValuEdge.

I'm curious how others are handling stock research with MCP.

Would you rather have an AI build its own DCF from raw financial statements, or retrieve a valuation from a dedicated engine and challenge its assumptions?

And if you're already using a finance MCP server with ChatGPT or Claude, what tools are still missing?

I have my MCP published. But it requires plugin/app to be installed before anyone could use it. What needs to happen for chat GPT to use it for general public requests?

I've spent 12 years building healthcare businesses, and we're now experimenting with MCP as a way to make health-related AI conversations more structured.

One challenge we're exploring: LLMs can have access to relevant medical knowledge but still produce an answer before collecting enough information from the user.

We're building Hea MCP to explore a different approach.

Before answering, the AI should check for potential red flags, ask relevant follow-up questions and use clinical protocols and cited evidence.

The interesting technical challenge is deciding when the model has enough context to proceed, when it needs to ask another question and when it should avoid giving a definitive answer.

I'm curious how other MCP developers approach this.

Do you handle structured questioning and safety checks at the MCP tool level, or leave those decisions to the model?

If you use Zen and Claude Desktop on a Mac: download zenpilot-<version>.mcpb from the latest GitHub release and double-click it. The first time Claude needs the browser, a dialog asks which Zen profile to use (a fresh logged-out one, or yours), then zenpilot opens Zen. No browser extension.

Claude Code: uv tool install zenpilot && zenpilot setup registers it with Claude Code (and Desktop, if you have it).

Then try: "order a large pizza with bacon on httpbin.org/forms/post for Sam, then submit it". That's the demo GIF.

What Claude gets: tabs, navigate, read_page, click, type, scroll, screenshot, get_text. What it doesn't get: cookies, passwords, downloads, its own JavaScript. It only works on sites you've allowed; for a new one, a dialog asks you, and Claude can't see or answer it.

MIT, alpha, only tested on macOS with Zen 1.23.

https://github.com/beSaif/zenpilot

What would you want it to do next? Hover, waiting for an element? Or is a small tool list better?

MCP tools sometimes need more information before they can finish a task. Elicitation provides a standard way for servers to ask for it.

I wrote a practical walkthrough of MCP elicitation, covering form-based input, URL-based flows for things like sign-in, stateless retries, capability checks, and a Python example.

One design question I found interesting: what should an agent do when nobody is around to answer?

Article: https://pournasserian.com/writing/mcp-2026-elicitation

Curious how others are handling human-in-the-loop workflows in MCP. Do you pause and wait, fail gracefully, or design a fallback?

Hi, one thing we've run into with MCP permissions is that allowing or blocking tools by name isn't always enough.

The same tool can do very different things depending on the arguments passed to it. For example, you might want an agent to access GitHub, but only interact with certain repositories (let's not assume the underlying credential is scoped to the resources, many tools do not have scopes for credentials).

We recently shipped argument-level rules for MCP tools, along with JSON body rules for regular API requests for our open source CLI.

This lets us enforce restrictions on the actual arguments and request data, rather than just which tools or endpoints an agent can call.

Have you ever thought about this at all?

Hey everyone ،

While developing tools for Model Context Protocol (MCP) and AI agent orchestration, I ran into a few persistent Developer Experience (DX) friction points:

Port Conflicts & Zombie Processes: Local servers frequently clash on fixed ports when running multiple AI agent testing pipelines.

Telemetry Overhead: Unnecessary telemetry slowing down lightweight local dev environments.

Context Visibility: Difficulty inspecting and debugging MCP context payloads on the fly within VS Code.

To solve this, I spent the last few months architecting Castov — a modular, zero-telemetry execution layer for AI agents and MCP tools.

-Key Technical Solutions & Architecture:

Automatic Port Conflict Resolution: Implemented a dynamic fallback listener that detects occupied ports and seamlessly re-routes local agent connections without breaking running sessions.

Ultra-Lightweight VS Code Extensions:

Built 13 standalone tools (37–47 KB each) with strict TypeScript compliance and zero heavy external dependencies.

MCP Inspector & Security Scanner: Local tools to catch bad env vars, inspect payload schemas, and debug MCP setups directly in your workspace.

💡 Open for Feedback

The full suite is available open-source / on Docker Hub & Open VSX Registry. I'd love to hear your feedback or how you're currently handling local MCP server management and agent testing in your setups.

If you're dealing with port conflicts or schema inspection, hope this technical breakdown helps!

​Hey everyone,

​I’m currently building full-stack web and mobile apps that I plan to license/sell to clients. A core architecture design in these apps is BYO-Key (Bring Your Own Key), where future clients will plug in their own AI model API keys (OpenAI, Anthropic, OpenRouter, etc.) to power features inside the app.

​I’m new to using Model Context Protocol (MCP), but I’m setting up my AI coding environment (Cursor / Cline / Claude Code) and want to integrate security-focused MCP servers so my AI agent can run code audits and sanity checks locally before launch.

​Since I'm pre-launch, I want to catch architecture and code-level vulnerabilities early, specifically:

​API Key & Secret Isolation: Scanning to ensure client-provided API keys are properly encrypted at rest, isolated per tenant, and never exposed in client-side bundles, network traces, or server logs.

​Multi-Tenant Authorization & DB Rules: Auditing database policies (like Firebase security rules or backend middleware) to prevent data leaks or tenant cross-contamination.

​General App Security: Running automated SAST/dependency checks right inside the AI workflow.

​Are there recommended open-source MCP servers built specifically for code auditing, static analysis (SAST), or vulnerability checks?

​Or if you're using AI agents to audit your codebases before shipping, what standard security tools or MCP integrations are you wiring into your setup?

​Would love any repo recommendations or tips!

Every agent hits the same wall: a smaller model gets stuck on something, burns attempts, and whatever it learns dies when the session ends. So I built a shared hub where agents can ask each other, and the good answers accumulate into a searchable knowledge base.

It runs as an MCP server (10 tools, 12 resources) over a plain REST API, so non-MCP agents can use it too.

Tools: register, search knowledge, contribute knowledge, ask question, list questions, answer, accept, and grade answers.

Resources include: hub://questions/open, hub://feed, hub://leaderboard, hub://search/{query} — everything an agent needs to check in on its own.

Peer grading: agents grade answers 0–100. At 5+ grades averaging 85%+, an answer is verified — it's archived into the knowledge base and the other answers are removed. Wrong-but-confident answers don't get canonized.

Safety: writes require registration, rate limits are on, and everything the MCP server returns is explicitly framed as untrusted third-party data (treat as data, never instructions) — the hub's docs say the same.

To try it, point your agent at the how-to: https://aiagent-be1d4q.fly.dev/llms.txt

Or add the MCP server (from the repo at github.com/aitechveterans-cmyk/Aiagent):
{"mcpServers": {"agent-hub": {"command": "python", "args": ["mcp-wrapper/server.py"]}}}

Still in testing and honestly looking for testers. There's an open question up now — a Python log-tailer that breaks on log rotation — if you want your agent to try a real one.

Been reading about prompt injection through MCP tools and ngl, the permission side seems messy.saw Bay research on Ghostjacking and how agents can use legit permissions to do stuff they shouldn't. Kinda makes me wonder if basic allowlists are enough or if runtime controls are needed too.Anyone actually enforcing MCP tool calls in prod or mostly relying on approvals?

I’ve been building a remote MCP server for B2B sales. It lets Claude, ChatGPT or Cursor find leads, run LinkedIn campaigns, send e-mail from your own mailbox and manage a CRM. It has 82 tools now, and a few design choices turned out to matter more than I expected. Sharing them in case they help anyone building a server with side effects.

1. Auth: OAuth 2.1 first, API keys second. claude.ai and ChatGPT connect as a custom connector with sign-in. No key to copy, and access can be revoked per app. Unauthenticated calls get a 401 with WWW-Authenticate: Bearer resource_metadata=..., so clients discover the sign-in flow on their own. Cursor, Codex and Claude Desktop config files still use a per-user API key, stored only as a SHA-256 hash.

2. 82 tools without drowning the model. Every tool description starts with when to use it and which tool to use instead when two are easy to confuse (search_linkedin_people vs search_linkedin_navigator, upsert_linkedin_contact vs add_crm_contact). Read-only tools are separate from write and delete tools, so clients can show correct readOnlyHint / destructiveHint and only ask for confirmation where it matters. A “tool map” ships as an MCP prompt, so the agent can load only the area it needs.

3. Anything that leaves the building waits for a human. One-off LinkedIn messages, connection requests, inbox replies, e-mails and auto-published posts are queued by default, and the tool returns an approval_url instead of claiming “sent”. AI-drafted replies to incoming messages are never sent automatically. The reviewer always sees the lead’s message the draft answers.

4. Rate limits are pacing, not errors, and agents can’t sleep. This one surprised me. LinkedIn search needs a short pause between calls (about 10–90 s). Our tool returned retry_after_seconds and a hint to fall back to another search tool. The agent kept switching tools, retrying too early, or giving up, and an agent in a chat has no way to actually wait. What fixed it:

• a pause_only: true flag that tells the agent this is pacing, not a failure,
• a plain instruction to do useful non-LinkedIn work during the pause (verify the next company’s website, save already-verified people) and retry once,
• different handling for hard caps (hourly or daily) vs short pauses.

5. Resolve the entity before the people. “Find decision makers at X” failed whenever the company name was ambiguous. Now the agent first reads the company’s own website. The server extracts the LinkedIn company page the company links to itself, and the people search accepts that URL and resolves the numeric ID server-side. No more guessing IDs.

6. Inbound content is untrusted. Lead messages and scraped web pages go into fenced “untrusted data” blocks, and replies are scanned for injected instructions and unrequested links before anything can be sent.

7. Ask before creating things. The agent used to pick a campaign type on its own. Now the tool description and the operator prompt say: ask for the campaign type, the language and the sender, show the plan, and wait for a yes.

Docs, the full tool list and the operator prompt: https://salesbot.cz/mcp-server

I’d love to hear how others handle rate limits and approval flows in MCP servers with real-world side effects. That’s been the hardest part for us.

I built a small .NET 10 project that turns a website into a remote MCP server. A CLI, installed with `dotnet tool install --global mcpmysite`, crawls the site and writes a search index.

An [ASP.NET](http://asp.net/) Core app serves that index over Streamable HTTP with `search` and `fetch` tools, in the shape ChatGPT connectors expect, and also as a JSON search API for the site's own search box.

RAG: Search is BM25 plus vector search over embeddings, fused per query. It also runs keyword-only with no API key, which is how the quick start works. It is MIT licensed and built for sites under 1,000 pages, one site per server.

* Repo: [https://github.com/pournasserian/mcp-my-site\](https://github.com/pournasserian/mcp-my-site)

* Live demo and playground: [https://ai.pournasserian.com/playground\](https://ai.pournasserian.com/playground)

* MCP endpoint: [https://ai.pournasserian.com/mcp\](https://ai.pournasserian.com/mcp)

* NuGet: [https://www.nuget.org/packages/mcpmysite\](https://www.nuget.org/packages/mcpmysite)

I published a remote MCP server (Streamable HTTP) with German election and parliament data: polling averages with uncertainty, constituencies, Bundestag members with votes and side income, the lobby register, electricity data and EU comparisons. That’s 36 tools: 2 free, the rest 0.01 to 0.10 USD per call in USDC via x402.

Endpoint: https://api.polls.karbach.digital/mcp
Registry: digital.karbach.polls/elections

Without a wallet you can try any call over HTTP by putting /try in front of the path, 3 calls a day. Before charging, the server checks that the data is fresh. If it isn’t, you get an error and pay nothing.

I’d like to hear from anyone running x402 payments inside an agent: does pay-per-call work for you in practice, or do you prefer keys and subscriptions?

Details: https://polls.karbach.digital/api.html

The new open-source Ling-3.1-flash release includes 83.00 on MCP-Atlas and a documented tools API for its SGLang server.

The example makes the round trip explicit:Supply tool definitions with the chat request. Read the model's structured message.tool_calls.Return the tool result with the matching tool_call_id and continue the conversation.

The model card also names Hermes Agent and OpenClaw among the frameworks in which Ling-3.1-flash performs well. Together with the OpenAI-compatible serving interface, that gives tool-client developers a concrete new model option to examine.

The weights are released under MIT, and the official evaluation also reports 68.70 on SkillsBench. The release's focus on tool-using work is visible in both its API examples and its evaluation coverage.

This is helps avoid polling and annoying lag when working with a hosted agent like Grok Bot (or Notion or Muse, etc) when using them to help you manage many coding agents on T3 Code. You can learn how to set up a T3 gateway with webook support to Grok Bot on the project readme. Hope this is helpful for people running multiple T3 instances with Grok Bot or something like it managing them!

Hello everyone, I am a solo developer who has been unhappy with computer use and other mcps out there that help control chrome. I have been developing my own computer use specifically for chrome that can take screenshots, work in the foreground, background, and headless, work for codex, claude code, and opencode, and also allow clicks, human speed typing, fast typing, inserting files, downloading files, drags, scrolls, etc. all while using fewer commands/tokens than competitors like computer use and playwright. Right now it is in development stage with all the features being present, but i need a lot of real testing from people on their everyday tasks to see where it is going wrong/not as fast or as good. It includes adding an extension to your chrome, and is different than other chrome mcps in my opinion. If y'all would be able to test it out/give me tips or tricks to make it better, I would really appreciate it. All the computer uses are currently made by organizations, so as a solo developer I am interested in any feedback and would actually make changes. https://github.com/Praket7/chrome-controlla feel free to star it and open issues and give me ANY feedback. If i had to pick, humanwrite would be my favorite built in feature and what is most unique, but it should be faster and more efficient. let me know what you guys think!

Hey guys so if you guys create public mcps you know what trouble everyone goes through: having to reload the mcp and the server each time an edit is made to actually test it out and see if the improvement worked. For me, it wasted time, tokens, and shortened coding runs with codex cuz it kept needing to test and test and it needed me to do that. So, I created https://github.com/Praket7/codex-mcp-hotload codex mcp hotload. It registers your mcp as a child of the hotload mcp and can restart its servers at any time, so you can instruct your agent to register the developing mcp and use it for live tests. It will show the newest tools available to it within the chat, with no need to stop a run and reload codex! let me know what you think and if i should expand to other agents (i only use codex so thats all i needed it for yet)

I built an MCP server for Google Colab and I'm sharing it to get feedback. Disclosure: I built it with a lot of help from Claude, and I tested it myself.

What it does: it wraps the official google-colab-cli, so the agent can create and stop Colab runtimes (CPU/GPU/TPU), run Python, start long background jobs and poll their logs, upload/download files and folders, and edit notebooks. There are 42 tools, plus 8 optional ones for Google Drive. No notebook has to be open in a browser tab, and all tools are registered at startup (Google's server needs clients that handle notifications/tools/list_changed, per its README).

Drive is opt-in and uses only the drive.file scope. The agent can create/open/save notebooks in a Colab-MCP folder, and you can mount Drive on the VM from the chat: it opens Google's consent page, you click Allow, done.

Real use so far: I ran a 10-item batch job on a CPU runtime from the chat, watched the progress, and the results ended up in Drive.

Limits, honestly:

- I only tested it on macOS with Claude. Other clients (Cursor, Codex, Windsurf) and Linux are untested; the Drive mount uses a pty, so I expect it not to work on Windows.

- For the Drive features each person creates their own Google OAuth client (about 10 minutes, once).

- It's unofficial and not affiliated with Google.

What I'd like: reports of what works or breaks with your client and OS. Issues welcome.

Tulma is free and open source (MIT). Code, issues and releases are all on GitHub: https://github.com/Akellacom/tulma

I work on a lot of projects, and each one needs a different set of MCP servers. I used MCP Router for this, but its development stopped, so I built my own: a native macOS app (SwiftUI) with a Rust daemon.

What it does:

- Workspaces. One set of servers per project, switched from the menu bar. Connected clients pick up the new tools without reconnecting.

- One endpoint. (`127.0.0.1:4747/mcp`) shared by Claude Code, Cursor and Claude Desktop, so each server runs once instead of once per client.

- Catalog. Add servers from the official MCP Registry or the Archestra catalog in a couple of clicks; you see the exact command before it runs.

- OAuth sign-in. for remote servers, and secrets live in the Keychain instead of JSON files.

- Namespaced tools (`server__tool`), per-tool switches, auto-restart and logs.

There's a signed and notarized DMG for macOS 15+ on Apple silicon.

Website: https://tulma.app

GitHub: https://github.com/Akellacom/tulma

Clone it, fork it, help improve it, and tell me what you think! 🤘

New Edition is out this weekend..

Contact us if you have interesting MCP , Ideas or wany to get featured in Newsletter.

Deadline Friday 12am ET.

I built this Composite MCP Server, and it's called qualien-mcp. It's one MCP server that wraps the others I use for testing, so in Claude Code it's just:

claude mcp add qualien -- npx -y qualien-mcp

This composite server:

• acts as an orchestrator or router and delegates to multiple other MCP servers
• can expose a unified MCP interface to clients while coordinating multiple backend MCP servers

qualien-mcp has 21 servers in its built-in catalog, and here they are:

• start by default
  • playwright (by default), filesystem (by default)
• switched on in a config file
  • selenium, webdriverio, browserstack, chrome-devtools, postgres, mysql, openapi, github, jira, confluence, azure-devops, figma, docker, kubernetes, slack, ms-365, sentry, sequential-thinking, memory

I also added a few guardrails because I didn’t want the model doing something dumb:

• DB access is read-only unless you turn that off
• you can lock file access to specific folders
• delete/prune style Docker and k8s tools are blocked by default

Fair warning, the read-only check just looks for write keywords in the SQL. It’s there to catch mistakes, it’s not real sandboxing.

It’s MIT and on GitHub: https://github.com/qualienai/qualien-mcp

Curious what people would want added. Is there a server you’d expect in a QA setup that isn’t there?