@@ -89,11 +89,10 @@ async def progress(self, progress: float, total: float | None = None, message: s
 def _typed(model: type[_ModelT], raw: Any) -> _ModelT | None:
     """Validate the classifier's raw envelope value into a typed model.
 
-    The classifier checks presence only; a value that fails shape validation
-    is treated as not supplied so the request still routes.
+    Rung 1 guarantees the envelope key was present; a ``null`` or mis-shaped
+    value falls through to ``ValidationError`` and is treated as not supplied
+    so the request still routes.
     """
-    if raw is None:
-        return None
     try:
         return model.model_validate(raw, by_name=False)
     except ValidationError:
 
@@ -27,7 +27,6 @@
     PARSE_ERROR,
     UNSUPPORTED_PROTOCOL_VERSION,
 )
-from mcp.types.methods import CLIENT_REQUESTS
 
 __all__ = [
     "ERROR_CODE_HTTP_STATUS",
@@ -60,13 +59,13 @@
 
 @dataclass(frozen=True)
 class InboundModernRoute:
-    """A modern-protocol request that passed every ladder rung.
+    """A modern-protocol request whose envelope passed every ladder rung.
 
     ``client_info`` and ``client_capabilities`` are the raw envelope values;
-    the classifier checks presence only, not shape.
+    the classifier checks presence only, not shape. Method existence is not a
+    ladder rung — kernel dispatch is the single source of truth for that.
     """
 
-    method: str
     protocol_version: str
     client_info: Any
     client_capabilities: Any
@@ -100,10 +99,9 @@ def classify_inbound_request(
     3. When ``headers`` is given, its ``MCP-Protocol-Version`` entry equals
        the envelope's protocol version → else
        :data:`~mcp.types.jsonrpc.HEADER_MISMATCH`.
-    4. ``(method, protocol_version)`` is a key of
-       :data:`mcp.types.methods.CLIENT_REQUESTS` → else
-       :data:`~mcp.types.jsonrpc.METHOD_NOT_FOUND`. Absence *is* the gate: a
-       method removed at a given version simply has no row.
+
+    Method existence is *not* a rung: kernel dispatch owns that decision so
+    custom-registered methods route and the answer lives in one place.
 
     Args:
         body: The decoded JSON-RPC request mapping. Envelope shape
@@ -138,15 +136,7 @@ def classify_inbound_request(
             message=f"{MCP_PROTOCOL_VERSION_HEADER} header does not match the request envelope's protocol version",
         )
 
-    method: Any = body.get("method")
-    if (method, protocol_version) not in CLIENT_REQUESTS:
-        return InboundLadderRejection(
-            code=METHOD_NOT_FOUND,
-            message=f"Method not found: {method!r} at protocol version {protocol_version}",
-        )
-
     return InboundModernRoute(
-        method=method,
         protocol_version=protocol_version,
         client_info=client_info,
         client_capabilities=client_capabilities,
 
@@ -923,6 +923,33 @@ async def discover(ctx: Ctx, params: RequestParams) -> Any:
     assert exc.value.error == ErrorData(code=METHOD_NOT_FOUND, message="Method not found", data="server/discover")
 
 
+@pytest.mark.anyio
+async def test_on_request_rejects_initialize_at_modern_version_with_method_not_found(server: SrvT):
+    """Spec-mandated: `initialize` has no `CLIENT_REQUESTS` row at the modern
+    version; kernel dispatch (not the inbound classifier) rejects it."""
+    born_ready = Connection.from_envelope(MODERN_PROTOCOL_VERSIONS[0], None, None)
+    async with connected_runner(server, initialized=False, connection=born_ready) as (client, runner):
+        assert runner.connection.protocol_version == MODERN_PROTOCOL_VERSIONS[0]
+        with pytest.raises(MCPError) as exc:
+            await client.send_raw_request("initialize", _initialize_params())
+    assert exc.value.error.code == METHOD_NOT_FOUND
+
+
+@pytest.mark.anyio
+async def test_on_request_dispatches_custom_method_registered_via_add_request_handler(server: SrvT):
+    """SDK-defined: a method outside `SPEC_CLIENT_METHODS` skips the version
+    gate and reaches its registered handler at any negotiated version."""
+
+    async def echo(ctx: Ctx, params: RequestParams) -> dict[str, Any]:
+        return {"echoed": True}
+
+    server.add_request_handler("myorg/echo", RequestParams, echo)
+    born_ready = Connection.from_envelope(MODERN_PROTOCOL_VERSIONS[0], None, None)
+    async with connected_runner(server, initialized=False, connection=born_ready) as (client, _):
+        result = await client.send_raw_request("myorg/echo", None)
+    assert result == {"echoed": True}
+
+
 @pytest.mark.anyio
 async def test_runner_middleware_short_circuit_on_a_wrong_version_spec_method_skips_the_sieve(server: SrvT):
     """A server-tier middleware that returns without calling `call_next` for a
 
@@ -152,54 +152,28 @@ def test_header_rung_rejects_on_disagreement(headers: dict[str, str]) -> None:
     assert_rejected(classify_inbound_request(envelope(), headers=headers), HEADER_MISMATCH)
 
 
-# --- rung 4: method-exists-at-version ------------------------------------------
-
-
-@pytest.mark.parametrize(
-    "method",
-    [
-        "initialize",
-        "ping",
-        "logging/setLevel",
-        "resources/subscribe",
-        "resources/unsubscribe",
-    ],
-)
-def test_method_rung_rejects_methods_removed_at_modern_version(method: str) -> None:
-    """Spec-mandated: absence from ``CLIENT_REQUESTS`` at the modern version *is* the gate — removed methods reject."""
-    rejection = assert_rejected(classify_inbound_request(envelope(method)), METHOD_NOT_FOUND)
-    assert method in rejection.message
-
-
-def test_method_rung_rejects_unknown_method() -> None:
-    """Spec-mandated: a method name not in the version's request table rejects METHOD_NOT_FOUND."""
-    assert_rejected(classify_inbound_request(envelope("does/not/exist")), METHOD_NOT_FOUND)
-
-
-def test_method_rung_rejects_absent_method_key() -> None:
-    """Spec-mandated: a body with no ``method`` key cannot route and rejects METHOD_NOT_FOUND."""
-    body = envelope()
-    del body["method"]
-    assert_rejected(classify_inbound_request(body), METHOD_NOT_FOUND)
-
-
 # --- all rungs pass ------------------------------------------------------------
 
 
-@pytest.mark.parametrize("method", ["tools/list", "tools/call", "server/discover"])
-def test_all_rungs_pass_yields_route(method: str) -> None:
+def test_all_rungs_pass_yields_route() -> None:
     """Spec-mandated: a complete envelope at a supported version with agreeing header routes, surfacing the envelope."""
-    result = classify_inbound_request(envelope(method), headers={MCP_PROTOCOL_VERSION_HEADER: MODERN})
+    result = classify_inbound_request(envelope(), headers={MCP_PROTOCOL_VERSION_HEADER: MODERN})
     assert isinstance(result, InboundModernRoute)
-    assert result.method == method
     assert result.protocol_version == MODERN
     assert result.client_info == CLIENT_INFO
     assert result.client_capabilities == CLIENT_CAPS
 
 
+@pytest.mark.parametrize("method", ["initialize", "myorg/custom", "does/not/exist"])
+def test_classifier_passes_unknown_method_through_to_route(method: str) -> None:
+    """SDK-defined: the classifier does not gate on method — kernel dispatch is the single owner of that decision."""
+    result = classify_inbound_request(envelope(method), headers={MCP_PROTOCOL_VERSION_HEADER: MODERN})
+    assert isinstance(result, InboundModernRoute)
+
+
 def test_ladder_first_failure_wins() -> None:
-    """Spec-mandated: rungs evaluate in order — version, header and method would all fail; the version rung fires."""
-    body = envelope("initialize", version=LATEST_PROTOCOL_VERSION)
+    """Spec-mandated: rungs evaluate in order — version and header would both fail; the version rung fires."""
+    body = envelope(version=LATEST_PROTOCOL_VERSION)
     result = classify_inbound_request(body, headers={MCP_PROTOCOL_VERSION_HEADER: MODERN})
     assert_rejected(result, UNSUPPORTED_PROTOCOL_VERSION)
 
@@ -224,7 +198,7 @@ def test_error_code_http_status_table(code: int, status: int) -> None:
 
 def test_error_code_http_status_covers_every_ladder_code() -> None:
     """SDK-defined: every code the ladder can emit has an HTTP-status entry, so the transport never has to default."""
-    ladder_codes = {INVALID_PARAMS, UNSUPPORTED_PROTOCOL_VERSION, HEADER_MISMATCH, METHOD_NOT_FOUND}
+    ladder_codes = {INVALID_PARAMS, UNSUPPORTED_PROTOCOL_VERSION, HEADER_MISMATCH}
     assert ladder_codes <= ERROR_CODE_HTTP_STATUS.keys()