Running Fable 5 Agents on Vercel's eve Framework

Two things shipped in 2026 that are better together than apart. Vercel's eve turns the repetitive plumbing of a production agent - durable sessions, a sandbox, approvals, subagents, evals - into a folder of files. Fable 5, Anthropic's most capable widely released model, is the reasoning engine you want driving a long, multi-step run. This post is the practical version: how eve's primitives pair with Fable 5's long-horizon strengths, a concrete architecture, honest costs, and the one refusal behavior you have to handle before you ship.

Why pair eve with Fable 5 specifically

eve's whole pitch is that the plumbing should not be your code. As Vercel puts it in the launch post, "agents today are where the web was before frameworks, with everyone hand-rolling the same plumbing and nothing carrying over to the next one." You define an agent as files, eve compiles it into an app on Vercel Functions, and durability, sandboxing, and approvals come wired in.

That framing matters more for a strong model than a weak one. The reason is where each model spends its lead: Anthropic positions Fable 5 so that the longer and more complex the task, the bigger its advantage. A model that can hold a 1M-token context and keep reasoning across dozens of tool calls is exactly the model that most needs durable sessions, a real sandbox, and a subagent story - because it will actually attempt runs long enough to hit crashes, redeploys, and timeouts. eve supplies that operational spine. Fable 5 supplies the reasoning. Neither is trying to be the other.

The primitives you are actually composing

eve is filesystem-first. You define an agent under an agent/ directory and eve discovers the files, per the eve docs:

my-agent/
└── agent/
    ├── agent.ts            # Model and runtime config
    ├── instructions.md     # System prompt
    ├── tools/              # Typed functions, one tool per file
    ├── skills/             # On-demand procedures loaded when relevant
    ├── channels/           # Message integrations
    └── schedules/          # Cron jobs

The pieces that carry the Fable 5 stack:

• Model config via AI Gateway. agent.ts names a model string that resolves through Vercel's AI Gateway, so eve is model-agnostic. You point it at an Anthropic model by editing one line.
• Durable sessions. Sessions checkpoint each step and survive crashes, cold starts, and deploys, backed by Vercel Workflow. A five-step run that dies at step three resumes instead of restarting.
• Sandboxed compute. Agent-generated code runs isolated from your app runtime in Vercel Sandbox, which went generally available on January 30, 2026 as, in Vercel's words, the execution layer for agents.
• Human-in-the-loop approvals. A high-stakes tool call can require manual authorization before it proceeds.
• Subagents. A parent agent delegates to child agents with isolated contexts, keeping the parent's context window clean.
• Evals. Scored test suites verify behavior locally or in CI.

A practical architecture: eve agent, Fable 5 orchestrator, Sandbox for code

The shape that gets the most out of both tools is a three-layer split.

Layer 1 - the eve agent (the app). This is your agent/ folder. It owns the session lifecycle, the tool surface, the approval gates, and the channels the agent talks over. It is the deployable unit on Vercel Functions.

Layer 2 - Fable 5 as the orchestrator. Set the top-level agent's model to Fable 5 and let it plan the run, decide which tools and subagents to invoke, and reason across the long context. Because eve resolves models through the gateway, this is a one-line config. The eve docs show agent.ts in this shape:

import { defineAgent } from 'eve';

// Model resolved through Vercel AI Gateway.
// Illustrative; use the exact gateway model id from your dashboard.
export default defineAgent({
  model: 'anthropic/claude-fable-5',
});

Fable 5's adaptive thinking is always on; you tune depth with the effort parameter rather than toggling reasoning on and off. For an orchestrator that decomposes a big task and delegates, a higher effort on the parent and cheaper models on the leaf subagents is the natural cost shape.

Layer 3 - Vercel Sandbox for code execution. When the agent needs to write and run code - a data transform, a migration script, a generated test - that executes in the sandbox, not your app runtime. eve wires a sandboxed tool through Vercel Sandbox so a model that is genuinely writing and executing code cannot reach into your application. Each tool is one file in agent/tools/, following the documented defineTool shape:

import { defineTool } from 'eve/tools';
import { z } from 'zod';

// Illustrative tool shape - adapt to the current eve API.
export default defineTool({
  description: 'Run a short Python script in an isolated sandbox.',
  inputSchema: z.object({
    code: z.string(),
  }),
  async execute(input) {
    // Delegate execution to Vercel Sandbox; return stdout/stderr.
    // ...
    return { ok: true };
  },
});

The division of labor is clean: eve owns durability and isolation, Fable 5 owns the plan, and the sandbox owns anything the model tries to run.

Handling refusals inside an eve agent

This is the part that will silently break the stack if you ignore it. Fable 5 ships with a cybersecurity safety classifier, and when it refuses a request it returns stop_reason: "refusal" as a normal 200 response, not an HTTP error, per Anthropic's model documentation. If your agent only handles HTTP errors, a refusal looks like a successful but empty completion, and the run stalls with no obvious cause.

Two things make this a day-one concern rather than an edge case. First, the post-return safety classifier that let Fable 5 redeploy globally on July 1, 2026 trades more benign false positives on coding and debugging for tighter safety, so a code-writing agent will hit refusals more than you expect. Second, Anthropic supports a server-side fallbacks parameter and documents Opus 4.8 as the fallback target, and you are not billed when the model refuses before producing output.

In eve terms, treat this as a tool-and-orchestrator concern: have the orchestrator recognize a refusal stop reason and route the step to a fallback model (Opus 4.8) rather than surfacing an empty result to the session. Because eve sessions are durable, the retried step slots back into the same run. We covered the refusal-handling pattern for multi-agent setups in more depth in handling Fable 5 refusals across agent fleets.

Honest costs

There are two meters running, and they bill differently.

The model. Fable 5 is $10 per 1M input tokens and $50 per 1M output tokens, per the model card. That sits above the Opus 4.8 tier ($5 / $25), so an orchestrator that reasons over a long context and emits large outputs is the expensive part of the run. The lever you have is the effort parameter and the subagent split: keep Fable 5 on the planning and reasoning, push mechanical leaf work to cheaper models through the same gateway.

The compute. Vercel Sandbox is billed for the compute an agent actually uses while running code, not a flat idle fee, and it scales to zero when nothing is executing. For the current dimensions and numbers, price it against your own workload from the Vercel Sandbox pricing and docs rather than a headline rate, because a code-heavy agent and a mostly-reasoning agent land in very different places. We compared the sandbox options builders actually choose between in where should your AI agent run code.

The honest summary: the model tokens are usually the dominant cost for a reasoning-led agent, and the sandbox is the variable you control by how much code the agent runs. Neither has a free tier you should design around.

Who this stack fits

Reach for eve plus Fable 5 when three things are true. You are already on Vercel or comfortable deploying there, since eve deploys natively to Vercel today with other platforms described as coming soon. Your agent runs long, multi-step tasks where a strong reasoning model earns its price - migrations, research-and-synthesis, multi-tool operational work - rather than a single classify-or-extract call a cheaper model handles fine. And you want the operational concerns (durability, isolation, approvals, subagents, evals) handled by the framework instead of your own code.

If your agent is a short, high-volume, single-shot call, Fable 5 is overkill and eve's durability machinery is more than you need. If you are multi-cloud and cannot commit to Vercel's deployment story yet, treat eve's platform caveat seriously. But for a builder who wants a long-horizon agent in production without hand-rolling the spine, eve gives you the folder and Fable 5 gives you the reasoning, and the two compose cleanly.

Frequently Asked Questions

Can eve run Anthropic models like Fable 5?

Yes. eve resolves its model string through Vercel's AI Gateway, which is model-agnostic, so you point agent.ts at an Anthropic model by editing one line. Use the exact gateway model id shown in your Vercel dashboard.

How does eve keep a long Fable 5 run from failing on a deploy?

eve sessions are durable. They checkpoint each step and survive crashes, cold starts, and redeploys via Vercel Workflow, so a long run resumes from its last checkpoint instead of starting over. That durability is most valuable precisely with a model like Fable 5 that attempts long, multi-step tasks.

What happens when Fable 5 refuses a request inside an agent?

It returns stop_reason: "refusal" as a 200 response, not an error, per Anthropic's model docs. Build a fallback path that detects the refusal stop reason and routes to Opus 4.8. You are not billed when the model refuses before producing output.

Is this stack production-ready today?

eve launched as a public preview and is in beta, so its API surface can shift before general availability, and it deploys natively to Vercel with other platforms marked coming soon. Vercel Sandbox and Fable 5 are both generally available. Treat eve's beta status as the main stability caveat.

Sources

• Introducing eve - Vercel blog
• eve documentation - Vercel docs
• Vercel Sandbox is now generally available - Vercel blog
• Vercel Sandbox - Vercel docs
• Vercel AI Gateway - Vercel docs
• Vercel Workflow - Vercel docs
• Introducing Claude Fable 5 and Claude Mythos 5 - Anthropic docs
• Redeploying Fable 5 - Anthropic