Contents
  1. Purpose and architecture
    1. Reusable access to external capabilities
    2. Hosts, clients, servers, and models
    3. Turning points in capability exchange
  2. Exposed interfaces
    1. Tools describe callable operations
    2. Resources name information
    3. Prompts return reusable messages
  3. Protocol exchange and discovery
    1. Read a versioned exchange
    2. Build and refresh the catalog
    3. Local processes and remote transports
    4. Continue when input is required
  4. Authority and application control
    1. Acquire access to a protected server
    2. Enforce authority at each boundary
  5. Execution and failure
    1. Trace one issue creation
    2. Interpret errors and interrupted requests
    3. Separate durable tasks from live requests
  6. Verification and choice
    1. Verify the integration and choose its boundary
  7. Check understanding
  8. Open questions
  9. Selected talks
  10. References
  11. Talk library
← All topics

MCP

MCP gives AI applications a common interface for discovering and using external capabilities. Servers expose tools, resources and reusable prompts; hosts decide how those capabilities enter the application’s model and user experience. This reduces the need for a different connector for every application-service pair while leaving permission and execution decisions with the responsible systems. This chapter uses core revision 2026-07-28 to explain that exchange and how to implement it.

Purpose and architecture

Reusable access to external capabilities

Model Context Protocol (MCP) is a shared interface between applications and providers of external capabilities. Instead of every application inventing a different way to describe and discover an integration, a provider exposes tools, information, and reusable messages through a common contract. Interoperability means independently implemented components can exchange those capabilities using agreed rules.

The service-specific integration still exists. Someone must translate requests into the backend's operations and interpret its responses. Linear's hosted MCP service, for example, supplies centrally maintained access to issue-management operations. Applications can reuse that interface, but still need compatible clients, suitable permissions, and a workflow that uses the returned information correctly.

A direct function or SDK call is often simpler when one application controls both sides. MCP becomes attractive when several applications should reuse a capability provider without duplicating its integration. That benefit comes with a server to operate or trust and a compatibility boundary to test. The useful decision is where reuse earns those obligations—not whether every operation should become MCP.

Hosts, clients, servers, and models

The host is the application coordinating the experience, model access, context, permissions, and consent. An MCP client is its protocol-facing component for communication with one server; a host can contain several clients. An MCP server exposes capabilities through handlers, which may call a separate backend, such as an issue tracker. These are logical roles, not a requirement for separate machines. A server can be a local subprocess or a remote service.

Tool calling is a different interface: a model proposes an operation and arguments; executable application code performs the accepted call and returns its result. The host can adapt MCP tool definitions into the model's tool format. The published LangChain MCP adapter makes that separation visible by loading MCP tools and then passing them to an agent with a separately selected model. Its example illustrates adaptation, not conformance to this chapter's protocol revision.

No model is required to invoke MCP. Application code can deterministically list capabilities, read resources, or call a known tool. Cross-server coordination can also remain in the host without putting every intermediate payload into model context. The model-facing interface is developed in Where MCP meets the local action boundary; acceptance and execution checks belong in a controlled dispatcher.

The enclosure denotes logical ownership, not isolation. The host adapts model proposals and accepts actions before dispatch; deterministic code can invoke the same interface without a model. Server-side adaptation connects MCP to the backend API.

Turning points in capability exchange

Reusable providers solve a recurring integration problem: independently developed consumers otherwise need separate adapters for the same capability. MCP applies that separation to AI applications. Its history also explains why older examples can teach sound interface ideas while showing incompatible connection mechanics.

DevelopmentContribution
Language Server Protocol — June 27, 2016Microsoft, Red Hat, and Codenvy's announcement described reusable language services across development tools. MCP explicitly identifies LSP as an inspiration for separating consumers from capability providers.
Model-facing function calling — June 13, 2023OpenAI's announcement introduced model-generated JSON arguments for developer-described functions. This predates MCP but addresses the model–application interface, not reusable server communication.
MCP public introduction — November 25, 2024Anthropic open-sourced MCP to reduce repeated custom integrations with isolated data sources. The launch included SDKs, reference servers, and local-server support in Claude Desktop; remote production tooling was forthcoming.
Streamable HTTP — March 26, 2025This revision replaced the earlier HTTP-plus-SSE transport and introduced an OAuth-based authorization framework. Specification changes did not imply simultaneous client adoption.
Self-describing requests — July 28, 2026Maintainers David Soria Parra and Den Delimarsky explained a shift away from connection-bound protocol state to address reliability and scaling difficulties. Applications could retain state through explicit handles.

These developments coexist. A model can propose an ordinary local function call, an MCP server can wrap an established API, and a host can choose either path. The later protocol changes matter because they alter how an exchange carries its assumptions—not because they eliminate service-specific behavior or distributed failures.

Exposed interfaces

Tools describe callable operations

A tool definition advertises an executable operation through a name, description, input JSON Schema, and optional output schema. A schema describes permitted data structure; it does not implement the operation. tools/list discovers definitions, while tools/call requests execution using a name and arguments. Names belong to their server. See Tool definitions shape available choices for designing the model-facing description.

For a teaching adapter, a minimal create_issue interface could use these artifacts. These are excerpts, not complete wire messages or Linear's hosted tool schema.
ArtifactExampleMeaning
Definitioncreate_issue; required string fields teamId and titleAdvertises accepted input shape.
Invocation arguments{"teamId":"team-A","title":"Fix login"}Requests an operation; no result exists yet.
Result excerptstructuredContent: {"issueId":"issue-42"}Server-produced data, not model-generated arguments.

Result structure needs careful interpretation. JSON serialized inside a text content block remains text; it is not the structuredContent field. GitHub's inspected issue-comment handler illustrates this distinction: after backend creation, it returns an ID and URL as serialized JSON in a text result. A host must adapt the actual representation it receives rather than infer the representation from how the text looks.

When an output schema is supplied, results must conform and clients should validate them. A JSON-RPC error differs from an execution failure returned with isError. Neither a well-shaped result nor an annotation such as a read-only hint establishes authority or the intended business effect.

Resources name information

A resource exposes information identified by a Uniform Resource Identifier (URI). A URI names something; it need not be an HTTP address. resources/list returns descriptions, resources/read retrieves content, and resources/templates/list exposes parameterized addresses. Expanding a template selects a URI to read rather than invoking a tool. Content entries can contain text or base64-encoded binary data, with a media type identifying the representation.

A constructed issue resource separates its address from its representation:
ObjectExample
Addressissues://team-A/42
Listed metadataName: Issue 42; media type: application/json
Read content{"title":"Fix login","state":"Backlog"}
Model inputThe host's selected representation of that content

The distinction from tools is not simply reading versus writing: tools can retrieve data too. Resources give applications an addressable information interface. Reading one does not automatically include it in model input. That selection is context assembly, covered in From sources to a request.

Resources can also carry procedural information. Backlog.md exposes a workflow overview and guides for task creation, execution, and completion alongside its callable tools. This gives the host material explaining how to use operations, but availability alone does not ensure that the host reads it or the model follows it.

Prompts return reusable messages

An MCP prompt is a discoverable, parameterized template that returns messages. prompts/list describes templates and their arguments; prompts/get supplies a name and argument values. The server resolves the template, and the host decides whether and how to use its messages. For example, a constructed review_issue template could expand an issue identifier into a user message requesting a review. Retrieving that message does not perform the review.

Prompts are conventionally user-selected. A slash command is one presentation, not a required interface: Mahesh Murag's MCP workshop describes a Zed command that accepts a pull-request identifier and prepares a longer summary prompt. User selection does not make server-authored instructions trusted. Instruction design itself belongs in Prompting and In-Context Learning.

The three interfaces can concern the same service while returning different kinds of artifacts.
InterfaceRequest and returnRemaining application decision
ToolOperation and arguments → execution resultWhether to execute and how to interpret the outcome
ResourceURI → informationWhether and how to include it in context
PromptTemplate and arguments → messagesWhether and how to use those messages

Protocol exchange and discovery

Read a versioned exchange

A remote procedure call (RPC) requests an operation across an execution boundary and returns its result. Birrell and Nelson's February 1984 Cedar RPC paper pursued accessible distributed programming while acknowledging timing and independent failures. MCP uses JSON-RPC 2.0, the JSON-RPC Working Group's transport-independent message convention. A convenient call interface never makes a remote operation behave exactly like a local function.

In revision 2026-07-28, every request carries protocolVersion and clientCapabilities in its metadata. A request names a method and has a non-null string or integer ID, unique among the sender's outstanding requests. Its response repeats that ID and contains a result or error. An error includes an integer code and message. A notification has no ID and receives no response.

Illustrative pseudocode

Python-like pseudocode
# Constructed request; no optional client features advertised.
request = {
    "jsonrpc": "2.0",
    "id": "list-1",
    "method": "tools/list",
    "params": {
        "_meta": {
            "protocolVersion": "2026-07-28",
            "clientCapabilities": {}
        }
    }
}

Capability negotiation tells peers which protocol features they implement. The request's client capabilities describe what the client can handle; server/discover lets it learn what the server supports. Servers must implement discovery, but clients need not call it first. An unsupported version produces UnsupportedProtocolVersionError with supported versions; the client can choose a shared version or report incompatibility. An optional extension needs shared support: otherwise use core behavior or reject the request. Feature support grants no permission, and this revision requires no connection-scoped initialization handshake.

Correlation permits independent requests to finish in a different order. In this constructed exchange, response order does not change identity.
Observed orderMessageInterpretation
1Request read-AFirst outstanding exchange
2Request read-BSecond independent exchange
3Response read-BCompletes the second exchange
4Notification, no IDNot either request's final response
5Response read-ACompletes the first exchange

Older revisions used initialize, a response containing supported capabilities, and notifications/initialized before normal operation. Keep that compatibility mode separate. Package version is another independent identifier: the TypeScript migration guide distinguishes modern-capable packages from explicitly selecting modern wire behavior. It also treats HTTP 401/403 as authorization failures, not evidence that an older protocol should be tried.

Build and refresh the catalog

Discovery has several meanings. A registry helps locate server packages or remote endpoints; it does not host their binaries or enumerate their live capabilities. Namespace verification identifies a publisher, not safe code. After selecting a server, server/discover describes support, while tools/list, resources/list, resources/templates/list, and prompts/list enumerate its interfaces.

Lists may be paginated. An opaque cursor is a continuation token the client passes back without interpreting or changing it. Continue while nextCursor is present; an empty string is still a valid cursor. Do not infer completion from page length. Invalid cursors require error handling rather than treating the partial inventory as complete.

Illustrative pseudocode

Python-like pseudocode
# client.request supplies the required version/capability metadata.
params = {}
items = []
while True:
    page = client.request("tools/list", params)
    items.extend(page["tools"])
    if "nextCursor" not in page:
        break
    params = {"cursor": page["nextCursor"]}

Preserve origin when aggregating catalogs: (server-A, search) and (server-B, search) are different tools. The host may expose either, both, or neither to a model. Discovery is not relevance ranking, and a visible definition is not execution permission.

Caching adds a freshness contract. Complete discover/list/read results carry ttlMs, a time-to-live hint, and cacheScope. Keys include result-affecting parameters; private entries cannot cross authorization contexts. TTL neither freezes content nor schedules polling. Relevant notifications invalidate even fresh entries. Pages are cached independently, so enumeration is not a transactional snapshot; an invalid cursor requires discarding pages and restarting. Continuation exchanges are not cacheable.

subscriptions/listen requests categories of changes or particular resource URIs. Its first message acknowledges the subset the server will honor: inspect that subset. Notification metadata identifies the subscription request. Cancellation or transport loss ends the subscription, so a reconnecting stdio client must subscribe again. A change notification still does not rewrite an existing model input. The host must re-fetch and assemble the next request; Refresh, supersede, remove explains that application responsibility.

A notification invalidates the cache, not the request

A notification invalidates the cache, not the requestThree lanes retain the same Server A search identity. A list result fills the earlier cache and is selected into request 1. A delivered change notification invalidates the cache even before TTL expiry. A later fetch and selection supply request 2. Request 1 stays unchanged.Server definitionHost cacheModel requestsServer A: searchEarlier definitionEarlier definitionCached representationRequest 1Already sentList resultSelectRemains unchangedServer A: searchDefinition changesEarlier cache invalidEven before TTL expiryNotification:invalidateRelevant change delivered through an acknowledged subscriptionRe-fetch when neededNew list resultUpdated definitionNewly fetched cacheRequest 2New selected definitionSelectOrder only: no polling schedule or transactional catalog snapshot implied.
A notification changes cache freshness; a fetch and a new host selection change the next model request. The already-sent request keeps its earlier definition.

Local processes and remote transports

A transport carries protocol messages. With stdio, the client launches a subprocess and exchanges newline-delimited messages through standard input and output. Standard output must remain protocol traffic; diagnostics belong on standard error. With Streamable HTTP, clients POST messages to one MCP endpoint. Responses use JSON or a request-scoped Server-Sent Events (SSE) stream—a server-to-client event delivery format, not necessarily a stream of model tokens.

ResponsibilityLocal subprocessRemote service
ExecutionThe client launches configured code.The service operator runs the server.
Trust decisionExecutable provenance and process privilegesEndpoint authenticity and operator access
CredentialsSecrets explicitly supplied to the process are accessible to it.The client grants access through the service's supported mechanism.
IsolationRequires host or OS controls.Authentication does not certify benign server code.

The inspected TypeScript stdio implementation uses an environment allowlist plus explicitly supplied values and launches with shell:false. These choices limit accidental inheritance and shell interpretation, but do not sandbox the executable. Local execution can still read permitted files and communicate over permitted networks.

July-2026 requests carry their own protocol assumptions rather than depending on an initialized protocol session. This permits routing to different instances without session storage, but applications can still require databases and explicit state handles. The redesign addressed operational complexity and introduced migration costs; it is not a measured throughput guarantee.

Clients must handle both JSON and SSE responses. On an ordinary SSE response stream, related notifications precede the final JSON-RPC response, which should end the stream. In this revision, closing that stream cancels its request, and Last-Event-ID replay is unsupported. Older Streamable HTTP examples with session IDs and resumable streams describe a different contract.

Continue when input is required

Multi Round-Trip Requests let tools/call, resources/read, or prompts/get return an InputRequiredResult for missing information. The client may continue with supported inputs, a different JSON-RPC ID, matching inputResponses, and an exact echo of any opaque requestState. This continues the original operation, rather than initiating an unsolicited server call.

Elicitation obtains user input through the client. Form mode collects permitted structured information; URL mode sends the user to an out-of-band interaction for secrets or third-party authorization. Form mode must not request passwords, access tokens, API keys, or payment credentials. Accept, decline, and cancel are different dispositions. Accepting a URL interaction does not prove completion: the server checks when the operation resumes. Neither mode is blanket approval for later actions.

Continuation fields are operation-specific, never shared with concurrent work. Treat returned state as attacker-controlled: authority or business state needs integrity protection and principal, request, and expiry binding. Single-use behavior requires server enforcement; continuation remains optional.

One operation, two request IDs

One operation, two request IDsClient request r1 receives an InputRequiredResult with response ID r1, state sigma and input request q1. The client asks the user for a non-sensitive timezone field. Optional r2 carries the same state and a matched inputResponses disposition. The server checks integrity, principal, original request and expiry. Both exchanges belong to one operation.UserClientServerOne logical operationr1 · initial requestprotocolVersion + clientCapabilitiesInputRequiredResult · response ID r1requestState: σ · input request q1Field: timezone (non-sensitive)Client asks for timezoneaccept / decline / cancelOptional continuation r2 · new RPC IDprotocolVersion + clientCapabilitiesExact σ echo · inputResponses for q1Server re-entry validationIntegrity · principalOriginal request · expiryThe input disposition is not action approval; requestState is not deduplication.
In this missing-field example, r1 and optional r2 belong to the same operation. The client echoes state σ unchanged and matches the input response to q1; the server validates its integrity and binding. The disposition does not determine a universal final outcome.

Sampling requests client-mediated model generation without transferring provider credentials to the server. Existing supported integrations use the continuation pattern, with the client retaining model choice and permission control. However, sampling is deprecated in revision 2026-07-28: new implementations should not adopt it, and existing ones should migrate to direct provider APIs. Deprecated does not mean removed; its specification remains for at least twelve months before removal eligibility.

Authority and application control

Acquire access to a protected server

Authentication establishes identity; authorization permits access. OAuth supports delegated access without giving an application the user's password. An authorization server issues an access token after the relevant checks and grant. A resource server accepts that token to serve protected operations. Scope describes granted permissions using service-defined strings; requesting a scope does not guarantee receiving it. Here, the protected resource server is the MCP service—not necessarily an item read through resources/read.

MCP authorization support is optional; the following flow concerns protected HTTP services. Separating token issuance from capability serving became explicit in the June 2025 revision, which classified MCP servers as OAuth resource servers and added protected-resource metadata. This lets the MCP implementation rely on an authorization service rather than own every identity function.

The client follows two discovery documents to find where it can obtain access. An issuer identifies an authorization server; checking that identity prevents the client from accepting metadata for a different server. Discovery itself grants no access.
DocumentHow it is foundWhat the client establishes
Protected-resource metadataA 401 WWW-Authenticate challenge's resource_metadata URL, preferred when present, or prescribed well-known locationsWhich authorization servers can issue access credentials
Authorization-server metadataThe selected issuer's metadata-discovery procedureAuthorization endpoints; the returned issuer must exactly match the issuer used for discovery

Once the authorization server is known, client registration identifies the application requesting access and its permitted redirect destinations. A Client ID Metadata Document lets an unfamiliar client supply that information through an HTTPS URL hosting JSON metadata. Clients supporting all registration options should prefer existing registration, then supported metadata documents, then dynamic registration. Manual configuration may be necessary. Dynamic registration is deprecated but remains available. Issued registration credentials are tied to their authorization-server issuer; a metadata-document URL is portable. Registration identifies the client—it does not grant access to business operations.

In a browser-based authorization flow, the user signs in and grants access. The authorization server returns a code to the client, which exchanges it for an access token and presents that token to MCP. Proof Key for Code Exchange (PKCE) binds code redemption to a verifier held by the initiating client. The token's audience is its intended recipient: the client requests access for the MCP resource, and the server checks that the token was issued for it. Secure storage and exact redirect validation protect other parts of the exchange.

An invalid or expired token requires HTTP 401; insufficient permission uses 403. A scope challenge can guide a bounded authorization upgrade, but clients should remember failed upgrades rather than loop. Refresh tokens are sensitive and cannot be assumed available. Before code redemption, validate the returned issuer against the recorded authorization attempt, including its required presence when issuer-response support was advertised. Renewing MCP access does not renew an independent backend credential.

Enforce authority at each boundary

A server must not forward its incoming client token to an upstream API. Backend access uses separate authority appropriate to that recipient. Preserve the represented user and acting service instead of silently substituting a broad service account. Distinguish people and actors develops those identities. Tenant context—the organization or customer boundary—must come from verified authentication context and constrain resource lookup and caches, not from a model-proposed tenant identifier.

Issue access, then present it to the intended recipient

Issue access, then present it to the intended recipientAfter authorization, the authorization server issues credential alpha to the client. Alpha is presented only to the MCP resource server, which checks audience and permissions plus operation and target. The handler uses separately obtained backend credential beta with verified tenant and represented-user context. Backend acquisition is outside the diagram, and alpha is not forwarded.Authorization serverAfter authorization flowBackend authority βObtained separatelyAcquisition outside this mapIssue token αRecipient: MCP serverSupply β to handlerHost / clientPresents αMCP resource serverα audience + permissionsHandler: action + targetVerified tenant + userBackend APIChecks β authorityPresent αCall with βα ends at MCP. No α path reaches the backend.Logical roles do not require separate machines or a particular token format.
The authorization server issues the MCP access token α to the client, which presents it to MCP. Backend access uses separately obtained authority β; its acquisition is outside this map. Neither discovery nor token scope alone approves a business action.

Visibility and authority can be restricted independently. Linear documents a read-only endpoint exposing only read tools and, separately, a read-scoped token that cannot reach write APIs on its standard endpoint. The first narrows discovery; the second limits credential authority. A hidden operation should not remain executable merely because a caller already knows its name.

A confused deputy misuses its own authority on behalf of a less-privileged caller. One MCP proxy risk arises when many clients share the proxy's upstream OAuth identity: remembered upstream consent can suppress a new consent screen for an unfamiliar MCP client. The proxy must track user approval per client and bind the returning authorization flow to that approval. Prior consent for one client is not consent for all clients.

Control belongs where the decision can actually be enforced.
DecisionEnforcing component
Enable a server and expose capabilitiesHost configuration and policy
Share model context or release dataHost input assembly and outbound controls
Approve a consequential actionHost approval bound to actor, target, arguments, scope, and lifetime
Accept arguments and current stateServer handler, before protected execution
Permit the backend operationBackend permissions and server-side access checks
Bound files, networks, and resourcesHost, operating system, and service limits

Roots communicate workspace locations, not confinement. They are deprecated in July 2026; new implementations should use tool parameters, resource URIs, or configuration instead. A declared file root cannot restrict an otherwise unrestricted process. Sandboxes and Execution Isolation explains the separate enforcement mechanisms.

Tool-description poisoning places attacker instructions in discovered metadata. Invariant's historical experiments included a nominal arithmetic tool that induced sensitive-file transmission and a cross-server redirection attack that did not require invoking the malicious tool. These findings concern the reported configurations, not every current client. They explain why discovery itself crosses an instruction boundary: retain independent enforcement and keep untrusted content in role, rather than treating server descriptions as privileged instructions.

Execution and failure

Trace one issue creation

To carry out a model-proposed action, the host must connect discovery to dispatch: obtain a tool definition, expose it to the model, check the proposed call, and send accepted arguments through its MCP client. The server then maps the call to its backend and returns the outcome. Consider creating “Fix login” in team-A through a Linear-backed adapter.

The handoffs carry different responsibilities: the host accepts the proposed action, the server validates it for execution, and the adapter interprets the backend’s reply.

The identifiers are deliberately different. call-7 associates the model proposal with its observation. rpc-12 associates a protocol request with its response. op-9 is application bookkeeping for the intended operation, not automatic backend deduplication. A created issue ID identifies the resulting record. Store their relationships explicitly rather than assigning one identifier every meaning.

Linear's API uses a GraphQL mutation, a request to change data, for issue creation. Its response includes success and selected issue fields, but HTTP 200 can also carry partial data and errors. Defaults matter too: omitting stateId selects the team's first Backlog state, or Triage when enabled. The returned issue ID permits a separate read. If the user requested a particular state, check that state explicitly; receiving a valid MCP response does not establish it.

From model proposal to backend result

From model proposal to backend resultDiscovery and host adaptation precede model proposal call-7. The host binds approval as operation op-9 and dispatches MCP request rpc-12. The server validates before Linear issueCreate, interprets the GraphQL payload and correlates rpc-12. A separate conditional read-back checks requested state when a returned issue ID exists. Host presentation associates the outcome with call-7; none of these identifiers supplies backend deduplication.ModelHost / clientServer handlerLinear APItools/listcreate_issue definitionSelected model-format toolProposal call-7Fix login · team-AAccept and record op-9Bind actor, target, arguments,scope and approval lifetimetools/call · rpc-12protocolVersion 2026-07-28clientCapabilitiesValidate argumentsCheck authority and targetissueCreate underbackend authorityPayload: success / issue / errorsReturned issue ID if availableInterpret GraphQL payloadHTTP 200 alone ≠ creationMCP result · response rpc-12Separate read-back only if requested state needs checking and an issue ID existsNew read requestRead issue by IDDomain fieldsRead-back findingsObservation for call-7Backend report / verified statecall-7: model · op-9: application · rpc-12: exchange · issue ID: backend record
This teaching adapter combines documented contracts; it is not an observed execution or Linear’s hosted schema. rpc-12 correlates the MCP response; call-7 correlates the model observation. The dashed read-back is a separate conditional operation. Application op-9 supplies no backend deduplication.

Keep the execution record connected without overclaiming visibility. Trace-context propagation carries execution identity across controlled service boundaries so their records can be joined. It cannot expose an uninstrumented provider's internals, and trace identity is not authorization. Propagate context and observe telemetry develops that mechanism. The user-facing result should distinguish what the backend reported from any separately verified state.

Interpret errors and interrupted requests

Failure handling begins by identifying which boundary supplied the observation. Rejection before dispatch, failure inside a handler, and loss of a response after dispatch require different responses. A single success flag cannot represent all three.

ObservationKnown factResponsible response
Unsupported version or featureThe requested exchange is unsupported.Client selects shared behavior or reports incompatibility.
Authorization rejectionAn access check rejected this request.Resolve identity or permission at that boundary.
JSON-RPC errorThe protocol operation returned an error.Interpret its code and operation-specific meaning.
Tool result with isErrorThe tool reports execution failure.Inspect the handler's failure contract, including partial effects.
Unusable resultThe host cannot safely consume the response.Reject downstream use; do not assume a mutation never happened.
No final responseThe client lacks a completed observation.Preserve uncertainty and investigate external state.

Progress is optional observation during work. The client supplies a progressToken, unique across active requests; notifications report increasing progress and optionally a total and message. A supplied token does not require reports. Without a meaningful total, do not display a percentage. Reports stop at completion and are neither a final result nor a durable job handle.

Set request timeouts and an overall maximum even if progress resets an inactivity timer. Cancellation is binding-specific: stdio uses notifications/cancelled with the outstanding request ID; HTTP closes the request's SSE stream. Servers should stop processing and release resources, but cancellation can arrive after completion or concern work that cannot stop. Clients must handle races and ignore late responses. This is not rollback.

If issue creation loses its final response, the client may have an unknown outcome: creation might not have committed, or it might have committed before delivery failed. July-2026 HTTP reconnection does not replay that response. Searching for a matching record may help investigate, but a match alone does not identify which concurrent attempt created it.

One observation, two possible realities

Example

A missing response cannot distinguish absent work from a committed effect whose result was lost.

Creation dispatched
No creation committedWork stops before the effect.
Creation committedThe backend record exists.
Result delivery lost
Client: no final responseEffect remains unknown to the client.
Possible paths after dispatch, not measured frequencies. Neither path gives the client a final result; recovery needs independent knowledge of the backend effect.
Read the diagram as text
  • Creation dispatched.
  • No creation committed. Work stops before the effect.
  • Creation committed. The backend record exists.
  • Result delivery lost.
  • Client: no final response. Effect remains unknown to the client.
  • Creation dispatched → No creation committed: Interruption before commit.
  • Creation dispatched → Creation committed: Execution reaches commit.
  • No creation committed → Client: no final response: No result delivered.
  • Creation committed → Result delivery lost: Interruption after commit.
  • Result delivery lost → Client: no final response: No result delivered.

Idempotency makes repeated attempts represent one logical operation only when the receiving service enforces that contract. A caller identifier must be recorded consistently with the effect, bound to unchanged parameters, and retained for a defined retry window. Logging an identifier or changing the JSON-RPC ID does not do this. Recover when the effect is unknown explains reconciliation. The agent runtime is the application machinery retaining execution state and recovery policy; its implementation belongs in Agent Runtimes and Harness Engineering.

Separate durable tasks from live requests

Some work must remain inspectable after its initiating connection disappears. MCP's maintainers introduced experimental Tasks in November 2025 for ongoing work and later result retrieval. The separately evolving Tasks extension, described here from its draft specification, is optional rather than part of core July-2026 request handling.

With shared extension support, a tools/call can return an ordinary result or a task handle after the task has been durably created. The client retains taskId and polls tasks/get, respecting pollIntervalMs. An input_required task accepts responses through tasks/update. completed contains the original method result, which can still be a tool result with isError; failed carries a protocol error. Ordinary progress notifications are not task progress.

IdentityWhat it representsWhat it does not guarantee
Request IDOne protocol exchangeRetrieval after connection loss
Task IDStored status and result, subject to retentionWorker restart or successful computation
Backend record or operation IDDomain-specific state or actionEquivalence with protocol task status

Task cancellation uses tasks/cancel, not request cancellation. Its acknowledgement confirms receipt, not stopped execution; another terminal outcome remains possible. A client retaining the handle can inspect later status. Retrieval still requires authorization and remains subject to retention: expiry can remove the task, and the extension provides no tasks/list recovery path for a lost handle. Cancellation does not reverse completed backend effects.

The two panels show the same logical task before and after disconnect. With a retained handle, authorized clients can inspect stored task state within retention. Storage does not restart a failed worker or undo backend effects.

Keep protocol status separate from domain status. An invoice, for example, can pass through several business states while its task remains working. Cornelia Davis's Tasks discussion makes this mapping explicit. A durable observation mechanism helps recover knowledge of work; it does not supply the application's entire recovery system.

Verification and choice

Verify the integration and choose its boundary

Verification has four levels. Protocol conformance checks the exchange rules. Shared feature support checks whether both implementations provide the required subset. Semantic agreement checks that operations and representations mean what each side expects. Task usefulness checks the intended external outcome. A connection can pass the first level while failing any of the others.

Use this as a test record for each exact host/client/server combination, not as a populated compatibility claim. Record implementation versions, endpoint or artifact identity, selected protocol revision, and transport. Every entry starts untested; documentation alone changes it to documented, not passed.
PropertyFocused testRequired evidence
Version and transportShared revision; JSON and SSE handling; explicit incompatibilityCaptured exchange and selected wire behavior
CatalogPagination, duplicate names, changes, authorization-scoped cachingComplete inventory and refreshed host view
Primitives and contentRequired tools, resource reads, prompt retrieval, result representationsDecoded artifacts and correct host use
AuthorityAllowed action, denied action, wrong target, insufficient scopeEnforcement result and backend state
ContinuationSupported input, refusal, unsupported feature, concurrent operationsCorrect request association and disposition
InterruptionTimeout, cancellation race, lost response, optional task recoveryHonest outcome status and bounded recovery
Business resultCreate the intended record under permitted authorityBackend receipt, relevant read-back, and accurate presentation

MCP Inspector helps inspect interfaces. Its documented fixtures cover cases such as pagination, structured results, authorization discovery, and client-rejected schemas. That is useful coverage, not a certificate that an application achieved its business goal. Exercise the actual host and backend as well; Exercise real integration boundaries explains why substitute-only tests cannot establish the whole path.

The server interface itself remains a design choice. Block's June 16, 2025 Linear account describes moving from endpoint-shaped tools to consolidated tools and then separate GraphQL read and mutation interfaces. The illustrated assignee query became one request, but the report is not a controlled performance benchmark or a universal recommendation for arbitrary GraphQL. It demonstrates that protocol reuse does not choose useful operation granularity.

Existing APIs can coexist with MCP. Azure API Management's REST wrapper exposes selected API operations as tools, not resources or prompts, with authentication configured separately. Intermediaries also affect execution: Microsoft warns that reading response bodies in policies can introduce buffering that interferes with streaming. An adapter preserves only the behavior it actually implements.

Choose direct integration when tight application ownership, specialized access patterns, or a small capability surface make it simpler. Choose MCP when reusable capability exchange justifies operating and testing the boundary. Compare both under the same task and authority requirements, keeping outcome quality, latency, model-context consumption, maintenance, and compatibility costs separate. A shared protocol is valuable when it reduces repeated work without hiding who owns the remaining decisions.

Open questions

  1. Behavioral portability remains harder than message compatibility. Hosts can differ in resource exposure, catalog refresh, and model-facing adaptation while exchanging valid messages. Progress would mean reproducible cross-host tests of a declared feature subset and equivalent backend outcomes, without requiring identical interfaces.

  2. Useful capability discovery must balance completeness against model-context cost. Loading every endpoint description can be impractical, while progressive disclosure adds selection steps and cache interactions. Progress would demonstrate task coverage, correct tool choice, and bounded context consumption under changing catalogs—not merely smaller initial payloads.

  3. Safe recovery across independent services still needs stronger business contracts than correlation alone. Durable task status can preserve observations, but external effects may lack enforced deduplication or a decisive reconciliation interface. Progress would expose operation-specific retry, retention, and effect-status guarantees that remain valid across crashes and concurrent attempts.

Follow the curated reading path through the speakers and demonstrations behind this entry.

20 min

AI Engineer World's Fair 2025 · 2025

Building Protected MCP Servers

Den Delimarsky (DEVDIV) · Julia Kasper · Den Delimarsky

Cited in this entry

Explains the historical separation of authorization-server and resource-server responsibilities, with a concrete metadata and protected-access demonstration.

Watch talk

Explore more talks

The rest of the library, beyond the curated path. Cited talks support this entry; reviewed transcripts were processed in full. Metadata candidates have not been reviewed as sources or verified as topic members.

373 matching talks

TalkSpeakerEventYear
Harald KirschnerAI Engineer World's Fair 20252025
Marlene Mhangami, Liam HamptonAI Engineer Europe 20262026
AI Engineering 101

Transcript reviewed

Noah HeinAI Engineer Summit 20232023
Roy DerksAI Engineer Summit 20252025
Philipp SchmidAI Engineer World's Fair 20252025
Alex GavrilescuAI Engineer Code 20252025
Harald KirschnerAI Engineer World's Fair 20252025
Sam MorrowAI Engineer Europe 20262026
Leonie MonigattiAI Engineer Europe 20262026
Ankur GoyalAI Engineer World's Fair 20252025
MCP is all you need

Transcript reviewed

Samuel ColvinAI Engineer World's Fair 20252025
Lovina DmelloAI Engineer World's Fair 20262026
Simon WillisonAI Engineer World's Fair 20242024
Tun Shwe, Jeremy FrenayAI Engineer Europe 20262026
Fouad MatinAI Engineer World's Fair 20252025
Liam McGarrigleAI Engineer Europe 20262026
Security Firewall for Agents

Transcript reviewed

Ryan DahlAI Engineer World's Fair 20262026
Vinoth GovindarajanAI Engineer World's Fair 20262026
Mike ChristensenAI Engineer Europe 20262026
Bennet FennerAI Engineer Europe 20262026
Nishant GuptaAI Engineer World's Fair 20262026
LLM Evals That Work IRL

Transcript reviewed

Aparna Dhinkaran, Aparna DhinakaranAI Engineer World's Fair 20242024
Damien MurphyAI Engineer World's Fair 20252025
David CramerAI Engineer World's Fair 20252025
Kim MaidaAI Engineer World's Fair 20262026
Jan CurnAI Engineer World's Fair 20252025
Antje BarthAI Engineer World's Fair 20252025
Ravi MadabhushiAI Engineer World's Fair 20262026
Tushar JainAI Engineer World's Fair 20262026
Harald Kirschner, Christopher HarrisonAI Engineer World's Fair 20252025
Siddharth AhujaAI Engineer World's Fair 20252025
Sarmad QadriAI Engineer World's Fair 20252025
Rachel Lee Nabors (RL Nabors)AI Engineer Europe 20262026
Yogendra MirajeAI Engineer World's Fair 20252025
Jared HansonAI Engineer World's Fair 20252025
Diego CarpinteroAI Engineer Europe 20262026
Yohei NakajimaAI Engineer World's Fair 20262026
Henry MaoAI Engineer World's Fair 20252025
Cornelia DavisAI Engineer Code 20252025
Du’An Lightfoot, Banjo ObayomiAI Engineer World's Fair 20252025
Ilan BigioAI Engineer Summit 20252025
Nimrod HauserAI Engineer Europe 20262026
Theodora ChuAI Engineer World's Fair 20252025
Pietro ZulloAI Engineer World's Fair 20262026
Matt CareyAI Engineer Europe 20262026
Michael HablichAI Engineer Europe 20262026
Dan MasonAI Engineer World's Fair 20252025
Pedro RodriguesAI Engineer Europe 20262026
Rafael LeviAI Engineer Europe 20262026
The Future of MCP

Metadata candidate

David Soria ParraAI Engineer Europe 20262026
Ruben CasasAI Engineer Europe 20262026
Kent C. DoddsAI Engineer World's Fair 20252025
Ronan McGovernAI Engineer World's Fair 20252025
Ido Salomon, Liad YosefAI Engineer World's Fair 20262026
Liad Yosef, Ido SalomonAI Engineer Europe 20262026
Garrett GalowAI Engineer Europe 20262026
Merve NoyanAI Engineer Europe 20262026
Alex Volkov, Benjamin EckelAI Engineer World's Fair 20252025
Tobin SouthAI Engineer World's Fair 20252025
Frédéric BartheletAI Engineer Europe 20262026
Ari HeljakkaAI Engineer World's Fair 20252025
Sanja GrbicAI Engineer World's Fair 20262026
Barry Zhang, Mahesh MuragAI Engineer Code 20252025
Ezra Tanzer, Dan ArpinoAI Engineer World's Fair 20262026
Brendan O'LearyAI Engineer Europe 20262026
Cedric VidalAI Engineer World's Fair 20252025
Stephen ChinAI Engineer World's Fair 20252025
Zach BlumenfeldAI Engineer World's Fair 20252025
Uday Kiran Medisetty, Adam HudaAI Engineer World's Fair 20262026
Shawn "swyx" WangAI Engineer Europe 20262026
Armanas PovilionisAI Engineer World's Fair 20262026
Nick Nisi, Lizzie SiegleAI Engineer World's Fair 20252025
Olivier Leplus, Yohan LasorsaAI Engineer Europe 20262026
Nick Nisi, Zack ProserAI Engineer World's Fair 20252025
Beyang LiuAI Engineer Code 20252025
Anthropic for VPs of AI

Metadata candidate

Alexander Bricken, Joe BayleyAI Engineer Summit 20252025
Frank CoyleAI Engineer World's Fair 20262026
Abhishek BhardwajAI Engineer World's Fair 20252025
Marlene MhangamiAI Engineer Europe 20262026
Filip KozeraAI Engineer World's Fair 20252025
Louis-François Bouchard, Paul Iusztin, Samridhi VaidAI Engineer Europe 20262026
Julián Duque, Anush DSouzaAI Engineer World's Fair 20252025
Jeff NgAI Engineer World's Fair 20262026
Rita KozlovAI Engineer World's Fair 20252025
Angie JonesAI Engineer World's Fair 20262026
Cedric VidalAI Engineer World's Fair 20252025
Eric ZakariassonAI Engineer Europe 20262026
Nick TaylorAI Engineer Europe 20262026
Codex and Subagents

Metadata candidate

Vaibhav Srivastav, Katia Gil GuzmanAI Engineer Europe 20262026
Codex, Behind the Harness

Metadata candidate

Dominik KundelAI Engineer World's Fair 20262026
Šimon PodhajskýAI Engineer Europe 20262026
Jon Peck, Christopher HarrisonAI Engineer World's Fair 20252025
Containing Agent Chaos

Metadata candidate

Solomon HykesAI Engineer World's Fair 20252025
Context Is the New Code

Metadata candidate

Patrick DeboisAI Engineer Europe 20262026
Stephen ChinAI Engineer World's Fair 20262026
Zeke SikelianosAI Engineer World's Fair 20252025
Ben HylakAI Engineer World's Fair 20262026
Shawn Wang (swyx)AI Engineer World's Fair 20252025
Barry ZhangAI Engineer Summit 20252025
Katelyn LesseAI Engineer Code 20252025
May WalterAI Engineer World's Fair 20262026
Mounir MouawadAI Engineer World's Fair 20252025
Gaurav MishraAI Engineer World's Fair 20262026
KitzeAI Engineer World's Fair 20252025
Alex AtallahAI Engineer World's Fair 20252025
Gateways are All You Need

Metadata candidate

Karan SampathAI Engineer Europe 20262026
Keegan McCallumAI Engineer World's Fair 20262026
KP Sawhney, Ian BallantyneAI Engineer Europe 20262026
Ash Prabaker, Andrew WilsonAI Engineer Europe 20262026
Kyle Jaejun LeeAI Engineer World's Fair 20262026
Identity for AI Agents

Metadata candidate

AI Engineer Code 20252025
Intro to GraphRAG

Metadata candidate

Zach BlumenfeldAI Engineer World's Fair 20252025
Suman DebnathAI Engineer World's Fair 20252025
Alex LissAI Engineer World's Fair 20252025
Robert ChandlerAI Engineer World's Fair 20252025
Sally Ann O'MalleyAI Engineer Europe 20262026
Adam BehrensAI Engineer World's Fair 20252025
Vincent KocAI Engineer Europe 20262026
Eashan SinhaAI Engineer World's Fair 20252025
Manuel OdendahlAI Engineer World's Fair 20252025
Drasko ProfirovicAI Engineer World's Fair 20262026
Mark Bain, Vasilije Markovic, Daniel Chalef, Alex GilmoreAI Engineer World's Fair 20252025
Sonny Merla, Mauro Luchetti, Mattia RedaelliAI Engineer Europe 20262026
Christopher HarrisonAI Engineer World's Fair 20252025
Juan Herreros ElorzaAI Engineer Europe 20262026
Yuval BelferAI Engineer World's Fair 20252025
Jon PeckAI Engineer World's Fair 20252025
Michael YuanAI Engineer World's Fair 20252025
Joshua SnyderAI Engineer Europe 20262026
Eno ReyesAI Engineer World's Fair 20252025
Skills are the New SDKs

Metadata candidate

Elvin AghammadzadaAI Engineer World's Fair 20262026
Louis Knight-WebbAI Engineer Europe 20262026
Al HarrisAI Engineer Code 20252025
Brandon WaselnukAI Engineer Europe 20262026
Vikash Agrawal, LindaAI Engineer World's Fair 20252025
Sohail Shaikh, Ankush RastogiAI Engineer World's Fair 20262026
Christopher Harrison, John PeckAI Engineer World's Fair 20252025
Corey GallonAI Engineer World's Fair 20262026
Beyang LiuAI Engineer World's Fair 20252025
Justin SchroederAI Engineer World's Fair 20262026
Junyang LinAI Engineer World's Fair 20252025
William LyonAI Engineer World's Fair 20252025
Paul Klein IVAI Engineer World's Fair 20252025
Manoj Nair, Ezra, RandallAI Engineer World's Fair 20262026
Rafal Wilinski, Vitor BaloccoAI Engineer World's Fair 20252025
Jon PeckAI Engineer World's Fair 20252025
Erik HanchettAI Engineer World's Fair 20262026
Harald KirschnerAI Engineer World's Fair 20252025
Itamar FriedmanAI Engineer World's Fair 20252025
Lucas PalmaAI Engineer World's Fair 20262026
Lei ZhangAI Engineer Code 20252025
Why Agent Engineering

Metadata candidate

swyx (Shawn Wang)AI Engineer Summit 20252025
Sunil Pai, Matt CareyAI Engineer Europe 20262026
Zach BlumenfeldAI Engineer Europe 20262026
Kevin HouAI Engineer World's Fair 20252025
Your agent is blindfolded

Metadata candidate

Johan LajiliAI Engineer Europe 20262026
Rafael LeviAI Engineer Europe 20262026
Hamza TahirAI Engineer World's Fair 20262026
Zack ProserAI Engineer Europe 20262026
Ramana Siddanth EmaniAI Engineer World's Fair 20262026
Mike PhippsAI Engineer World's Fair 20262026
Lisa OrrAI Engineer Code 20252025
Dex HorthyAI Engineer World's Fair 20252025
Logan KilpatrickAI Engineer World's Fair 20252025
Sharmila Chokalingam, ShubhiAI Engineer World's Fair 20242024
Ievgen VakulenkoAI Engineer World's Fair 20242024
Ari HeljakkaAI Engineer Summit 20252025
Steve YeggeAI Engineer World's Fair 20262026
Gabe De MesaAI Engineer World's Fair 20262026
Steve RuizAI Engineer Europe 20262026
Sam BhagwatAI Engineer World's Fair 20252025
AGI: The Path Forward

Metadata candidate

Eiso Kant, Jason WarnerAI Engineer Code 20252025
Charles FryeAI Engineer Summit 20232023
AI Platform Engineering

Metadata candidate

Patrick DeboisAI Engineer World's Fair 20242024
Tomas ReimersAI Engineer World's Fair 20252025
AI SDK v6

Metadata candidate

Nico AlbaneseAI Engineer Europe 20262026
Gagan Bhat, Isabella Kai HeAI Engineer World's Fair 20262026
Patrick LöberAI Engineer Europe 20262026
Lance MartinAI Engineer World's Fair 20242024
Corey CooperAI Engineer World's Fair 20252025
Robert BrennanAI Engineer Code 20252025
Ivan BurazinAI Engineer World's Fair 20252025
Paige BaileyAI Engineer Europe 20262026
Jerry LiuAI Engineer World's Fair 20252025
John CrepezziAI Engineer Summit 20252025
Thor Schaeff, Philipp SchmidAI Engineer Europe 20262026
Simrat HanspalAI Engineer Summit 20232023
Kat Kampf, Ammaar ReshiAI Engineer Code 20252025
Ivan LeoAI Engineer Code 20252025
Building Reactive AI Apps

Metadata candidate

Matt WelshAI Engineer Summit 20232023
Michael FesterAI Engineer World's Fair 20252025
Building security around ML

Metadata candidate

Dr. Andrew DavisAI Engineer World's Fair 20242024
Building Self-Coding Agents

Metadata candidate

Colin FlahertyAI Engineer Summit 20252025
Jamie Neuwirth, Zack WittenAI Engineer World's Fair 20242024
Ben HolmesAI Engineer World's Fair 20252025
Thariq ShihiparAI Engineer Code 20252025
Lance MartinAI Engineer World's Fair 20262026
Sunil PaiAI Engineer Europe 20262026
Jedrick Kosinski, ComfyAnonymousAI Engineer World's Fair 20252025
Dhruv BatraAI Engineer World's Fair 20262026
Conquering Agent Chaos

Metadata candidate

Rick BlalockAI Engineer World's Fair 20252025
Convex Launch

Metadata candidate

Jamie TurnerAI Engineer World's Fair 20242024
Dominik KundelAI Engineer World's Fair 20242024
Copilots Everywhere

Metadata candidate

Thomas Dohmke, Eugene YanAI Engineer World's Fair 20242024
Mani KhanujaAI Engineer World's Fair 20252025
Defying Gravity

Metadata candidate

Kevin HouAI Engineer Code 20252025
Max Kanat-AlexanderAI Engineer Code 20252025
Ara KhanAI Engineer Europe 20262026
Arthur ObjartelAI Engineer Summit 20252025
Doug GuthrieAI Engineer World's Fair 20252025
Carlos Esteban, Doug GuthrieAI Engineer World's Fair 20252025
Mason EggerAI Engineer World's Fair 20252025
Nina Lopatina, Rajiv ShahAI Engineer World's Fair 20252025
Emma Ning, Tsavo KnottAI Engineer World's Fair 20252025
Daniel Kim, Daria SobolevaAI Engineer World's Fair 20252025
Romain HuetAI Engineer World's Fair 20242024
Paola Estefanía de CamposAI Engineer World's Fair 20262026
Jason LiuAI Engineer World's Fair 20262026
Future-Proof Coding Agents

Metadata candidate

Bill Chen, Brian FiocaAI Engineer Code 20252025
Florina Muntenescu, Oli GaymondAI Engineer Europe 20262026
Cassidy HardinAI Engineer Europe 20262026
Omar SansevieroAI Engineer Europe 20262026
GitHub Next Explorations

Metadata candidate

Rahul PanditaAI Engineer World's Fair 20242024
Luke HarriesAI Engineer Europe 20262026
Audry HsuAI Engineer Europe 20262026
Victoria MelnikovaAI Engineer World's Fair 20262026
Tanmai GopalAI Engineer World's Fair 20242024
Evan BoyleAI Engineer World's Fair 20252025
Vasek MlejnskyAI Engineer World's Fair 20242024
Paul GilbertAI Engineer Summit 20252025
Ian ButlerAI Engineer World's Fair 20252025
Yegor Denisov-BlanchAI Engineer Code 20252025
Hypermode Launch

Metadata candidate

Kevin Van GundyAI Engineer World's Fair 20242024
Justin McCartyAI Engineer World's Fair 20242024
Ian WebsterAI Engineer World's Fair 20242024
AI Engineer Summit 20252025
Ritvik PandyaAI Engineer World's Fair 20262026
Stefano FiorucciAI Engineer Europe 20262026
Michael RichmanAI Engineer Europe 20262026
Carter Abdallah, Vincent Weisser, Lucas Atkins, Chris AlexiukAI Engineer World's Fair 20262026
Kyle MisteleAI Engineer World's Fair 20262026
Eno ReyesAI Engineer Code 20252025
Peter Werry, BrandonAI Engineer Europe 20262026
Minimax M2

Metadata candidate

Olive SongAI Engineer Code 20252025
Ilan BigioAI Engineer World's Fair 20252025
Ola MabadejeAI Engineer World's Fair 20252025
Cedric VidalAI Engineer World's Fair 20242024
Omar KhattabAI Engineer World's Fair 20252025
OpenLLMetry is all you need

Metadata candidate

Nir GazitAI Engineer Summit 20252025
DottaAI Engineer Europe 20262026
Steven MoonAI Engineer Summit 20252025
Nick NisiAI Engineer Europe 20262026
Chris ParsonsAI Engineer Europe 20262026
Respect The Process

Metadata candidate

Andrew DumitAI Engineer World's Fair 20262026
Kshitij GroverAI Engineer World's Fair 20252025
Patrick DeboisAI Engineer Summit 20252025
Boris StarkovAI Engineer Europe 20262026
Onur SolmazAI Engineer Europe 20262026
Gunjan PatelAI Engineer World's Fair 20242024
Reid MayoAI Engineer Summit 20232023
Mike ChambersAI Engineer World's Fair 20252025
Laurie VossAI Engineer Europe 20262026
Giran Moodley, Mayan Soni, Oussama Hafferssas, Mayank SoniAI Engineer Europe 20262026
Kenneth AuchenbergAI Engineer World's Fair 20252025
Shreya Rajpal, Aman GuptaAI Engineer World's Fair 20262026
Marc KlingenAI Engineer Europe 20262026
Skills at Scale

Metadata candidate

Nick Nisi, Zack ProserAI Engineer Europe 20262026
The New Code

Metadata candidate

Sean GroveAI Engineer World's Fair 20252025
Josh PurtellAI Engineer World's Fair 20252025
Elizabeth Fuentes LeoneAI Engineer World's Fair 20262026
Rob CheungAI Engineer World's Fair 20242024
swyxAI Engineer Summit 20232023
Patrick DeboisAI Engineer World's Fair 20252025
Tara AgyemangAI Engineer Europe 20262026
Quinn SlackAI Engineer World's Fair 20242024
The AI Evolution

Metadata candidate

Mario RodriguezAI Engineer Summit 20232023
Chris White, Bryan Bischof, Brittany WalkerAI Engineer Summit 20232023
Brook RiggioAI Engineer World's Fair 20252025
The End of Apps

Metadata candidate

KitzeAI Engineer Europe 20262026
The Future of Work

Metadata candidate

Toran Bruce Richards, Silen Naihin, Reinier van der LeerAI Engineer Summit 20232023
Lou BichardAI Engineer Europe 20262026
The New Application Layer

Metadata candidate

Malte UblAI Engineer Europe 20262026
Diego Rodriguez, Eugene Cheah, Jonas Bauer, Shijia Liao, David Vorick, Alex AtallahAI Engineer World's Fair 20252025
Ted JohnsonAI Engineer World's Fair 20262026
The Prompt is the Platform

Metadata candidate

Dominik TornowAI Engineer World's Fair 20262026
Amir HaghighatAI Engineer World's Fair 20252025
Elmer Thomas, Maria BermudezAI Engineer World's Fair 20252025
Kathryn Grayson NanzAI Engineer World's Fair 20262026
The Weekend AI Engineer

Metadata candidate

Hassan El MghariAI Engineer Summit 20232023
MuhtesemAI Engineer Summit 20252025
Micah Hill-Smith, George CameronAI Engineer World's Fair 20252025
Audry HsuAI Engineer Europe 20262026
Kathleen KenealyAI Engineer World's Fair 20242024
Michael ArnaldiAI Engineer Europe 20262026
James LeAI Engineer World's Fair 20262026
Bilge YücelAI Engineer Europe 20262026
Charles FryeAI Engineer World's Fair 20252025
Remy GuercioAI Engineer Europe 20262026
Benjamin CowenAI Engineer Europe 20262026
Alex AlbertAI Engineer World's Fair 20242024
Fryderyk Wiatrowski, Peter AlbertAI Engineer World's Fair 20242024
Joel BeckerAI Engineer Code 20252025
Victoria MelnikovaAI Engineer World's Fair 20252025
Philipp SchmidAI Engineer Europe 20262026
Rizel ScarlettAI Engineer Summit 20252025
Sean DuBois, Kwindla Hultman KramerAI Engineer World's Fair 20252025
Adi SinghAI Engineer World's Fair 20262026
Lincoln MurrEvent unknownUnknown
Remy GuercioAI Engineer World's Fair 20262026
Dustin MihalikEvent unknownUnknown
Felippe Felisola Caso, Francesco GallettaEvent unknownUnknown
Kamil PotrecEvent unknownUnknown
Ford PriorEvent unknownUnknown
Hari KumarEvent unknownUnknown
Noyan TokgozogluEvent unknownUnknown
Jeremy AdamsEvent unknownUnknown
Jeremiah LowinEvent unknownUnknown
Edo LibertyAI Engineer World's Fair 20262026
Cole GannawayEvent unknownUnknown
Xander SongEvent unknownUnknown
Vlad LuzinAI Engineer World's Fair 20262026
Gareth YoderEvent unknownUnknown
Emile Baizel, Shruti AroraAI Engineer World's Fair 20262026
Jan CurnEvent unknownUnknown
Javier GarzaAI Engineer World's Fair 20262026
Rania KhalafAI Engineer World's Fair 2026Unknown
Gil FeigAI Engineer World's Fair 20262026
Killian Carlsen-PhelanAI Engineer World's Fair 20262026
Jeff Vestal, James WilliamsAI Engineer World's Fair 20262026
Yohan RajuAI Engineer World's Fair 20262026
Charlie Guo, Gabriel ChuaAI Engineer World's Fair 20262026
Jesse LumarieAI Engineer World's Fair 20262026
Jakub HojsanAI Engineer Code 2025Unknown
Priyanka Phatak, Gabe CemajAI Engineer World's Fair 20262026
Jack WotherspoonEvent unknownUnknown
Ajay PrakashEvent unknownUnknown
Jan CurnAI Engineer Code 2025Unknown
Greg PstruchaAI Engineer World's Fair 20262026
Sarah SimionescuAI Engineer Code 2025Unknown
Mikyo KingEvent unknownUnknown
Priyanka Phatak, Gabe CemajAI Engineer World's Fair 20262026
Philipp SchmidAI Engineer World's Fair 20262026
Em ShreveAI Engineer World's Fair 20262026
Aidan SochowskiEvent unknownUnknown
Nilofer RajpurkarAI Engineer World's Fair 20262026
Joseph KimEvent unknownUnknown
Kamalakannan NandagopalEvent unknownUnknown
Kevin OrellanaAI Engineer World's Fair 20262026
Peter WerryAI Engineer World's Fair 20262026
Jim ClarkAI Engineer World's Fair 20262026
Harish GaggarAI Engineer NYC 2026 Online Talks2026
William LyonEvent unknownUnknown
Liad YosefAI Engineer World's Fair 20262026
Kim MaidaAI Engineer NYC 2026 Online Talks2026
Andrey RybkaEvent unknownUnknown
Ben DickenAI Engineer World's Fair 20262026
Michael GrinichAI Engineer World's Fair 20262026
Thor SchaeffAI Engineer World's Fair 20262026
Dominik KundelAI Engineer World's Fair 20262026
Dhruv NathawaniAI Engineer World's Fair 20262026
Vlad LuzinEvent unknownUnknown
Thorsten HansEvent unknownUnknown
Rafal WilinskiAI Engineer World's Fair 20262026
Michael Forrester, Whitney LeeAI Engineer World's Fair 20262026
Filip MakraduliAI Engineer World's Fair 20262026
Rowan ChristmasAI Engineer Code 2025Unknown
Abhi AryaEvent unknownUnknown
Karthik Ranganathan, Heather DowningAI Engineer World's Fair 20262026
Sam ParsonsAI Engineer World's Fair 20262026
Pedro LopezAI Engineer World's Fair 20262026
Sam ProdgerAI Engineer World's Fair 20262026
Elizabeth Fuentes LeoneAI Engineer World's Fair 20262026
Micah SilvermanAI Engineer World's Fair 20262026

References

Coverage and source review
Processed transcripts
50 processed in full · 5 in the curated path
Automated source review
Passed
Metadata candidates
328 unreviewed; not verified topic membership
Corpus version
1bd8e407b26a07b33815594e1b2db5f41827119a2b3cb6fbf240f9fc571fc767

Automated review checks source support; it is not publication approval.

A synthesis of selected conference talks and technical references. Citations link to the source material; they do not imply that every talk on this subject is included.

  1. Model Context Protocol: Specification and trust principles, revision 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28

  2. MCP server — Linear documentation

    https://linear.app/docs/mcp

  3. A2A & MCP: Automating Business Processes with LLMs

    https://www.youtube.com/watch?v=wXVvfFMTyzY&t=456

  4. Model Context Protocol: Architecture, revision 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28/architecture

  5. Function Calling is All You Need

    https://www.youtube.com/watch?v=KUEmEb71vzQ&t=678

  6. LangChain MCP Adapters

    https://github.com/langchain-ai/langchain-mcp-adapters

  7. Building (Agents) with Model Context Protocol

    https://www.youtube.com/watch?v=kQmXtrmQ5Zg&t=5598

  8. A Common Protocol for Languages

    https://code.visualstudio.com/blogs/2016/06/27/common-language-protocol

  9. MCP Specification — revision 2025-06-18

    https://modelcontextprotocol.io/specification/2025-06-18

  10. Function calling and other API updates

    https://openai.com/index/function-calling-and-other-api-updates/

  11. Introducing the Model Context Protocol

    https://www.anthropic.com/news/model-context-protocol

  12. MCP Key Changes — revision 2025-03-26

    https://modelcontextprotocol.io/specification/2025-03-26/changelog

  13. The 2026-07-28 Specification

    https://blog.modelcontextprotocol.io/posts/2026-07-28/

  14. Expose REST API in API Management as an MCP server

    https://learn.microsoft.com/en-us/azure/api-management/export-rest-mcp-server

  15. Model Context Protocol: Tools, revision 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28/server/tools

  16. GitHub MCP Server — issue-comment implementation

    https://raw.githubusercontent.com/github/github-mcp-server/main/pkg/github/issues.go

  17. MCP Resources, revision 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28/server/resources

  18. Building (Agents) with Model Context Protocol

    https://www.youtube.com/watch?v=kQmXtrmQ5Zg&t=652

  19. Backlog.md: Terminal Kanban Board for Managing Tasks with AI Agents — Alex Gavrilescu, Funstage

    https://www.youtube.com/watch?v=zMXKhhwiCIc&t=340

  20. MCP Prompts, revision 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28/server/prompts

  21. Building (Agents) with Model Context Protocol

    https://www.youtube.com/watch?v=kQmXtrmQ5Zg&t=777

  22. Implementing Remote Procedure Calls — Birrell and Nelson

    https://www.cs.cmu.edu/~15712/papers/birrell84.pdf

  23. JSON-RPC 2.0 Specification

    https://www.jsonrpc.org/specification

  24. MCP Base Protocol: messages and per-request metadata

    https://modelcontextprotocol.io/specification/2026-07-28/basic

  25. MCP Versioning and Compatibility, revision 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28/basic/versioning

  26. MCP Lifecycle — revision 2025-06-18

    https://modelcontextprotocol.io/specification/2025-06-18/basic/lifecycle

  27. Supporting protocol revision 2026-07-28 — MCP TypeScript SDK

    https://github.com/modelcontextprotocol/typescript-sdk/blob/main/docs/migration/support-2026-07-28.md

  28. The MCP Registry

    https://modelcontextprotocol.io/registry/about

  29. MCP Pagination, revision 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28/server/utilities/pagination

  30. MCP Caching, revision 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28/server/utilities/caching

  31. Subscriptions — MCP 2026-07-28 specification source

    https://raw.githubusercontent.com/modelcontextprotocol/modelcontextprotocol/main/docs/specification/2026-07-28/basic/patterns/subscriptions.mdx

  32. Model Context Protocol: Transport overview, revision 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28/basic/transports

  33. MCP Transports — revision 2025-06-18

    https://modelcontextprotocol.io/specification/2025-06-18/basic/transports

  34. MCP TypeScript SDK: local subprocess launch and environment

    https://raw.githubusercontent.com/modelcontextprotocol/typescript-sdk/main/packages/client/src/client/stdio.ts

  35. Connecting to remote MCP servers: endpoint identity and permissions

    https://modelcontextprotocol.io/docs/2026-07-28/develop/connect-remote-servers

  36. MCP Streamable HTTP: results and disconnected requests

    https://modelcontextprotocol.io/specification/2026-07-28/basic/transports/streamable-http

  37. Multi Round-Trip Requests — MCP 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28/basic/patterns/mrtr

  38. MCP Elicitation, revision 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28/client/elicitation

  39. MCP Sampling, revision 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28/client/sampling

  40. RFC 6749 — OAuth 2.0 Authorization Framework

    https://www.rfc-editor.org/rfc/rfc6749.html

  41. MCP Authorization — revision 2025-06-18

    https://modelcontextprotocol.io/specification/2025-06-18/basic/authorization

  42. MCP Key Changes — revision 2025-06-18

    https://modelcontextprotocol.io/specification/2025-06-18/changelog

  43. Authorization — MCP 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization

  44. Authorization Server Discovery — MCP 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization/authorization-server-discovery

  45. Client Registration — MCP 2026-07-28 specification source

    https://raw.githubusercontent.com/modelcontextprotocol/modelcontextprotocol/main/docs/specification/2026-07-28/basic/authorization/client-registration.mdx

  46. Model Context Protocol: Authorization security considerations, revision 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization/security-considerations

  47. Your Insecure MCP Server Won't Survive Production — Tun Shwe, Lenses

    https://www.youtube.com/watch?v=BurJvbqFr4c&t=980

  48. OWASP Multi-Tenant Security: tenant context and resource access

    https://cheatsheetseries.owasp.org/cheatsheets/Multi_Tenant_Security_Cheat_Sheet.html

  49. MCP Security Best Practices: per-client proxy consent

    https://modelcontextprotocol.io/docs/2026-07-28/tutorials/security/security_best_practices

  50. The Protection of Information in Computer Systems

    https://www.cs.virginia.edu/~evans/cs551/saltzer/

  51. Your Agent Didn’t Fail. Your Harness Did.

    https://www.youtube.com/watch?v=BInpv7lGp1o&t=717

  52. MCP Roots, revision 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28/client/roots

  53. Invariant Labs: MCP Security Notification—Tool Poisoning Attacks

    https://invariantlabs.ai/blog/mcp-security-notification-tool-poisoning-attacks

  54. AI Engineering with the Google Gemini 2.5 Model Family

    https://www.youtube.com/watch?v=zK9lYrLbjSg&t=3664

  55. Getting started — Linear GraphQL API

    https://linear.app/developers/graphql

  56. Your Agent Didn’t Fail. Your Harness Did.

    https://www.youtube.com/watch?v=BInpv7lGp1o&t=882

  57. Making retries safe with idempotent APIs — Amazon Builders' Library

    https://aws.amazon.com/builders-library/making-retries-safe-with-idempotent-APIs/

  58. OpenTelemetry: Context propagation

    https://opentelemetry.io/docs/concepts/context-propagation/

  59. Tools — Model Context Protocol specification 2025-06-18

    https://modelcontextprotocol.io/specification/2025-06-18/server/tools

  60. MCP tools: application security responsibilities

    https://modelcontextprotocol.io/specification/2025-06-18/server/tools

  61. gRPC lifecycle: cancellation is not rollback

    https://grpc.io/docs/what-is-grpc/core-concepts/

  62. MCP request progress, revision 2026-07-28

    https://modelcontextprotocol.io/specification/2026-07-28/basic/patterns/progress

  63. MCP request cancellation and timeout limits

    https://modelcontextprotocol.io/specification/2026-07-28/basic/patterns/cancellation

  64. GitHub REST API endpoints for issue comments

    https://docs.github.com/en/rest/issues/comments

  65. Your Agent Didn’t Fail. Your Harness Did.

    https://www.youtube.com/watch?v=BInpv7lGp1o&t=608

  66. One Year of MCP: November 2025 Spec Release

    https://blog.modelcontextprotocol.io/posts/2025-11-25-first-mcp-anniversary/

  67. MCP Tasks extension: capability, lifecycle, and result retrieval

    https://tasks.extensions.modelcontextprotocol.io/specification/draft/tasks

  68. MCP Tasks architecture: durable handles across disconnects

    https://tasks.extensions.modelcontextprotocol.io/

  69. MCP Tasks (async)/ Why the heck aren't any agents supporting MCP tasks/async?

    https://www.youtube.com/watch?v=s4r6nk5WsZw&t=703

  70. SEP-2663: task cancellation, post-cancel observation, and retention

    https://modelcontextprotocol.io/seps/2663-tasks-extension

  71. MCP Inspector — official repository testing documentation

    https://github.com/modelcontextprotocol/inspector

  72. Are MCPs Overhyped? A Rant about MCPs

    https://www.youtube.com/watch?v=tOou_GJ9Ddk&t=246

  73. Block’s Playbook for Designing MCP Servers

    https://engineering.block.xyz/blog/blocks-playbook-for-designing-mcp-servers

  74. A2A & MCP: Automating Business Processes with LLMs

    https://www.youtube.com/watch?v=wXVvfFMTyzY&t=882

  75. MCP Resources — revision 2025-06-18

    https://modelcontextprotocol.io/specification/2025-06-18/server/resources

  76. MCP Prompts — revision 2025-06-18

    https://modelcontextprotocol.io/specification/2025-06-18/server/prompts

  77. Full Spec MCP: Hidden Capabilities of the MCP Spec — Harald Kirschner, Microsoft/VS Code

    https://www.youtube.com/watch?v=ExeD-8gFUMM&t=122

  78. Your Agent Is an Infinite Canvas

    https://www.youtube.com/watch?v=LMbeDEQO6QM&t=605

  79. MCP = Mega Context Problem - Matt Carey

    https://www.youtube.com/watch?v=YBYUvGOuotE&t=190

  80. Your MCP Server is Bad and You Should Feel Bad

    https://www.youtube.com/watch?v=96G7FLab8xc&t=1820

  81. AWS Builders Library: Making retries safe with idempotent APIs

    https://aws.amazon.com/builders-library/making-retries-safe-with-idempotent-APIs/

  82. Remote MCPs: What we learned from shipping — John Welsh, Anthropic

    https://www.youtube.com/watch?v=0NHCyq8bBcM&t=189

  83. Building Protected MCP Servers

    https://www.youtube.com/watch?v=PHBGhUKAM-w&t=235

  84. Building Protected MCP Servers

    https://www.youtube.com/watch?v=PHBGhUKAM-w&t=511

  85. MCP Tasks (async)/ Why the heck aren't any agents supporting MCP tasks/async?

    https://www.youtube.com/watch?v=s4r6nk5WsZw&t=860