MCP July 28 RC Checklist: 6 JSON Changes Every Developer Must Handle

The MCP 2026 Release Candidate ships July 28, 2026 — 42 days from today. It is not a minor version bump. Six changes directly affect how JSON flows between MCP clients, servers, and tool calls. Miss any one of them and your MCP server either silently misbehaves or hard-fails on July 28.

This is a checklist post. If you want the deep dive on schema keyword migration, see the MCP 2026 JSON Schema migration guide. If your MCP tools are producing bad JSON today, fix it first, then come back here to make sure your schemas survive the RC.

---

The 6 JSON Changes at a Glance

---

Change 1: outputSchema — Your Tool Outputs Get Type-Checked

This is the biggest new capability in MCP RC 2026 and the one most developers aren't prepared for.

In MCP 2025.x, only inputSchema was defined. Tool outputs were untyped — the client received whatever JSON the tool returned. The RC adds outputSchema: a JSON Schema 2020-12 declaration that describes what your tool promises to return.

// MCP RC 2026 — tool with both input AND output schema
{
  name: "get_order_status",
  description: "Returns status and ETA for a given order ID",
  inputSchema: {
    type: "object",
    properties: {
      order_id: { type: "string" }
    },
    required: ["order_id"]
  },
  outputSchema: {          // NEW in RC — was undefined in 2025.x
    type: "object",
    properties: {
      status: { type: "string", enum: ["pending", "shipped", "delivered"] },
      eta_days: { type: "integer" },
      tracking_url: { type: "string", format: "uri" }
    },
    required: ["status"]
  }
}

Checklist item 1: For every tool that returns structured JSON, add an outputSchema declaration. If your tool currently returns inconsistent structures (optional fields sometimes missing, types varying), the RC validator will surface those failures explicitly — which is better than silent data corruption downstream.

If you're generating output schemas programmatically, validate them first at aijsonmedic.com/validate before shipping.

---

Change 2: inputSchema Upgrades to JSON Schema 2020-12

MCP 2025.x used JSON Schema draft-07 for inputSchema. The RC moves to JSON Schema 2020-12. Most simple schemas work unchanged — the breakage is in specific keywords.

What Breaks

// BROKEN in RC — draft-07 style schema
{
  "type": "object",
  "definitions": {             // ← REMOVED in 2020-12
    "Address": {
      "type": "object",
      "properties": {
        "street": { "type": "string" }
      }
    }
  },
  "properties": {
    "shipping": { "$ref": "#/definitions/Address" }
  }
}

// FIXED for RC — use $defs
{
  "type": "object",
  "$defs": {                   // ← correct 2020-12 keyword
    "Address": {
      "type": "object",
      "properties": {
        "street": { "type": "string" }
      }
    }
  },
  "properties": {
    "shipping": { "$ref": "#/$defs/Address" }  // ← path updated
  }
}

The other common breakage: $recursiveRef / $recursiveAnchor (draft-07) → $dynamicRef / $dynamicAnchor (2020-12). If you're using these for recursive schema definitions (tree structures, nested JSON), update the keyword names.

Checklist item 2: Search your schema definitions for definitions, $recursiveRef, $recursiveAnchor, additionalItems. Each one is a migration target.

grep -r '"definitions"\|"\$recursiveRef"\|"\$recursiveAnchor"\|"additionalItems"' \
  ./src --include=".ts" --include=".json"

For a complete keyword mapping, see the MCP 2026 JSON Schema migration guide.

---

Change 3: Composition Now Works in Tool Schemas

This is actually good news. In draft-07 for MCP, oneOf, anyOf, and allOf had inconsistent support across SDKs. In MCP RC 2020-12, they are first-class — and $ref plus $defs work correctly for schema reuse.

// NOW VALID in RC — inputSchema with anyOf + $ref
{
  inputSchema: {
    type: "object",
    properties: {
      identifier: {
        anyOf: [
          { type: "string", format: "email" },
          { type: "string", pattern: "^USR-[0-9]{6}$" }
        ]
      }
    },
    required: ["identifier"]
  }
}

If you previously had workarounds for this limitation — extra validation logic in tool handlers, manual type checking — you can remove them after July 28 and let the schema handle it.

Checklist item 3: Audit tool schemas for manual type-union workarounds. Replace with anyOf or oneOf for cleaner definitions.

---

Change 4: Error Code -32002 → -32602

JSON-RPC error code -32002 was used in MCP 2025.x for parameter validation failures. The RC aligns with the official JSON-RPC 2.0 specification and remaps this to -32602 ("Invalid params").

If your MCP client parses error codes to detect validation failures — to retry with corrected params, to surface errors to users, or to log specifically — you need to update the check:

# BEFORE — catches 2025.x validation errors only
if error["code"] == -32002:
    handle_validation_error(error)

AFTER — catches RC validation errors
if error["code"] == -32602:
    handle_validation_error(error)

Or handle both during transition window
VALIDATION_ERROR_CODES = {-32002, -32602}
if error["code"] in VALIDATION_ERROR_CODES:
    handle_validation_error(error)

// TypeScript equivalent
const VALIDATION_CODES = new Set([-32002, -32602]);
if (VALIDATION_CODES.has(error.code)) {
  handleValidationError(error);
}

Checklist item 4: Find every place your client code checks for -32002. Update to check -32602 (or both during the transition).

grep -r "\-32002" ./src --include=".ts" --include=".py" --include="*.js"

---

Change 5: Sessions Protocol Removed from Core

The MCP 2025.x sessions protocol (maintaining stateful context across multi-turn tool calls) is removed from the core spec in the RC. The core protocol becomes fully stateless.

Stateful behavior moves to the Extensions framework — a new formalized way to add optional capabilities to MCP servers.

What this means for JSON:

• Any session token or session context you embed in tool call JSON is no longer part of the core protocol
• If you rely on session continuity for multi-step JSON workflows (e.g., building a JSON object across multiple tool calls), you need to move to explicit context passing or wait for the Extensions spec to finalize

Checklist item 5: Audit any tool call JSON that includes session state or assumes session continuity. Add explicit context parameters where needed, or flag these tools for review before July 28.

---

Change 6: Formal Deprecation Policy + SDK Tier Timelines

The RC introduces a formal deprecation policy. Tier 1 SDKs (official Anthropic-maintained MCP SDKs) must ship RC support within 10 weeks of the RC publication — putting the deadline around early October 2026 for SDK implementations.

But the spec itself ships July 28. If you're running a community MCP server or using an unofficial SDK, check its maintenance status now.

Checklist item 6: Check your MCP SDK version and its RC roadmap. If it's a community package with no RC milestone, plan to pin to a pre-RC version until the maintainer ships support.

# Check your SDK version
npm list @modelcontextprotocol/sdk
pip show mcp

---

Pre-July 28 Testing Workflow

Before the RC drops, test your schemas and JSON outputs systematically:

Step 1: Validate all tool schemas against JSON Schema 2020-12

Use aijsonmedic.com/validate to paste your inputSchema and outputSchema definitions. If they fail validation, the JSON repair tool can auto-fix common structural issues like definitions → $defs, trailing commas, and malformed $ref paths.

Step 2: Check error code handling

Write a unit test that simulates an -32602 error response and verify your error handler triggers correctly.

Step 3: Test stateless tool execution

Run each tool in a fresh context with no session state. If a tool fails without session continuity, add explicit context parameters before July 28.

Step 4: Run against the RC SDK in a staging environment

Watch for schema validation errors on the output side — the new outputSchema enforcement will surface JSON shape inconsistencies you may not have noticed before.

If you're hitting MCP schema errors in production already, the MCP JSON Schema error fix guide covers the most common validation failure patterns.

---

FAQ

What happens on July 28 if I haven't migrated?

The RC spec ships July 28. Tier 1 SDKs (official Anthropic-maintained packages) start tracking RC compliance with a 10-week window. For the spec itself, stable release follows the RC — so July 28 is the start of the final validation period, not a hard cutover. However, schemas written for draft-07 may fail validation on RC-compliant clients from that date forward.

Do I need to add outputSchema to all my tools? outputSchema is not required — it's optional in the RC. But if you don't add it, you lose the ability for RC-compliant clients to validate and type-check your tool outputs. For any tool returning structured JSON, adding an output schema is strongly recommended. Does JSON Schema 2020-12 break backward compatibility with draft-07 schemas?

For simple schemas (flat objects with primitive properties), there's no change. The breaking changes are specific to: definitions, $recursiveRef, $recursiveAnchor, and additionalItems. If your schemas don't use those keywords, they work unchanged in 2020-12.

What should I do with JSON that's already broken in my MCP tool outputs?

Fix the output first, then add a schema. Paste your broken tool output JSON into AI JSONMedic's repair tool — it handles truncated JSON, wrong quote types, trailing commas, and structural errors from LLM-generated tool call payloads.

Where do I find the full MCP RC specification?

The official RC spec and changelog are at modelcontextprotocol.io. For the specific JSON Schema migration path (keyword-by-keyword), see the MCP 2026 JSON Schema migration guide on this site.

What are the most common MCP JSON Schema validation errors right now?

The most common patterns before the RC are $dynamicRef misuse, invalid $ref paths, and anyOf used incorrectly. The MCP JSON Schema error guide covers all five of the most frequent error types with fixes.

---

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What happens on July 28 if I haven't migrated my MCP server?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "The MCP RC spec ships July 28, 2026. Tier 1 SDKs have a 10-week window to ship RC support. Schemas using deprecated draft-07 keywords (definitions, $recursiveRef) may fail validation on RC-compliant clients from that date. The safest approach is migrating inputSchema to JSON Schema 2020-12 and adding outputSchema before July 28."
      }
    },
    {
      "@type": "Question",
      "name": "Is outputSchema required in MCP RC 2026?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "outputSchema is optional in MCP RC 2026, but strongly recommended for any tool returning structured JSON. Without it, RC-compliant clients cannot validate or type-check tool outputs. Adding outputSchema is a one-time improvement that catches JSON shape inconsistencies before they reach downstream consumers."
      }
    },
    {
      "@type": "Question",
      "name": "What JSON Schema keywords break when upgrading from draft-07 to 2020-12 for MCP?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Four keywords break: 'definitions' (replaced by '$defs'), '$recursiveRef' (replaced by '$dynamicRef'), '$recursiveAnchor' (replaced by '$dynamicAnchor'), and 'additionalItems' (replaced by 'items' in the 2020-12 meaning). Simple flat schemas with type, properties, and required are unaffected."
      }
    },
    {
      "@type": "Question",
      "name": "Why did MCP change error code -32002 to -32602?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "The MCP 2026 RC aligns with the official JSON-RPC 2.0 specification, which defines -32602 as 'Invalid params'. The previous MCP-specific use of -32002 was non-standard. Clients that check for -32002 to detect parameter validation failures must update to check -32602 after July 28."
      }
    },
    {
      "@type": "Question",
      "name": "What does removing the sessions protocol mean for JSON in MCP?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "The MCP 2026 RC removes the sessions protocol from the core spec. The core becomes stateless — no session token or session context is part of the standard JSON wire format. Stateful behavior moves to the Extensions framework. Any tool call JSON that embeds session context needs explicit context passing or an extension implementation after July 28."
      }
    },
    {
      "@type": "Question",
      "name": "How do I validate my MCP tool schemas against JSON Schema 2020-12?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Paste your inputSchema or outputSchema JSON into aijsonmedic.com/validate — it validates against JSON Schema 2020-12 and highlights keyword errors. For broken schema JSON (syntax errors, trailing commas, wrong $ref paths), use aijsonmedic.com/json-repair to auto-fix structural issues before validating."
      }
    }
  ]
}