Claude 2026 Feature Guide: API, Tool Use, MCP, Structured Output, and AI Agents

1. Why a longer feature list makes production more brittle

From late 2025 into 2026, Anthropic moved “call tools”, “attach MCP”, and “emit JSON Schema” onto the main Messages path: output_config.format replaced the beta output_format; tools may set strict: true so grammar-constrained sampling keeps arguments valid; remote MCP can ride in the same request via mcp_servers plus type: "mcp_toolset". Docs are clear. Engineering still collapses three jobs into one:

• Human-readable prose and machine-ingest JSON in one unschematized text blob;
• Local scripts, SaaS, and write-capable MCP tools flattened into one tools array for the model to pick;
• An “agent” defined as “repeat the same user turn 20 times” with no max steps and no tool_use audit.

Demos work; tickets fill with JSONDecodeError, bad enums, and MCP servers treated as a universal shell. The Claude API is not “missing features”. Entry, execution, and context were never split. If the agent must run xcodebuild, execution also lands on real Mac hardware—the same ops problem as a self-hosted GitHub Actions macOS runner, not a prompting problem.

2. What each layer is (What)

2.1 Claude API — conversation entry, not an agent product

The Claude API (Messages) is the entry that attaches model, messages, system prompt, cache, and billing to your system. It does not execute tools for you and does not guarantee json.loads. Chat completion is a valid use. The moment a downstream service writes a database, opens a ticket, or triggers CI, you stack the later layers. Ask first: is this call consumed by a human or a parser?

2.2 Tool Use — an execution plane you own

Tool Use lets the model emit tool_use blocks; your server runs them and returns tool_result. Use it for implementations you own: inventory, tickets, repo scripts. For 2026 production, put strict tool use on the definition: strict: true plus input_schema uses the same grammar pipeline as structured outputs, which cuts “string 2 instead of number” crashes. The cost: the schema must fit Anthropic’s supported JSON Schema subset.

2.3 MCP connector — remote tool plane, not another SDK

The Messages MCP connector declares remote servers (URL, OAuth) and an mcp_toolset to enable all tools, an allowlist, or a denylist. It solves discovery and transport: you do not hand-write Anthropic tool JSON for every SaaS. It is not automatic safety—filesystem or shell MCP still needs a gateway or allowlist. Protocol “why USB” and this page’s “how to hang a server on the API” are complementary, not duplicates.

2.4 Structured Output — context for parsers, not voice for readers

Structured Output uses output_config.format with json_schema so the model’s text block is valid JSON. Use it for field extraction, report objects, contracts for the next service. It is orthogonal to Tool Use: JSON-only, strict tools only, or both. It does not replace tool calls—pretty JSON never fires HTTP for you.

2.5 AI agent — loop policy, not a fifth API product

An AI agent here is: model picks a tool → you execute → results return → until stop. Stop conditions are yours: max rounds, banned tool names, budget, human confirm. The loop can be Tool Use only or mixed with MCP. Structured Output fits the final handoff. “Fully automatic” without a loop cap is unbounded retry.

3. Core comparison (How Compare)

4. How to choose (Decision)

Fix the consumer and the side effects first, then pick layers. The matrix splits on whether you mutate external state.

5. Recommended stacks

Stack features. Do not hunt for a single product name.

• Personal scripts / internal bots: Claude API + 2–5 owned tools + strict. Skip MCP until the secret surface is worth it.
• Growing SaaS support agent: owned write tools (tickets) + read-only MCP knowledge + Structured Output at the end for QA.
• Platform / multi-team: MCP gateway for auth and rate limits; orchestrator for steps and budget; billing writes stay owned Tool Use.
• macOS / iOS build agent: expose only “enqueue job on named runner”; real xcodebuild runs on a stable cloud Mac, not model-driven ad-hoc SSH.

Versus IDE Skills: the API agent owns loops with system side effects; Claude Code Skills own in-repo developer SOPs. Both may mention MCP; do not share one credential table for write access.

6. Pitfalls

• “MCP means we can drop Tool Use” → write paths, compliance, and idempotency stay owned and audited.
• “Structured Output is an agent” → it only constrains text JSON; it does not perform side effects.
• “strict works on any nested JSON Schema” → stay in the documented subset; deep oneOf / dynamic keys fail.
• Treating legacy beta output_format and output_config as two products → transition compatibility only; new code uses output_config.format.
• “Stronger models need no max steps” → steps are money and blast radius, not IQ.
• Copy-pasting strict into every MCP client schema → strip API-only fields on generic MCP channels.

7. Seven rollout steps

1. Inventory side effects: read queries, internal writes, CI triggers, production. One tool table per class.
2. Ship one owned tool: minimal input_schema + strict: true; prove tool_use → execute → tool_result.
3. Split human vs machine delivery: machine contracts via Structured Output or a dedicated parse call.
4. Attach MCP read-only: mcp_servers + allowlist; keep writes owned.
5. Wrap the loop: max N steps, timeouts, token budget, reject undeclared tool names.
6. Observe: log tool name, arg hash, latency, schema failures—not only the final assistant text.
7. Pin heavy execution: macOS jobs on cloud Mac / self-hosted runners; the agent emits a job id, not a laptop shell.

# Pseudocode — use the official SDK in production
POST /v1/messages
{
  "model": "claude-opus-4-6",
  "max_tokens": 2048,
  "tools": [{
    "name": "create_ticket",
    "strict": true,
    "input_schema": {
      "type": "object",
      "properties": {
        "title": {"type": "string"},
        "severity": {"type": "string", "enum": ["low","high"]}
      },
      "required": ["title","severity"],
      "additionalProperties": false
    }
  }],
  "output_config": {
    "format": {
      "type": "json_schema",
      "schema": {
        "type": "object",
        "properties": {
          "ticket_id": {"type": "string"},
          "next_action": {"type": "string"}
        },
        "required": ["ticket_id","next_action"],
        "additionalProperties": false
      }
    }
  },
  "messages": [{"role": "user", "content": "Open a high-severity ticket: build timed out"}]
}

Pin model IDs to your console and the Tool Use overview. Before prod, confirm output_config and strict no longer depend on leftover beta headers in your SDK version.

8. Conclusion

Claude API answers how the model joins the system. Tool Use answers owned execution and guaranteed arguments. MCP answers remote discovery and trimming. Structured Output answers the parser contract. The AI agent answers when the loop stops and how large the blast radius is. These are not five parallel “new feature” headlines. They are one entry, two execution planes, one delivery format, and orchestration you must write. Draw side-effect boundaries first; then turn on MCP and the loop so demos survive production.

Further reading: Structured outputs · Strict tool use · MCP connector · MCP protocol intro