# The Stack Weekly, week 47: The frontier got cheaper twice this week, and Cloudflare finally caps your bill

> Seven things worth your time from 9 to 15 November 2026. The top of the market moved twice: Claude Fable 5.2 took first place on the index with a 20% price cut, and Gemini 4 Carbon opened to every paying developer at half its future price, until 30 November. Google also shipped a decision API that doesn't beat my pick, Cloudflare finally lets you cap a Workers bill, AWS gave away a local emulator for your agents' tests, and Node.js patched 16 holes.

- 9–15 November 2026, published 16 November 2026 by Nicolas Dao (Cloudless Labs, Sydney)
- Judged against The Stack: https://cloudlesslabs.com/stack/brief.md
- Web page: https://cloudlesslabs.com/weekly/2026-w47/

## Claude Fable 5.2, by Anthropic

- New. Verdict: Watching. Medium risk.
- Pain: Some jobs beat even Opus: the long agent run that ends half-done, the hard bug it circles. Until now the only model above it cost $10 in and $50 out per million tokens.
- Fix: Fable 5.2 is first on the Artificial Analysis index at 65, at $8 in and $40 out, 20% cheaper than Fable 5.1, and on Bedrock the same day.
- Value: The best model you can buy, a fifth cheaper per token, but still 2.6 times Sonnet per task.
- Company: Anthropic, founded 2021
- Product: Generally available from 9 November 2026; retirement no sooner than 9 November 2027; third Fable release in ten weeks
- In The Stack: [Anthropic API (for client systems)](https://cloudlesslabs.com/stack/anthropic-api/index.md), [Amazon Bedrock](https://cloudlesslabs.com/stack/aws-bedrock/index.md), [OpenRouter](https://cloudlesslabs.com/stack/openrouter/index.md)

Anthropic shipped Claude Fable 5.2 on 9 November, ten weeks after Fable 5.1. It's a point release that matters for one reason: it's now the strongest model you can buy, first on the Artificial Analysis Intelligence Index at **65** at maximum effort, and it's **20% cheaper per token**: $8 in and $40 out per million tokens, down from $10 and $50. Mythos 5.2 is the same model with the cyber and biology safeguards relaxed, for vetted organisations only.

That's a price drop at the frontier of intelligence, which is always news here. But read the per-task numbers before you switch anything:

| Model | Index | Cost per task |
|---|---|---|
| Claude Fable 5.2 (max) | 65 | $26.54 |
| Gemini 4 Carbon (high) | 60 | $5.48 |
| Claude Opus 5.5 (max) | 59 | $10.04 |
| GPT-6 Astra (max) | 57 | $6.24 |
| Claude [Sonnet 5.5](https://cloudlesslabs.com/stack/anthropic-api/index.md) (max) | 55 | $10.02 |

Fable at max effort buys ten points over Sonnet for **2.6 times the cost per task**. At high or xhigh effort it scores 62, but the index doesn't publish a cost for those. Anthropic's own guidance is the sensible one: start with Opus, and move to Fable only when Opus at high effort fails your evals. Opus costs the same per task as Sonnet and scores four points higher, which is the quieter story of the season.

**On Bedrock** it arrived the same day, on the global and US profiles. Read the data terms before you route client work there: Bedrock requires the `aws_review` retention mode for this model, AWS keeps all Fable traffic for 30 days, and flagged traffic can be read by AWS staff. Anthropic's own API treats it as a covered model with 30-day retention too, so zero data retention isn't on offer anywhere.

**Gotchas, with fixes:**
- **Rate limits are a quarter of Sonnet's** at the Start tier: 500K input and 100K output tokens a minute. Cache your prompts, since cache reads don't count, and ramp traffic up gradually.
- **Breaking API changes:** `tool_choice` set to `any` or a named tool returns a 400, so do disabled thinking and a `budget_tokens` setting, and temperature and top-p are gone. Use `auto` with strict tools, drop the sampling parameters, and keep the conversation history append-only.
- **Effort defaults to high,** not medium. Set it per request, and keep max for the jobs that justify $26.
- **The tokenizer** (since Opus 4.7) produces about 30% more tokens for the same text than older Claude models. Re-measure your own prompts before you compare bills.

**What it can do now:** work unattended for hours with subagents (Anthropic's claim), a fast mode at 2.5 times the output speed for double the price ($16 / $80), thinking preserved across turns, and an advisor tool with a Fable advisor (beta). It's guaranteed until at least 9 November 2027.

**My verdict: watching. This is the model for the job Opus can't finish, not a new default. For most production work, Opus or Sonnet costs less than half as much per task and does the job.**

Sources:

- [Anthropic: Claude Fable 5.2 and Mythos 5.2](https://www.anthropic.com/claude-fable-and-mythos-5-2)
- [Claude docs: what's new in Fable 5.2](https://platform.claude.com/docs/en/models/fable-5-2/whats-new-fable-5-2)
- [Claude API pricing](https://platform.claude.com/docs/en/about-claude/pricing)
- [Bedrock model card: Claude Fable 5.2](https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-anthropic-claude-fable-5-2.html)
- [Bedrock: abuse detection and data retention](https://docs.aws.amazon.com/bedrock/latest/userguide/abuse-detection.html)
- [Claude API: rate limits](https://platform.claude.com/docs/en/api/rate-limits)
- [Artificial Analysis leaderboard](https://artificialanalysis.ai/leaderboards/models)

## Gemini 4 Carbon, now open to every paying developer, by Google

- Follow-up. Verdict: Worth a pilot. Medium risk.
- Pain: You pay Sonnet prices for Sonnet-level answers on your hardest jobs, and the one model scoring higher for less was locked behind a cyber-defenders programme.
- Fix: Carbon opened to paying developers on 10 November. It scores 60 on the index at $5.48 per task, against Sonnet 5.5's 55 at $10.02, at $2 in and $10 out until 30 November.
- Value: Five points above Sonnet for about half the cost per task, for two weeks, then about the same cost.
- Company: Google
- Product: Stable model id from 10 November 2026, paid tier only; Vertex AI gated to verified enterprise customers; Hydrogen from 12 November
- In The Stack: [Anthropic API (for client systems)](https://cloudlesslabs.com/stack/anthropic-api/index.md), [OpenRouter](https://cloudlesslabs.com/stack/openrouter/index.md), [Google Cloud](https://cloudlesslabs.com/stack/google-cloud/index.md)

Two weeks ago I wrote that Gemini 4 Carbon scored above everything except Anthropic's top model, and that you couldn't have it: only a group of cyber defenders could. On 10 November Google opened it to every paying developer through the Gemini API and AI Studio, under a stable model id. On OpenRouter it's `google/gemini-4-carbon`.

**The price is the story, and it has an end date.** Carbon costs **$2 in and $10 out** per million tokens **until 30 November**, then **$4 and $20 from 1 December**. Cached input doubles too. At today's price, Artificial Analysis puts it at **60 at $5.48 per task**, against Sonnet 5.5's 55 at $10.02: five points better for a little over half the cost. That's down from $7.76 a week earlier, with the same score and the same list price, and the index doesn't say why. Gemini 4 Argon's cost per task halved the same way, from $9.95 to $4.97. From 1 December, by my arithmetic, Carbon lands at about **$10.96 per task** if it uses the same tokens: level with Sonnet and Opus on cost, and still a point above Opus.

So Carbon is the best score per dollar at the frontier for two weeks, then a fair alternative. That's a pilot with a deadline, and nothing to sign a client up for at the introductory price.

Its sibling Hydrogen (12 November, $1.50 / $7.50) is under Looked at, skipped.

**What it can do now that it couldn't:** anyone paying can use it (the cyber variant stays allowlisted), with a 1M-token context and up to 1M tokens of output through background decoding, plus computer use, code execution and grounding. Flex and batch run at half price, and Google's Antigravity can run a swarm of agents on it (preview).

**Gotchas, with fixes:**
- **Vertex access is gated** to verified enterprise customers. Use the Gemini API or OpenRouter instead.
- **It thinks a lot.** Thinking is billed as output and counts against `max_output_tokens`, so answers can stop early. Set 32,768 or more, use `background: true` past 65,536 tokens of output, and give the client a timeout of 15 minutes or more.
- **The OpenRouter AI Studio endpoint caps a completion at 32,768 tokens.** Use the Vertex global endpoint for long output. The Vertex US and EU endpoints are 10% dearer, at $2.20 / $11.
- **New accounts start at Tier 1.** Tier 2 needs $100 spent and three days. Plan for that before a demo.

This is how I'd run the trial: through [OpenRouter](https://cloudlesslabs.com/stack/openrouter/index.md), on a copy of a real job you already run on Sonnet, scored against your own evals, with the budget set at $4 / $20 from the first day. If it wins at the December price, keep it. If it only wins in November, enjoy November.

**My verdict: pilot it now, with a 30 November deadline. It doesn't replace Sonnet 5.5 as my pick: one vendor, and the price doubles in two weeks.**

Sources:

- [Google: Gemini 4 Carbon now available](https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-carbon-now-available/)
- [Gemini API pricing](https://aistudio.google.com/docs/pricing)
- [Gemini API: what's new in Gemini 4 Carbon](https://aistudio.google.com/docs/whats-new-gemini-4-carbon)
- [Vertex AI: Gemini 4 Carbon](https://docs.cloud.google.com/vertex-ai/generative-ai/docs/models/gemini/4-carbon)
- [Google: introducing Gemini 4 Hydrogen](https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-hydrogen/)
- [OpenRouter: Gemini 4 Carbon endpoints](https://openrouter.ai/api/v1/models/google/gemini-4-carbon/endpoints)
- [Artificial Analysis leaderboard](https://artificialanalysis.ai/leaderboards/models)

## Gemini Decisions API, by Google

- Follow-up. Verdict: Watching. Medium risk.
- Pain: The yes, no or label step in your product still runs on an LLM prompt, and the only decision models with a probability you can act on come from startups you'd hesitate to put in a client contract.
- Fix: Google now sells one: up to 1,000 closed questions over one input of up to 256K tokens, a probability per answer in about 200 ms, at $0.10 per million input tokens and free output.
- Value: A decision model from a vendor that won't vanish, at the same price as my pick, but not better.
- Company: Google
- Product: Launched 11 November 2026 on the v1beta Gemini API, neither GA nor preview by label; Vertex AI "coming soon"
- In The Stack: [Baseten decision models](https://cloudlesslabs.com/stack/baseten-decision-models/index.md), [Jev](https://cloudlesslabs.com/stack/typesafe-jev/index.md)

Decision models, which return a probability per answer instead of a paragraph, are the paradigm shift I keep pointing at: they make AI reliable in software without paying for more intelligence. Last week Sarvam and Perplexity widened the field. This week Google joined it, and that changes what you can put in a client contract.

**What Google shipped on 11 November.** The Gemini Decisions API (`gemini-decision-1`) takes one input (text, images, audio, video or a PDF, up to 256K tokens) and up to **1,000 closed questions** about it: yes or no, pick one of 2 to 255 options, or a rubric score. It returns a probability for each answer and a confidence, in about 150 to 250 ms end to end, Google says. It costs **$0.10 per million input tokens, and output is free**. At the 500-token decision my [decision model guide](https://cloudlesslabs.com/stack/guides/which-decision-model/index.md) assumes, that's about **$50 per million decisions** by my arithmetic: the same as Baseten's mammoth-1 and OpenAI Decisions, and about 2.4 times Jev's $21. Each question's instructions are billed as input too, so that's a floor. And because the input is billed once for all its questions, a long document with many questions works out cheaper per question.

**Is it any good?** Google says it has the lowest calibration error of the decision models, on Google's own test. The one independent board that lists it, Benchmark Heaven's API board, gives it a Capability score of **78.5** and calibration of **89.6**, ahead of Jev 1.14 (75.0) and OpenAI Decisions (73.5), slightly behind both on calibration (90.1). My pick, [Baseten's mammoth-1](https://cloudlesslabs.com/stack/baseten-decision-models/index.md), scores 85.2 on the open-weights board. That's a different board, so treat the gap as indicative, but nothing here says Google beat it.

**Why it still matters:** a decision model from a vendor that won't be gone in a month, with published rate limits (1,500 requests a minute at Tier 1, 15,000 at Tier 3), a deprecation page and a 256K context, against mammoth-1's 16,384 tokens. When Microsoft, OpenAI, Perplexity, Sarvam and now Google all ship the same new kind of model within two months, the idea is real.

**The field, in one paragraph.** Decision models were **26.1% of the requests on Vercel's AI Gateway in October**, up from 12.8% in September, but only 0.53% of the spend: exactly the point of them. Vercel put Parallel Decisions, which searches the live web and cites its evidence, on its gateway free until 23 November. Amazon's Strands team published a case study cutting ticket labelling from about $0.0222 to $0.0005 per ticket by replacing Sonnet 4.6 with a small decision model, Amazon's own figures. And Perplexity's Decider v1.3 can now **locate**: it returns the exact text span behind an answer, with offsets, under Apache 2.0.

**Gotchas, with fixes:**
- **v1beta, with no GA or preview label.** Wrap the call in an adapter so you can swap to mammoth-1 or OpenAI in a day.
- **The free tier uses your data** to improve Google's products, with human review. Never send client content without a paid key.
- **Paid data is logged for an unspecified period,** and Vertex support is only "coming soon". For anything confidential, open weights you host yourself remain the answer.

**My verdict: watching Google's, as the big-vendor option for long documents and big batches of questions. No change to my pick: mammoth-1 scores higher, costs the same and comes with weights you can leave with.**

Sources:

- [Google: Gemini Decisions API](https://blog.google/innovation-and-ai/technology/developers-tools/gemini-decisions-api/)
- [Gemini API: Decisions API docs](https://aistudio.google.com/docs/decisions-api)
- [Gemini API pricing](https://aistudio.google.com/docs/pricing)
- [Gemini API: rate limits](https://aistudio.google.com/docs/rate-limits)
- [Benchmark Heaven: decision APIs](https://benchmarkheaven.com/jev-models/api)
- [Vercel: AI Gateway Production Index, November 2026](https://vercel.com/blog/ai-gateway-production-index-november-2026)
- [Vercel: Parallel Decisions free on AI Gateway](https://vercel.com/changelog/parallel-decisions-now-available-on-ai-gateway-for-free)
- [Strands: Amazon replaces Sonnet with Strands Decider](https://strandsagents.com/blog/amazon-saves-millions-replacing-sonnet-with-strands-decider/)
- [Hugging Face: Perplexity Decider v1.3](https://huggingface.co/perplexity-ai/pplx-decider-v1.3)

## Spend Management for Workers and Durable Objects, by Cloudflare

- New. Verdict: Worth a pilot. Low risk.
- Pain: A runaway loop or a bot flood on a pay-per-use Worker keeps billing until somebody reads an email, and on AWS nothing will stop a Lambda because of a dollar figure either.
- Fix: Set a dollar cap per product. Cloudflare emails you at 80% and 100%, and at the limit it rejects new Workers or Durable Object invocations until you lift it.
- Value: A circuit breaker on the bill, free and opt-in, in beta.
- Company: Cloudflare, founded 2009
- Product: Beta from 13 November 2026 for pay-as-you-go accounts; Workers and Durable Objects only, more products promised
- In The Stack: [Cloudflare Workers](https://cloudlesslabs.com/stack/cloudflare-workers/index.md), [Cloudflare Durable Objects](https://cloudlesslabs.com/stack/cloudflare-durable-objects/index.md), [Cost Explorer (with Claude Code)](https://cloudlesslabs.com/stack/aws-cost-explorer/index.md)

The most common horror story on serverless isn't an outage, it's a bill: a loop that calls itself, a bot that finds an expensive endpoint, a weekend nobody watched. Until this week, Cloudflare could only email you about it. On 13 November it shipped **Spend Management, in beta**: a dollar cap per product that actually stops the spending. An X post called it GA; it isn't.

**How it works.** You set a monthly limit in dollars for **Workers** (requests and CPU time) and, separately, for **Durable Objects** (requests, duration, SQLite rows and KV operations). Cloudflare emails you at 80% and 100%. At the limit, it **rejects new invocations** of that product across the account, pauses Cron Triggers and Queue consumers, and keeps serving static assets. Raise the limit, delete it, or wait for the next billing cycle, which starts on your subscription date, not the first of the month. You can manage it in the dashboard, with the `cf` CLI or through a REST API.

**Before and after.** Before: a runaway Worker bills until a human reads the alert. After: the bill stops within minutes. On AWS, the nearest thing is Budget Actions, which can apply an IAM deny or stop EC2 and RDS instances, but nothing stops a Lambda because of a dollar figure. Reserved concurrency caps the rate, not the money.

**Gotchas, with fixes:**
- **It's account-wide per product.** A cap on Workers stops every Worker on the account, production included, not just the one that ran away. Put experiments in their own Cloudflare account, set the production cap well above your peak, or leave production on alerts only until you trust the number.
- **It's not a guaranteed maximum.** Spend is reported within about 10 minutes and enforcement is asynchronous, so you can overshoot. Set the cap below what you can actually afford.
- **It doesn't cover R2, Workers AI, KV or Queues,** and Durable Object storage keeps billing while blocked. Use AI Gateway's own spend limits for inference.
- **A limit made in the dashboard has no email recipient.** Set `notification_email` through the API or the CLI.
- **No Terraform or Pulumi resource yet.** Script it with the API from CI.

**Its quiet companion:** on 10 November, Workflows gained a **per-Workflow concurrency limit**, and the instances over the limit queue instead of failing. It's the back-pressure I get from SQS in front of Lambda, now in config (Wrangler 4.127.0 or later). Keep it in the committed config, because a deploy without it removes it.

**My verdict: pilot. Turn it on today for every account where Workers is a side project, and on alerts only for production until you've seen it fire. [Workers](https://cloudlesslabs.com/stack/cloudflare-workers/index.md) stays my edge default, and now it has a fuse.**

Sources:

- [Cloudflare blog: Spend Management](https://blog.cloudflare.com/spend-management/)
- [Cloudflare changelog: Spend Management](https://developers.cloudflare.com/changelog/post/2026-11-13-spend-management/)
- [Cloudflare docs: spend limits](https://developers.cloudflare.com/billing/manage/spend-management/)
- [Cloudflare API: spend policies](https://developers.cloudflare.com/api/resources/billing/subresources/spend_policies/)
- [Cloudflare changelog: per-Workflow concurrency limits](https://developers.cloudflare.com/changelog/post/2026-11-10-per-workflow-concurrency-limits/)
- [Vercel: Spend Management](https://vercel.com/docs/spend-management)
- [AWS: Budget actions](https://docs.aws.amazon.com/cost-management/latest/userguide/budgets-controls.html)

## Node.js November security releases, by OpenJS (Node.js)

- New. Verdict: No change to my pick. Low risk.
- Pain: Your Node.js containers terminate TLS or HTTP/2 themselves, and this week 16 security fixes landed, 7 of them high, most in exactly that code.
- Fix: Rebuild on Node 22.23.5, 24.22.3 or 26.13.1 and redeploy. Zip Lambdas on automatic runtime updates are patched by AWS, and never see raw HTTP/2 anyway.
- Value: One rebuild closes remote crashes and a TLS key leak; Lambda users mostly wait.
- Company: OpenJS Foundation
- Product: Security patch releases on 11 November 2026 for the 22, 24 and 26 lines
- In The Stack: [Node.js](https://cloudlesslabs.com/stack/nodejs-javascript/index.md), [AWS Lambda](https://cloudlesslabs.com/stack/aws-lambda/index.md), [Fargate services (always on)](https://cloudlesslabs.com/stack/aws-fargate-service/index.md), [Neon (serverless Postgres)](https://cloudlesslabs.com/stack/neon/index.md)

On 11 November the Node.js project shipped **16 security fixes, 7 of them high**, in 22.23.5, 24.22.3 and 26.13.1. One sweep reported 18 with 9 high; the project's own post says 16. Most are in the code that terminates HTTP/2 and TLS: a remote client can crash a default HTTP/2 server, two use-after-free bugs in HTTP/2 stream handling, a session that never gets cleaned up and leaks memory and file descriptors, a TLS server crash, a client-certificate check that can be bypassed through TLS 1.2 renegotiation, and an HTTPS bug that can leak heap memory, TLS keys included, if you call `res.flushHeaders()` before the body ends.

**Who must act, in plain words:**
- **Containers running Node that terminate TLS or HTTP/2 themselves** (on Fargate, EC2 or anywhere): rebuild on a fixed version and redeploy, today. The official `node` Docker images were rebuilt on 11 and 12 November.
- **Fargate behind a default ALB target group:** the ALB talks HTTP/1.1 to your task, so the HTTP/2 bugs can't reach you. An HTTPS target group still puts Node's TLS code in scope. Rebuild anyway.
- **[Lambda](https://cloudlesslabs.com/stack/aws-lambda/index.md), zip-packaged, on the default automatic runtime updates:** a function URL hands your code an event, never raw HTTP/2 or TLS, so you're not exposed to the worst of it, and AWS patches the runtime itself. The Lambda base images were rebuilt on 15 November, but I couldn't confirm which Node version the managed runtime runs now. Log `process.version` at start-up and you'll know.
- **Container-image Lambdas and functions on "Function update" or "Manual"** don't move on their own. Rebuild from `public.ecr.aws/lambda/nodejs` and redeploy, or deploy any change. Leave Manual only as a short rollback.

**Postgres patched the same week.** PostgreSQL 18.7, 17.12, 16.16, 15.20 and 14.25 came out on 12 November with fixes for 52 CVEs, and 14.25 is the last PG14 release. [Neon](https://cloudlesslabs.com/stack/neon/index.md) moved to the new versions on 13 November, which is the managed-database argument in one line. On RDS or Aurora, check your maintenance window. If you still run 14, it's time to plan the upgrade.

AWS's runtime calendar annoys me, but in a week like this, the platform patches while container owners rebuild.

**My verdict: no change to my pick. Rebuild every Node container today; let AWS patch zip Lambdas, and check `process.version` to see it land.**

Sources:

- [Node.js: November 2026 security releases](https://nodejs.org/en/blog/vulnerability/november-2026-security-releases)
- [AWS Lambda: runtime version updates](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-update.html)
- [AWS Lambda: invoking function URLs](https://docs.aws.amazon.com/lambda/latest/dg/urls-invocation.html)
- [ALB: target groups](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html)
- [Docker Hub: node](https://hub.docker.com/_/node)
- [PostgreSQL 18.7, 17.12, 16.16, 15.20, 14.25 and 19 RC 2 released](https://www.postgresql.org/about/news/postgresql-187-1712-1616-1520-1425-and-19-rc-2-released-3442/)
- [Neon changelog](https://neon.com/docs/changelog)

## AWS Emulator, by AWS

- New. Verdict: Worth a pilot. Medium risk.
- Pain: Your agents' integration tests hit a real AWS dev account: slow, billed, shared between agents, and every agent needs credentials. The local alternative, LocalStack, now charges for commercial use.
- Fix: AWS's own emulator runs the AWS API on 127.0.0.1, free and CC0. Point the SDK at it with environment variables and S3, SQS or Secrets Manager calls work with no account.
- Value: Free, account-free AWS tests for agents and CI, with honest fidelity scores.
- Company: AWS, founded 2006
- Product: Generally available from 11 November 2026, v1.0.385 on 14 November; issues only, no outside pull requests; no support commitment
- In The Stack: [Playwright, Vitest, pytest](https://cloudlesslabs.com/stack/testing/index.md), [Claude Code](https://cloudlesslabs.com/stack/claude-code/index.md), [GitHub Actions](https://cloudlesslabs.com/stack/github-actions/index.md), [Pulumi](https://cloudlesslabs.com/stack/pulumi/index.md)

Agentic coding changed what a test suite costs. An agent runs the integration tests dozens of times an hour, so a real AWS dev account means slow round trips, a bill, stray resources, agents colliding with each other, and credentials handed to every one of them. The local alternative was LocalStack, and its free Hobby plan is now non-commercial only, with Base at $39 a month on an annual plan, while the old Community edition gets no more updates, not even security fixes.

On 11 November AWS made the problem its own: **AWS Emulator**, generally available, free, and released under **CC0**. It's a single Rust program from the official `aws` GitHub organisation that serves the AWS API on `https://127.0.0.1:9297`. Set a few environment variables (`AWS_ENDPOINT_URL` and friends) and your existing CLI or SDK code runs unchanged, with no account, no deployment and no cost. Resources live in memory and vanish when it stops, so every run starts clean.

**The honest part is the fidelity score.** Each release publishes, per service, how many of AWS's own fidelity tests pass against real AWS, and an operation it doesn't implement returns a loud HTTP 501 rather than a quiet wrong answer. It also ships an agent skill (`aws agent-toolkit add-skill --skill-name aws-emulator`, AWS CLI 2.35.0 or later) so [Claude Code](https://cloudlesslabs.com/stack/claude-code/index.md) can install it, start it and check whether your repo will work against it.

**What it isn't, and the fix for each:**
- **It doesn't evaluate IAM or resource policies.** A permission bug passes locally. Test policies against real AWS, and never call this a security test.
- **No persistence** (an open issue). Seed state in the test setup.
- **One account and one Region per process,** whatever Region string you send. Run one emulator per port if you need two.
- **Lambda is partial.** Open issues show invokes working for some runtimes, with memory growth, while Cognito triggers and API Gateway–Lambda wiring are listed as not working. Keep those flows on a real dev account.
- **IaC is experimental.** Terraform works through the endpoint variable for some resources, but `aws_s3_bucket` fails on provider 6.23.0 and later, and security groups fail too. I found nothing on [Pulumi](https://cloudlesslabs.com/stack/pulumi/index.md) either way.

This is how I'd wire it for a client: the emulator in every agent's sandbox and in CI for the SDK-level tests (S3, SQS, Secrets Manager), and one real dev account for IAM, Cognito and the final check before production. The agents never get real credentials, and the cloud bill for testing goes to near zero.

**My verdict: pilot it for agent and CI integration tests. It's not a replacement for a real account, and it doesn't need to be.**

Sources:

- [AWS News Blog: test your applications against AWS locally with AWS Emulator](https://aws.amazon.com/blogs/aws/test-your-applications-against-aws-locally-with-aws-emulator/)
- [AWS Emulator user guide](https://docs.aws.amazon.com/emulator/latest/userguide/what-is-service.html)
- [AWS Emulator: fidelity](https://docs.aws.amazon.com/emulator/latest/userguide/fidelity.html)
- [AWS Emulator: pointing your SDK at it](https://docs.aws.amazon.com/emulator/latest/userguide/point-sdk-to-emulator.html)
- [aws/aws-emulator on GitHub](https://github.com/aws/aws-emulator)
- [LocalStack pricing](https://www.localstack.cloud/pricing)

## Cognito token exchange, by AWS

- New. Verdict: Watching. Medium risk.
- Pain: Your MCP server calls another API for the signed-in user, so it either forwards the user's own token, which the MCP spec forbids, or uses a service key with far more power than the user has.
- Fix: Cognito now swaps the user's token for a short-lived one, bound to one downstream API, with only the scopes it needs and an act claim naming the agent.
- Value: Agents that act for a user with the user's rights, not their own, on a managed service.
- Company: AWS, founded 2006
- Product: Generally available from 12 November 2026 on the Essentials and Plus plans; the account must have it enabled; SDK and Terraform support lagging
- In The Stack: [Amazon Cognito](https://cloudlesslabs.com/stack/aws-cognito/index.md), [Better Auth](https://cloudlesslabs.com/stack/better-auth/index.md), [Self-hosted MCP servers](https://cloudlesslabs.com/stack/mcp-servers/index.md)

Every MCP server I build hits the same question: when the agent calls a downstream API for a signed-in user, whose rights does it use? The lazy answers are both wrong. Forward the user's own token, and you're doing the token passthrough the MCP spec forbids, with the wrong audience and every scope the user has. Use a service key, and the agent has more power than the user, and your logs can't say who did what.

On 12 November **Cognito** shipped the standard answer, **RFC 8693 token exchange**, generally available. The MCP server presents the user's token, plus its own token as the actor, and asks for one downstream API. Cognito returns a short-lived token of about an hour, with no refresh token, bound to that API's audience, with only the scopes the user, the request and the app client all share, and an `act` claim naming the agent. The downstream API sees both the user and the agent, and a leaked token is narrow and expires on its own. The same call exists as a new SDK operation, `GetDerivedToken`. It can also swap a token from a registered OIDC or SAML provider. A day earlier, Cognito gained **session management**: list, revoke and cap a user's sessions, with managed-login SSO sessions of up to 90 days per app client.

**The catches, which are why it's a watch:**
- **Essentials or Plus only,** not Lite. Essentials is $0.015 per monthly active user after the first 10,000 free; Plus is $0.020 with no free tier. No per-exchange price is published, so I can't promise there isn't one.
- **The account must be enabled for it,** or you get `OperationNotEnabledException`, also in the replica Regions of a multi-Region pool. The docs don't say how. Test it in the client's account and Region before you design around it.
- **One audience per call and no `may_act`,** so Cognito won't restrict which agents may act for a user. Check `act.sub` in the downstream API.
- **Tooling lags.** Terraform's AWS provider 6.73.0 doesn't support the new app-client flows, and a third-party test found the AWS CLI and boto3 without the API. POST to the token endpoint until they catch up.

**Against my pick.** For serious apps on Postgres, [Better Auth](https://cloudlesslabs.com/stack/better-auth/index.md) comes first, and it got the same delegation in its OAuth provider this week: in **1.8.0-beta.9** on 12 November, with DPoP-bound exchange in beta.10 on 15 November. Beta only, so stay on 1.7.x in production. For a small app or an internal tool already on [Cognito](https://cloudlesslabs.com/stack/aws-cognito/index.md) Essentials, this is the cleanest way I've seen to let an [MCP server](https://cloudlesslabs.com/stack/mcp-servers/index.md) act for a user on a managed service.

**My verdict: watching until the account switch is documented and Terraform supports it. Then it's how I'd wire an MCP server on Cognito.**

Sources:

- [AWS What's New: Cognito token exchange](https://aws.amazon.com/about-aws/whats-new/2026/11/cognito-token-exchange/)
- [Cognito: exchanging tokens for downstream services](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-token-exchange.html)
- [Cognito API: GetDerivedToken](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_GetDerivedToken.html)
- [Cognito: managing user sessions](https://docs.aws.amazon.com/cognito/latest/developerguide/managing-user-sessions.html)
- [Cognito pricing](https://aws.amazon.com/cognito/pricing/)
- [Better Auth: OAuth provider](https://www.better-auth.com/docs/plugins/oauth-provider)

## Looked at, skipped

- [EC2 G7 GPU instances in more Regions](https://aws.amazon.com/about-aws/whats-new/2026/11/amazon-g7-additional-regions/) (AWS): An RTX PRO 4500 Blackwell with 32 GB reaching four more Regions is a footprint change, not news. The smallest size, g7.2xlarge, is about three times Runpod's L40S per hour for less memory, so Runpod stays my GPU.
- [Gemini 4 Hydrogen](https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-hydrogen/) (Google): A fast, cheap executor for Carbon at $1.50 / $7.50, scoring 54 at $3.16 per task, while GPT-6.1 Sol scores 55 at $1.27. Cheaper mediocre intelligence changes nothing when the frontier already sells it for less.
- [Stripe closes its OpenRouter acquisition](https://openrouter.ai/blog/announcements/openrouter-is-joining-stripe/) (Stripe and OpenRouter): Only the press says the deal closed on 10 November; neither company's own page did by Sunday. Nothing changes for your code either way: same key, same API.
- [Lambda MicroVMs on x86](https://aws.amazon.com/about-aws/whats-new/2026/11/aws-lambda-microvms-x86-architecture/) (AWS): Good news for code with x86-only binaries, but it doesn't change what MicroVMs are for or my watch verdict. They go on the watch list's next check, not this week's slot.
- [AWS Nitro Sandboxes for EKS, ECS and EC2](https://aws.amazon.com/about-aws/whats-new/2026/11/nitro-sandboxes-eks-ecs-ec2/) (AWS): A hardware-isolated VM per pod or task, which matters if you run Kubernetes for untrusted code. For a small team that's two problems you didn't need; Cloudflare Sandbox and Lambda MicroVMs already do the job.
- [Next-generation AgentCore runtime becomes the default](https://aws.amazon.com/about-aws/whats-new/2026/11/new-agentcore-runtime-default/) (AWS): Faster starts and scale to zero, for a managed agent runtime I don't use: my agents run in plain Lambda or a sandbox, and a third party reports dearer per-unit rates that I couldn't confirm.
- [CloudWatch Logs account-level retention policies](https://aws.amazon.com/about-aws/whats-new/2026/11/amazon-cloudwatch-log-retention/) (AWS): Free: set one retention for the whole account so no log group keeps "never expire". Do it today, it takes a minute, but it's a setting, not a story.
- [ElastiCache Serverless for Valkey gains vector and full-text search](https://aws.amazon.com/about-aws/whats-new/2026/11/amazon-elasticache-serverless-search-aggregations/) (AWS): A cache that now wants to be your search engine too. Postgres with pgvector and full-text search already does this next to the data, without a second system to keep in sync.
- [Tailscale OAuth apps, and Grok Bot on the tailnet](https://tailscale.com/blog/oauth-apps-ga) (Tailscale and xAI): OAuth apps going GA is welcome plumbing. Giving a chatbot a seat on your private network is the opposite of what a tailnet is for, until it can be scoped as tightly as a person.
- [OpenOrange, the Workers API on any cloud](https://openorange.dev) (Rivet): Days old, with cost claims from the vendor alone. Running Workers off Cloudflare gives up the network that makes Workers worth it. Play with it on a weekend, not in a client's stack.
- [CoreWeave Database](https://www.unite.ai/coreweave-launches-managed-postgresql-inside-ai-compute-clusters/) (CoreWeave): Managed Postgres inside a GPU cluster, for teams that already live on CoreWeave. Mine don't, and Neon is the Postgres I'd pick anywhere else.
- [DocumentDB 1.0](https://documentdb.io/blogs/posts/documentdb-1-0/) (Linux Foundation (started at Microsoft)): Old news (19 October) dressed as this week's, and a MongoDB-compatible layer on Postgres solves a problem you only have if you chose MongoDB. Use Postgres with JSONB and skip the costume.
- [Val Town winding down](https://blog.val.town/winding-down) (Val Town): A lovely product closing is the two-year gate in action. If you hosted anything there, move it to a Worker this week.
- [Lambda Web Functions billing memory after the last request](https://www.easel.sh/blog/lambda-web-functions-idle-memory) (AWS (finding by Easel)): A third-party test says idle environments keep billing memory for minutes after the last request. AWS hasn't confirmed it; I'll test it myself before I trust either side.
- [Better Auth 1.8 beta](https://github.com/better-auth/better-auth/releases/tag/v1.8.0-beta.9) (Better Auth (Vercel)): Token-exchange delegation and DPoP for its OAuth provider, which matters for MCP servers, but it's a beta. Stay on 1.7.x in production, and never below 1.7.16.
- [Claude Code Code Mode](https://github.com/anthropics/claude-code/releases) (Anthropic): Experimental in v2.1.323 and barely documented. I'll write about it once it's out of the lab.
- [Inkling 2 Small on Workers AI](https://developers.cloudflare.com/changelog/post/2026-11-12-inkling-2-small-workers-ai/) (Cloudflare (model by Thinking Machines Lab)): A 31 on the index, far from the frontier, on a platform where open models cost up to twice OpenRouter's price.
- [Muse Ember](https://openrouter.ai/meta/muse-ember) (Meta): Cheap at $0.10 / $0.50, and 36 on the index, level with Haiku 5.5. Below the frontier, so it changes nothing.
- [Hatchet v2](https://hatchet.run/announcement/hatchet-v2) (Hatchet): Another durable-execution engine to run yourself, in a category where Lambda durable functions cover my case inside the client's account.
- [ClickHouse buys Xata](https://www.businesswire.com/news/home/20261109580526/en/ClickHouse-Unifies-Enterprise-AI-Data-Stack-with-Launch-of-Expanded-Platform) (ClickHouse): Only search snippets confirmed it; the release itself wouldn't load. A funding-and-acquisitions story with no product change for anyone on Neon.

## For the geeks

### Claude Fable 5.2 on Bedrock (global profile)

```python
from anthropic import Anthropic
from aws_bedrock_token_generator import provide_token

token = provide_token(region="us-east-1")

client = Anthropic(
    base_url="https://bedrock-runtime.us-east-1.amazonaws.com/anthropic",
    api_key=token,
)

response = client.messages.create(
    model="global.anthropic.claude-fable-5-2",  # global cross-region profile
    max_tokens=16000,
    messages=[{"role": "user", "content": "Can you explain the features of Amazon Bedrock?"}],
)
print(response)
```

Source: [Bedrock model card](https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-anthropic-claude-fable-5-2.html). Set the `aws_review` retention mode before the first call.

### Gemini 4 Carbon: one call

```python
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-4-carbon",
    input="Write a three.js script that renders a realistic 3D black hole with gravitational lensing."
)

print(interaction.output_text)
```

Source: [What's new in Gemini 4 Carbon](https://aistudio.google.com/docs/whats-new-gemini-4-carbon). Use a paid key, and budget at the December price.

### Gemini Decisions API: one yes-or-no question

```python
from google import genai

client = genai.Client(http_options={"api_version": "v1beta"})

result = client.decisions.create(
    model="gemini-decision-1",
    input="The blue mug I ordered on Monday arrived cracked on Wednesday.",
    questions={
        "is_damaged": {
            "type": "noul",  # Google's name for a yes-or-no question
            "instructions": "Did the item arrive damaged?",
        },
    },
)

answer = result.answers["is_damaged"]
print(f"P(yes)={answer.noul:.2f} confidence={answer.confidence:.2f}")
```

Source: [Decisions API docs](https://aistudio.google.com/docs/decisions-api). Act on a threshold you calibrated on your own labelled cases.

### Cloudflare: a Workers spending cap from CI

```bash
curl --fail-with-body --request POST \
  "https://api.cloudflare.com/client/v4/accounts/${CLOUDFLARE_ACCOUNT_ID}/billing/spend-policies" \
  --header "Authorization: Bearer ${CLOUDFLARE_API_TOKEN}" \
  --header "Content-Type: application/json" \
  --data '{"name":"Workers spending cap","product_id":"workers","enabled":true,"threshold_cents":10000,"action":"usage_block","notification_email":"me@example.com"}'
```

Source: [Cloudflare blog](https://blog.cloudflare.com/spend-management/). Use `"action":"notification"` to alert without blocking.

### Lambda: choose how the runtime gets patched, and check it

```typescript
import * as aws from "@pulumi/aws";

// Auto is the default. FunctionUpdate patches the runtime only when you deploy.
new aws.lambda.RuntimeManagementConfig("api-runtime", {
  functionName: fn.name,
  updateRuntimeOn: "Auto", // "Auto" | "FunctionUpdate" | "Manual"
});

// In the handler, log the Node version that is actually running:
export const handler = async () => ({ node: process.version });
```

Source: [Pulumi registry](https://www.pulumi.com/registry/packages/aws/api-docs/lambda/runtimemanagementconfig/).

### AWS Emulator: point the CLI and SDK at it

```bash
export AWS_ENDPOINT_URL=https://127.0.0.1:9297
export AWS_SHARED_CREDENTIALS_FILE=~/.aws/emulator/9297/emulator_credentials
export AWS_CONFIG_FILE=~/.aws/emulator/9297/config
export AWS_CA_BUNDLE=~/.aws/emulator/9297/ca.pem
export AWS_EC2_METADATA_DISABLED=true
export AWS_DISABLE_HOST_PREFIX_INJECTION=true
export AWS_REGION=us-east-1
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILE
# after starting it: aws-emulator --telemetry off
aws s3api create-bucket --bucket amzn-s3-demo-bucket
python -c "import boto3; print(boto3.client('s3').list_buckets()['Buckets'])"
```

Source: [AWS Emulator user guide](https://docs.aws.amazon.com/emulator/latest/userguide/point-sdk-to-emulator.html).

### Cognito: exchange a user's token for a downstream API

```http
POST /oauth2/token HTTP/1.1
Host: example-domain.auth.us-west-2.amazoncognito.com
Content-Type: application/x-www-form-urlencoded
Authorization: Basic Base64Encoded(client_id:client_secret)

grant_type=urn:ietf:params:oauth:grant-type:token-exchange&
subject_token=eyJra456defEXAMPLE&
subject_token_type=urn:ietf:params:oauth:token-type:access_token&
audience=solar-system-data&
scope=solar-system-data/asteroids.add
```

Source: [Cognito developer guide](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-token-exchange.html). Add `actor_token` and `actor_token_type` for delegation, so the new token carries an `act` claim.

## Coverage

Window 9 to 15 November 2026 (UTC). Scanned the AWS What's New and News Blog feeds, the Cloudflare changelog and blog, InfoQ, Hacker News, the release notes and advisories of the tools in the stack, X and Google News, the week's new models on OpenRouter, Hugging Face and Workers AI, the Artificial Analysis leaderboard, every topic past editions covered, plus open searches across every concern in the catalog. X posts didn't load, Reddit returned almost nothing, and the search budget ran out during the last checks, so the final verifications read primary pages directly. Stripe's close of the OpenRouter deal is reported by the press only, so it stays a rumour here. Not exhaustive: if it matters and it's missing, tell me.

## Related

- [Every edition of The Stack Weekly](https://cloudlesslabs.com/weekly/index.md): newest first, with summaries
- [The Stack, in one file](https://cloudlesslabs.com/stack/brief.md): the catalog these items are judged against
- [Map of every Markdown file on cloudlesslabs.com, with what each one answers](https://ask.cloudlesslabs.com)
