Fable 5 Hits Make

Make added Claude Fable 5 to its automation platform, exposing Anthropic’s model inside the Make AI Agent (New) app and the Anthropic Claude (Create a Prompt module) app. The integration requires operators to bring their own Anthropic API key.

Make’s pitch is that Fable 5 is the model you reach for when a scenario step needs to chew through long context, read images or scanned documents, or do reasoning heavier than a normal prompt module can handle. Make positions it as a single-module workhorse: pull a batch of documents, charts, code, or support logs into one step, then pass structured output to whatever comes next, whether that’s a CRM update, an ERP write, an email, or a review queue.

Two hard numbers anchor the release: a 1 million token context window on the input side, and up to 128,000 output tokens per request. Make also calls out a specific refusal behavior. When Fable 5 declines a high-risk request, it returns a refusal response rather than an error, so scenarios can branch and retry on a different model (Make names Claude Opus 4.8 as the fallback example) without the run being marked failed.

One compliance note operators need to see up front: Anthropic enforces a mandatory 30-day data retention period on this model, and zero data retention is not available.

Key details

1Minput context tokens

128Koutput tokens per request

30 daysmandatory data retention

• Model name: Claude Fable 5
• Input context window: 1 million tokens
• Maximum output per request: 128,000 tokens
• Host apps in Make: Make AI Agent (New), Anthropic Claude (Create a Prompt module)
• Authentication: operator-supplied Anthropic API key
• Multimodal inputs: images, blueprints, financial charts, scanned PDFs, multi-page technical documents
• Use cases Make names: analyzing blueprint sets, a day of support conversations, large technical documents, code drafts, document comparison, dataset summarization, record updates, reports, review queues
• Refusal behavior: high-risk requests return a refusal response rather than a scenario error, with Claude Opus 4.8 as the named fallback
• Data retention: Anthropic mandatory 30-day retention; zero data retention not available

Why it matters

For Make specifically, this is the difference between “call an LLM inside a scenario” and “put a real reasoning step inside a scenario.” Automation platforms have spent the last two years bolting model calls onto flows designed for deterministic API glue. The moment you drop a million-token window into a module, the shape of what’s automatable changes. You stop chunking, you stop stitching, you stop building a pre-summarizer just to fit content into the prompt. One module ingests the whole thing.

That matters more on Make than on a chat surface, because Make scenarios are where operators wire long-context reasoning to actual system-of-record writes. A million tokens in isolation is a demo. A million tokens feeding a CRM update is a workflow that used to require a data pipeline.

The refusal-versus-error distinction is the other quiet signal. Most agent platforms still treat a model refusal as an exception the operator has to catch. Turning refusal into a first-class response type, one a router can branch on, is how you build fallback logic that doesn’t page someone at 2am. It’s a small API decision with real operational consequences for anyone running Make scenarios in production.

The mandatory 30-day retention is the countervailing signal. Any Make operator working under a contract that promises zero data retention, and there are a lot of them in regulated verticals, cannot route sensitive payloads through Fable 5 on Make today. That constraint will shape which scenarios adopt this model and which stay on whatever the operator was using before.

Fable 5's 30-day retention is mandatory with no zero-retention path, so scenarios touching regulated data should not route through it today.

How it compares

We don’t have a cross-platform snapshot for this release, so treat what follows as qualitative positioning rather than a spec-by-spec comparison.

Inside Make’s own model roster, Fable 5 slots in as the long-context, multimodal option, with Opus 4.8 named as the retry target when Fable refuses. That tells you how Make wants operators to route: Fable as the default heavy-lift model, Opus as the fallback when a request gets blocked, and presumably lighter models for cheaper per-step reasoning that doesn’t need a million tokens.

Against other automation platforms, the meaningful comparison isn’t which model is exposed. It’s whether the platform treats refusals as first-class response objects or as thrown errors. Make choosing the former is the piece worth flagging. Most agent and automation surfaces still leak model refusals up the stack as generic failures, forcing operators to build brittle string-matching to detect them.

On retention, the 30-day floor lands harder here than on a raw API. Operators using Make often signed contracts assuming they could steer sensitive data through zero-retention endpoints. That option is off the table for Fable 5 on Make, full stop.

Who should care

• Ops teams running document-heavy scenarios: the ones pre-chunking large PDFs, running a summarizer module, then feeding the summary into a second reasoning step. Collapse that into a single Fable 5 module and delete the pre-processing branch. The output ceiling means your final report or code artifact probably finishes in one call.
• Support and success automators: a full day of support conversation logs fits in one module now. Batch-classification and root-cause scenarios that ran per-ticket can run per-day, which changes what dashboards you can build downstream.
• Anyone maintaining review-queue or approvals scenarios: the refusal-as-response pattern is the piece to redesign around. Add an explicit branch that catches refusal objects and routes to Opus 4.8, and stop wrapping model modules in generic error handlers.
• Regulated-vertical teams (health, finance, legal): read the retention line carefully before enabling this in any scenario touching regulated data. If your contract requires ZDR, Fable 5 on Make is not the module for that scenario.
• Solo builders shipping agent-flavored side projects: the 1M / 128K envelope on a single module is the interesting part. Whole-repo code review, whole-book summarization, and whole-dataset analysis all fit inside one step now.

What changed practically

1. 1Ingest long or multimodal input into one Fable 5 module
2. 2Reason over the whole payload, up to 128K output
3. 3Map structured output into downstream modules
4. 4On refusal, branch and retry against Opus 4.8

Where it lives: two Make apps carry the model. The Make AI Agent (New) app, and the Anthropic Claude app, specifically the Create a Prompt module inside it. Operators authenticate with their own Anthropic API key rather than a Make-managed credential.

Context and output limits: 1 million tokens of input context per module call, up to 128,000 output tokens per request. Make frames the output ceiling as enough headroom for long summaries, code drafts, and full reports to finish inside a single module rather than being truncated and re-called.

Multimodal input: Fable 5 reads images and scanned documents directly inside the module, including blueprints, financial charts, scanned PDFs, and multi-page technical documents. Make’s framing is that the model returns data in a shape downstream modules can map directly, which is the part operators care about when wiring output into a Make mapping panel.

Refusal handling: a blocked request returns a refusal response object, not a scenario error. Scenarios can read that response, branch, and retry the same payload against another model, with Claude Opus 4.8 as the example fallback.

Retention: Anthropic’s 30-day retention applies. Zero data retention is unavailable for this model on Make.

What to watch next

Two things worth tracking over the next few weeks.

First, whether the refusal-as-response pattern becomes a Make-wide convention or stays scoped to Fable 5. If Make generalizes it across other model providers, that’s a real primitive for building production-grade routing scenarios, and other automation platforms will feel pressure to match. If it stays Anthropic-only, it’s a nice feature but not a platform shift.

Second, whether operators actually collapse multi-module reasoning chains into single Fable 5 calls, or keep the chunk-then-reason pattern for cost and control reasons. The million-token window makes the collapsed pattern possible, but Make scenarios are billed and monitored per operation. Expect a stretch of experimentation as teams figure out whether one giant module or five smaller ones is the better production shape.

The retention constraint is the other thing to watch. If Anthropic doesn’t offer a zero-retention path for Fable 5, expect regulated-vertical operators to keep older Claude versions or non-Anthropic models pinned in sensitive scenarios, which fragments the model routing story inside Make itself. The next test is whether Make ships routing patterns or templates that make that fragmentation manageable, or leaves operators to build it themselves.

Open questions

A few things the announcement doesn’t answer:

• Rate limits and concurrency: pushing a million tokens through a scenario module has implications for throughput, timeouts, and billing. The source doesn’t say how Fable 5 calls count against scenario limits or how long a single module call can run before Make times it out.
• Streaming and partial output: with a 128K output ceiling, whether Make streams tokens back or blocks until completion matters for tight execution windows. Not addressed.
• Structured output guarantees: Make says the model returns data “in a format your modules can map directly.” Whether Fable 5 supports strict JSON schemas, tool-use, or structured outputs inside the module isn’t spelled out.
• Refusal object shape: the most operationally interesting piece here, but the source doesn’t document the actual response schema. Operators building branch logic will need to test what the refusal object looks like before they can route on it.
• Cross-region availability and residency: no mention of where inference runs, which matters for operators with data-residency requirements on top of the retention constraint.
• Which existing modules deprecate: the source names two apps that get Fable 5 but says nothing about older Claude modules or whether operators should migrate.

Source: help.make.com