If you want to debug your MCP OAuth flows easily, we've got you.
In my last few posts, I've been showing coding agent workflows using the MCPJam's CLI to e.g. find and fix OAuth client registration issues.
Here’s that same workflow using MCPJam’s OAuth Debugger in our Inspector: every step of the MCP OAuth flow is logged, tied back to the spec, explained, and sequenced in the UI. When something fails, you can see exactly which part of the flow broke.
In this example, the server fails for dynamic client registration. MCPJam surfaces the raw error, points to the failed OAuth step, and lets you rerun the flow until the server connects.
You can test your server against every protocol version across all client registration methods. My personal favorite feature since it dropped in October.
Check it out at https://lnkd.in/d2jDcmwG#mcp#modelcontextprotocol#mcpjam#oauth
This is what agent-native MCP debugging looks like.
In this demo, a coding agent uses our MCPJam CLI to connect to an MCP server, identify a client registration issue, help the developer fix it, then run protocol and OAuth conformance checks.
Along the way, no tokens were exchanged with the agent directly. The CLI also supports credentials files, so agents can run follow-up commands without you pasting tokens into prompts.
Install with: npm i -g @mcpjam/cli
Check out docs here: https://lnkd.in/g37pUAEJ
OAuth AS used: Stytch#mcp#modelcontextprotocol#oauth#cli
Show agents your MCP Apps UI with: mcpjam tools call --ui
Coding agents can call a tool and see its UI rendered live in MCPJam Inspector.
Agents can inspect more than JSON now. They can validate the actual user interfaces your end-users will see. Try it out by installing the CLI: https://lnkd.in/gzB6bH7g#mcp#modelcontextprotocol#cli#mcpjam
Inspect your MCP servers today with one command: mcpjam
npm i -g @mcpjam/cli
The new MCPJam CLI brings our core Inspector workflows to your terminal: connect to servers, call tools, debug OAuth, and run protocol conformance. It also lets your coding agent debug MCP Apps by rendering tool results in the MCPJam UI!
Pair it with our skill and get jamming:
https://lnkd.in/gF4hssqF#mcp#modelcontextprotocol#cli
Solid high-level read. Personal takeaways:
Some highlights:
- MCP SDK downloads: 300M/month, up from 100M at the start of 2026 -> cool! wonder how much of this is agent-driven
- Core tool design: every tool call is a decision point for the agent. Reduce the # of tool calls to reach your desired user flow. e.g. Cloudflare exposes 2 tools that end up exposing 2,500+ endpoints in ~1k tokens used on defs
- Solid methods for clients to reduce tool-definition token consumption (though not baked in the spec)
...Buts:
- The post calls MCP "the compounding layer." True for the ecosystem: a server built today works with clients that don't exist yet. The distribution of compounding value is skewed toward whoever owns the host/client. More servers/integrations to connect to, more user intent and context, more capabilities they can decide to expose. With each client bringing with it its own discovery, selection logic, capabilities (skills + mcp as plugins), the cardinality of variables that an MCP server team needs to evaluate their server for continues to increase.
- Bundle Skills + MCP to make your MCP server more efficient with plugins: perhaps, though yet another variable for an MCP server team to evaluate their server on now. Solve the MxN connection problem, but lets not forget the growing variables to evaluate a server's efficacy
A great Day-1 guide on MCP tool design and best practices - but MCP client leaning as it doesn't address some immediate problems MCP servers will face in actually testing for natural questions that come with e.g. "but how do I know Skills + MCP is actually more effective for my server"?
https://lnkd.in/gpvsRGcY
Connect your MCP server. See a live trace in less than 30 seconds!
With MCPJam, see every tool call, every argument, every latency hop across every service boundary. Captured as an OTel span tree from user prompt to agent reasoning to tool call and back. Watch a demo video below! :)
Model Context Protocol#mcp#modelcontextprotocol
MCP solved the integration availability MxN problem (will link to Pragmatic's Engineer intro on this below): connect to many hosts.
But: OpenAI just shipped sandboxes, workspace manifests, and model-native harness diffs. Anthropic shipped managed agents. Each host now has configurable and different execution architectures that could change tool selection behavior, arg construction, different results rendering.
Is anyone instrumenting tool effectiveness, given this cross-host variance?
pragmatic engineer's MCP intro to MxN: https://lnkd.in/gkjPGy_g
openai's new expanded agents sdk: https://lnkd.in/gwK8rn-7
I spoke at the MCP Developers Summit in NY on behalf of MCPJam. Attached the full 30-minute talk if you missed it.
The talk is called "Evaluate What You Can't See." The core idea:
In MCP, your server/integration can execute perfectly while still failing the user completely and you have almost no visibility into the actual outcome.
In a traditional API integration, your system usually sees enough surrounding context to evaluate success. In MCP, the user's original request, the agent's reasoning, and the user's satisfaction all live outside your system.
I introduced a framework called the User-Value Chain, talked about my evals experience, give 6 concrete ways today for you to get user context in a system that makes it difficult to do, and discuss an what an effectiveness feedback loop looks like.
User-Value Chain: my framework to outline the steps from a user's intent and actual value delivery: Connection → Discovery → Tool Selection → Tool Call → Tool Response → User Value. Most MCP teams only instrument Step 4.
And dove into reliability vs. effectiveness with an X-Y problem lens in MCP, why REST API design instincts don't transfer to MCP tool design, an instrumentation feedback loop for getting signal on effectiveness, and how to build effectiveness evals into CI/CD.
This is what we're building at MCPJam. Not just "does your server work" -> "does your server measurably deliver user value."
I also published the first post in the Effective MCP series, which will dive into more detail about what I covered only briefly in the talk, that goes deeper on the User Value Problem and the User-Value Chain here: https://lnkd.in/g5C2gcGc
Would love to hear from anyone building or maintaining MCP servers. Does this talk resonate? What does your visibility into user outcomes look like today?
Model Context Protocol#mcp#modelcontextprotocol#ai#agents
We shipped two new features at MCPJam this week that should fundamentally expand your visibility and intuition when testing and debugging your MCP servers and apps.
Multi-Model Compare:
Send a single prompt to up to three models simultaneously (including frontier models like Opus 4.6, GPT-5.4, Gemini 3.1 Pro). See exactly how different models handle your tools.
Trace Viewer:
Every chat surface now includes Trace timeline, Chat, and Raw JSON views. The timeline visualizes the full tool call sequence across service boundaries, detailing tool selection, arguments, payloads, and latency across the user, agent, host application, and server.
We've had a lot of fun dogfooding these features and we're excited to share them with you today. Get jamming at https://app.mcpjam.com.
Model Context Protocol#mcp#modelcontextprotocol#agents#ai
Anthropic just launched Claude Managed Agents: production infrastructure for building and deploying cloud-hosted agents. Asana, Notion, Rakuten, and more are already shipping agents on it.
Managed Agents makes it cheaper and faster to deploy agents that call external tools via MCP. When the agent deployment barrier drops, the number of agents calling your MCP server goes up, which means:
Agent-initiated traffic starts to outpace human-initiated traffic for your product.
That shifts what your MCP integrations need to do. Today, most MCP server teams validate that their server works. That's necessary. It's not sufficient.
Your logs show a tool call arrived and returned 200 OK.
They don't show the 1000s of times the agent considered your tool and picked something else.
They don't show the 1000s of times your tool was selected but the response didn't match what the user actually needed.
Anthropic is making it dramatically easier to deploy agents. The question that follows: is your MCP server ready to perform in a world where agents are the primary consumer of your product's functionality?
That's the problem MCPJam is focused on. Not just that your MCP integrations work, but whether they're effective, they actually deliver user value, inside agentic application environments you don't own.
#mcp#modelcontextprotocol#claude#agents