MCPJamMCPJam
Open in web
Back to all posts

Effective MCP, Part 1: The User Value Problem

Prathmesh Patel8 min read

Your users aren't in your app anymore. They're talking to an agent, perhaps in ChatGPT, Claude Cowork, or Cursor. That agent decides when they talk to you. Agents have all the user's context. You get almost none of it.

As users shift their workflows into these agentic applications, capturing closed-loop feedback from production usage has become the hardest part of improving your MCP integration.

To make this concrete, let's look at an example.

Two users with similar sessions and tool calls producing nearly identical logs with 200 OK responses
Example: Two users, similar sessions, two tool calls, nearly identical logs that result in 200 OK successful status codes from the integration’s perspective for the two users.

Now look at the user prompts that triggered those tool calls:

User prompts that triggered the tool calls showing opposite outcomes
Different user outcomes behind similar-looking tool traffic.

Two completely different user outcomes, but your logs show the exact same thing: successful 200 OKresponses for the same tool calls across nearly identical user sessions. From your system's perspective, you cannot tell the difference. The agent monopolizes all the user's actual intent and context.

The User Value Problem

The problem is this:

In MCP, your integration can execute perfectly while failing the user completely in practice, yet you have almost no visibility into the actual outcome.

In a traditional API integration, your system usually sees the initiating action or enough surrounding context to evaluate success. In MCP, your integration has visibility that a tool was called by an agent. The user's original request, the agent's reasoning, and the user's satisfaction often live outside your system.

Diagram contrasting what the integration sees versus what the user and agent experience
Service boundary and agent monopolization of user context limits what you can see from your integration.

The server backing your integration controls: tool schema, metadata, implementation, and response format. It does not control when those calls happen, what user context surrounds them, nor whether the results satisfy the user.

The Shift to Agentic Workflows

This disconnect is happening because the workflows your product was built on are being completed somewhere else. Users are automating tasks through conversation in applications like Claude Cowork and ChatGPT rather than visiting your website.

Exhibit A

A scheduled task runs at 9am in Cowork. The agent fetches priorities by querying Slack, Linear, and Notion. It sends a daily briefing to the user, without manual intervention.

Cowork agent running a scheduled Daily priorities task across Slack, Notion, and Linear
Chat and rendered Daily Priorities diagram summarizing tasks by urgency

Exhibit B

A user asks an agent to find homes under $800k in Austin with a yard. The agent queries Zillow's data, compares listings, and generates a slide deck using Gamma AI.

ChatGPT with Zillow integration showing a map and listings for homes in Austin
Gamma slide deck preview for Austin homes under budget with a yard

Your users are actively rewiring how they work. If they cannot access your product seamlessly through their agent of choice, they may abandon your product for a competitor who is integrated.

But simply checking the "we have an MCP integration" box is not a safety net. If your integration is clumsy, if the agent consistently chooses the wrong tool, or if it returns unparseable data, the user won't just blame the agent. They will blame your product.

To survive this shift, you have to be where the users are. But to pull ahead, you have to ensure that your integration is effective: it actually delivers user value.

The Black Box of Intent

Your integration sits behind an opaque boundary. Platforms like OpenAI are pointing out this visibility gap.

In their developer documentation, OpenAI states:

"Discovery in ChatGPT is model-driven: the assistant chooses your app when your tool metadata, descriptions, and past usage align with the user's prompt."

The challenge is measuring effectiveness when the user's intent, the decision to call your tool, and the context of that call all happen outside of your control.

So, how do you know your MCP integration actually delivers user value?

The question isn't just 'does your integration work?' but rather 'did the full chain from user intent to user outcome succeed?' I call this the User-Value Chain. For an MCP integration to deliver real value, several things have to go right:

User-Value Chain diagram
  • Connection
    • The user has to connect your integration successfully with the right auth, account, and permissions.
  • Discovery
    • The host application and agent have to be able to surface and recognize that your integration and tools are available.
    • Tool metadata, descriptions, and how the host application decides to surface available integrations all influence whether discovery happens.
    • Note: also a likely monetization surface for agentic host applications, since agentic host applications control how integrations are surfaced, ranked, and entered.
  • Tool Selection
    • The agent has to choose the right tool for the user’s intent instead of skipping it or picking a competing option.
    • Clear tool descriptions, schema design, reliability, and past successful use may influence whether selection happens, as does the host application's implementation of tool disclosure.
  • Tool Call
    • The agent has to pass arguments that are syntactically valid for your schema: correct types, required fields, formats, enums, bounds, etc.
    • The args should be semantically correct for the user’s intent: the right IDs, dates, filters, etc.
    • If your tool depends on context like account, environment, locale, or permissions, that context has to be passed or inherited consistently.
  • Tool Response
    • Your tool has to return the correct response with acceptable latency and clear errors (notably quite different from API integrations, we'll talk about this later).
    • The agent has to interpret, use, and sequence the response correctly.
    • If the tool is linked to a UI resource, the host application has to fetch and render that UI correctly, initialize it through the standard iframe bridge, and keep the UI in sync with tool inputs and results.
    • The result, whether agent output, UI output, or both, has to feel trustworthy and understandable to the user.
  • User Value
    • The user has to get the outcome they actually wanted.

Real user value is delivered only when the entire chain completes successfully. Most MCP integration teams only observe a small slice of that chain.

Shipping MCP is not just about testing endpoints and fixing bugs. You aren't instrumenting users interacting directly with your product. You are instrumenting agents interacting with your product on behalf of users.

And until you measure the full chain, you do not really know whether your MCP integration is effective.

Why this series exists

This series is about closing that gap.

In the parts to come, we'll map the User-Value Chain's failure modes across the boundary between the host application and your integration. Then, we'll show you how to bridge that visibility gap with an Effectiveness Feedback Loop, moving your system from 'our MCP integration works' to 'our MCP integration measurably delivers user value.'

The MCP integration teams that compound user value over time will pull ahead. They will be the ones observing, evaluating, and optimizing the entire path from user intent to user outcome.