W47: 9–15 November 2026. By Nicolas Dao · published . RSS

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.

69 candidates, 149 searches, 9 research agents, 7 worth your time

This week in 30 seconds

The problem you know, the fix, who ships it, and what it's worth. Each card links to the detail.

  1. 01 Watching. The 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. The 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. Claude Fable 5.2 by Anthropic: The best model you can buy, a fifth cheaper per token, but still 2.6 times Sonnet per task. Medium risk. The details on Claude Fable 5.2
  2. 02 Follow-up Worth a pilot. The 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. The 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. Gemini 4 Carbon, now open to every paying developer by Google: Five points above Sonnet for about half the cost per task, for two weeks, then about the same cost. Medium risk. The details on Gemini 4 Carbon, now open to every paying developer
  3. 03 Follow-up Watching. The 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. The 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. Gemini Decisions API by Google: A decision model from a vendor that won't vanish, at the same price as my pick, but not better. Medium risk. The details on Gemini Decisions API
  4. 04 Worth a pilot. The 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. The 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. Spend Management for Workers and Durable Objects by Cloudflare: A circuit breaker on the bill, free and opt-in, in beta. Low risk. The details on Spend Management for Workers and Durable Objects
  5. 05 No change to my pick. The 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. The 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. Node.js November security releases by OpenJS (Node.js): One rebuild closes remote crashes and a TLS key leak; Lambda users mostly wait. Low risk. The details on Node.js November security releases
  6. 06 Worth a pilot. The 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. The 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. AWS Emulator by AWS: Free, account-free AWS tests for agents and CI, with honest fidelity scores. Medium risk. The details on AWS Emulator
  7. 07 Watching. The 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. The 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. Cognito token exchange by AWS: Agents that act for a user with the user's rights, not their own, on a managed service. Medium risk. The details on Cognito token exchange

01 Watching. Medium risk.

Claude Fable 5.2 by Anthropic

The best model you can buy, a fifth cheaper per token, but still 2.6 times Sonnet per task.

The 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.

The 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.

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 (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.

02 Follow-up Worth a pilot. Medium risk.

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

Five points above Sonnet for about half the cost per task, for two weeks, then about the same cost.

The 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.

The 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.

Previously: Covered in week 45. Here is what changed since.

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, 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.

03 Follow-up Watching. Medium risk.

Gemini Decisions API by Google

A decision model from a vendor that won't vanish, at the same price as my pick, but not better.

The 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.

The 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.

Previously: Covered in week 46. Here is what changed since.

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 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, 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.

04 Worth a pilot. Low risk.

Spend Management for Workers and Durable Objects by Cloudflare

A circuit breaker on the bill, free and opt-in, in beta.

The 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.

The 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.

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 stays my edge default, and now it has a fuse.

05 No change to my pick. Low risk.

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

One rebuild closes remote crashes and a TLS key leak; Lambda users mostly wait.

The 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.

The 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.

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, 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 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.

06 Worth a pilot. Medium risk.

AWS Emulator by AWS

Free, account-free AWS tests for agents and CI, with honest fidelity scores.

The 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.

The 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.

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 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 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.

07 Watching. Medium risk.

Cognito token exchange by AWS

Agents that act for a user with the user's rights, not their own, on a managed service.

The 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.

The 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.

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 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 Essentials, this is the cleanest way I've seen to let an MCP server 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.

Looked at, skipped

What else made noise this week, and why it didn't make the cut.

  • EC2 G7 GPU instances in more Regions by 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 by 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 by 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 by 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 by 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 by 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 by 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 by 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 by 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 by 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 by 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 by 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 by 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 by 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 by 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 by 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 by 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 by 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 by 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 by 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

Examples and code for the items above.

Claude Fable 5.2 on Bedrock (global profile)

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. Set the aws_review retention mode before the first call.

Gemini 4 Carbon: one call

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. Use a paid key, and budget at the December price.

Gemini Decisions API: one yes-or-no question

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. Act on a threshold you calibrated on your own labelled cases.

Cloudflare: a Workers spending cap from CI

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. Use "action":"notification" to alert without blocking.

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

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.

AWS Emulator: point the CLI and SDK at it

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.

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

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. Add actor_token and actor_token_type for delegation, so the new token carries an act claim.

A new edition every Monday. In your inbox on Tuesday.

One email a week. Confirm by email, unsubscribe in one click. Your address goes to Resend, our email provider, and nowhere else.

Or subscribe by RSS

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.

Want this stack in your AWS account?

Cloudless Labs is a Sydney consultancy. We migrate on-premises systems to AWS, build serverless apps on this stack, and coach teams to ship with Claude Code and Codex.

Talk to us

Contact Us

For general inquiries, please contact us at:

For e-learning capabilities, please contact: