What the MCP Roadmap Means for Trading Research Servers
What the new MCP roadmap means for trading research servers: identity, long-running tasks, progressive discovery and result contracts beyond a long tool list.
This article is published in English.
The MCP maintainers released a roadmap in late August 2026 covering the next spec cycle and the period after it. Nothing on its list of five priorities is a fresh class of financial data. All five deal with what surrounds a tool call: messaging between agents, a sturdier transport, agent identity, sharper primitives and SDKs you can count on. For a server that serves trading research, that change of focus helps, since a long tool list tells you what an agent can ask for but not who asked, what authority came along, when the answer held true, or whether the job was ever completed.
Finance feels this more than most fields because research output compresses doubt into convincing answers. Think of a compiler-style diagnostic on trading code, a scan of options flow, a quote snapshot and a portfolio risk report: each may show up as tidy structured data, yet they aren't the same kind of thing. Every one runs on its own clock and draws on its own source and universe, fails in its own way and feeds a different decision.
The next bar for a trading MCP server, then, has little to do with how many tools its setup page lists. What counts is whether somebody can rebuild the request and the result without taking the model's word for either.
Why a tool list alone is not enough
MCP began as a tidy method for models to find and invoke external abilities. Tool names, descriptions, input schemas and output shapes still help a client work out what's possible, so the list keeps its value.
But the protocol has outgrown a simple list. With the 2026-07-28 release, the spec removed the initialisation handshake and session ID at the protocol level, let requests describe themselves, added server discovery plus cache hints, formalised extensions and tightened authorisation. A remote MCP server now resembles any other HTTP service.
The roadmap picks up from that point and poses further questions. How should work that takes a long time report back? How does a server recognise an agent? How will clients find their way through a growing set of capabilities? How can tool results behave the same way each time, and how can SDKs show they conform? A server may expose an excellent tools/list reply and still leave all of those unanswered. They concern how the system operates, not how it's described.
Finance makes the gap obvious fast. "Get a stock snapshot" names an interface. Behind it you must still settle which universe of data applies, when the observation happened, where it came from, how caching works, what permissions were in force, how errors surface, and whether a later call could reproduce the same evidence.
Slow research needs a lifecycle, not a progress bar
The roadmap observes that current agent workloads rarely follow one request and one reply. Jobs can last minutes, servers might stream or push partial output, and a client may want to redirect a task while it runs. MCP already has Tasks, subscriptions/listen and progress notifications, and its maintainers want how they start, stop and fail to fit together cleanly.
In trading research the stakes are practical. Say a market-wide screen is launched against one universe and ends once conditions have moved. A code check over many files could report on a few and then lose a worker. A backtest may produce simple statistics well before a heavier resampling stage is done. A portfolio review might receive nearly every position and lack one data feed.
With only "running" and "done" to go on, a client will treat whatever payload comes back as the final word. Better states are accepted, running, partly available, completed, failed, cancelled and unknown, together with a rule on which artifacts remain trustworthy in each.
Progress isn't evidence of completeness. A streamed result should say what portion is available and what work remains. A cancellation acknowledgement shouldn't pass for an observed terminal state, and a cached result shouldn't take on the timestamp of the request that fetched it.
The roadmap doesn't supply every financial state label. It names the protocol problem, and servers and applications still have to preserve what partial work means.
Agent identity isn't a bearer token
Today's MCP authorisation spec revolves around a resource owner letting an MCP client reach a protected server. Support is optional. Wherever an HTTP implementation offers it, the spec describes an OAuth-based flow along with the discovery and token rules that go with it.
The roadmap highlights a newer identity worry. Increasingly, callers are cloud agents running unattended, acting for a person, for a service or via a narrower sub-agent. A server has to distinguish between those, and between the powers each one holds.
A pasted API key or bearer token can prove a request is authentic. It won't necessarily settle the following:
- Which agent workload made the call?
- Which user or organisation delegated the authority?
- Was the token meant for this server and this action?
- Whether a sub-agent was handed less authority than the agent above it.
- Whether the credential could be replayed from somewhere other than the workload it was issued to.
Areas the roadmap names include proof-of-possession, workload identity federation, agent delegation and token exchange. They are lines of work. Nobody should infer that all MCP clients and servers already follow an agent-identity standard.
This matters in finance even if every tool only reads. Queries can leak holdings, watchlists, in-house code, unpublished assumptions or licensed data. Saying a tool cannot place an order limits one outcome, but it says nothing about who may view or combine the information underneath.
Progressive discovery changes the control surface
Tool growth brings a second problem. As the roadmap notes, a server with a hundred tools makes the model take in the entire surface before the user has asked anything, and selection quality tends to fall as the list lengthens. The maintainers are starting a progressive-discovery effort in which a server reveals a small entry point and widens the catalogue as the conversation narrows.
For a financial server this can do more than save context. It can keep apart domains that shouldn't be mixed. Checking a piece of trading code might call for tools about the language, platform, source and compiler version, yet never for an options-flow scanner. Company research may need filings, fundamentals and event context but not portfolio holdings. A risk review may need portfolio data without being able to search every outside source. The safest useful catalogue is often the smallest one that can answer the declared task.
Dynamic reveal creates its own need for evidence, though. When tools appear on demand, the audit trail should note which catalogue and policy the client saw at the moment it chose a tool. Without that, a reviewer looking later may meet a different surface and be unable to explain the choice. Discovery therefore belongs in the control record, versioned, scoped and rebuildable, and mustn't stay a mere convenience.
Structured output still needs financial meaning
The roadmap also admits to ambiguity in tools/call results. One response may hold overlapping structured and unstructured versions, and clients can show the model different ones. Maintainers want a firmer contract.
Consistency is needed, but finance has domain meaning that a generic result wrapper can't work out for itself. The charter of the MCP Financial Services Interest Group admits as much. It puts portable audit records, data lineage and provenance, attestation, policy enforcement that machines can check, and finance-specific extensions in scope. What it offers is a list of requirements and work areas, with no certification or completed compliance layer behind it.
So for a research result, structure must stretch past valid JSON. A reviewer may need, depending on the tool:
- the source, or at least its type;
- when it was observed and when it was fetched;
- session, timezone and universe covered;
- a label saying whether the figures are live, delayed, cached, estimated or derived;
- whether the output is partial or final;
- versions of tool, schema, model and dataset;
- any warnings, absent fields and known gaps in coverage.
Such fields don't make a conclusion correct. They expose its assumptions enough to be challenged.
What a real catalogue shows
Take a typical remote financial MCP server offering a couple of dozen read-only tools, behind a bearer token, claiming it can't place trades or alter positions. That gives you a public catalogue and a stated limit on actions. Whether the tools are accurate, the sources fresh, the token scoped to the right audience, credentials rotated, delegation handled, discovery progressive, tasks tracked, results traceable or every client well-behaved is still unproven.
A list that size already raises the design question, though. A single catalogue can stretch from code checks to company data, options and dark-pool colour, market regimes and portfolio work, and those jobs have neither a shared clock nor a shared evidence model.
Growth in the list would make progressive discovery attractive for cutting selection noise. Calls that run long call for partial and terminal states. Cloud agents acting for users mean holding a token no longer describes the whole workload identity. And when results guide research choices, source and as-of details must outlast the model's own prose. The roadmap makes these review questions harder to dodge.
Reviewing a workflow with two envelopes
An application can convert the roadmap into two records. Treat them as engineering synthesis: neither is a new MCP primitive nor a regulatory safe harbour.
The request envelope explains the call:
- the actor workload and client identity;
- the user or service being represented;
- the delegated scope and policy decision;
- the declared research purpose;
- versions of protocol, server, client, catalogue and tool;
- the universe asked for, and any point-in-time limit.
The result envelope explains the evidence:
- where the data came from and what it may be used for;
- when it was observed and when it was fetched;
- session, timezone and universe covered;
- which tool and schema produced it;
- whether it's partial, final, failed, cancelled or of unknown status;
- caveats, gaps, whether it came from cache, and any transformations applied;
- how a person or downstream system dealt with it.
The model may summarise both envelopes but shouldn't be their only home. A persuasive paragraph makes a lossy audit record.
One caution: extra metadata can turn into ritual. Logging every field achieves little when no reviewer knows which invariants matter. Aim for a minimal record tied to the claim the tool is supposed to support, and skip maximal telemetry.
A direction, not a certification
The official roadmap sketches a vision for roughly the next six to twelve months and says outright that priorities may shift, ship differently or slip. No product can point to it as proof that agent identity, progressive discovery, result contracts or SDK conformance are done.
Teams should check the protocol version, SDK support, server build and application evidence they actually run, and in financial settings supply domain meaning the base protocol cannot guess.
Showing a tool call is simple. Proving what's left once the demo ends is harder: who called, with whose authority, against which catalogue, on data from when and where, and what terminal result came back.
Pick any answer a financial agent produced. If you can't rebuild its request and result envelopes without leaning on the model's own account of events, the missing piece isn't another tool but an evidence contract.
This is general technical background on research infrastructure, not investment, legal, security or compliance advice.