Skip to content

Changelog

New updates and improvements at Cloudflare.

Artifacts now supports local development

You can now develop and test Artifacts locally. Create repos, import Git repositories over HTTPS, issue repo tokens, and clone or push with Git on your machine before deploying to Cloudflare's global network. Local repos are separate from your deployed repos, so you can test changes without affecting production data.

Local repos also emit the same Artifacts events as production when a repo is created, imported, forked, or deleted, or when a repo token is created or revoked. This lets you test the Workflows that react to them before you deploy.

To use local repos when you run your Worker locally, add an Artifacts binding to your Wrangler configuration file:

{
  "$schema": "./node_modules/wrangler/config-schema.json",
  "name": "artifacts-worker",
  "main": "src/index.ts",
  // Set this to today's date
  "compatibility_date": "2026-11-17",
  "artifacts": [
    {
      "binding": "ARTIFACTS",
      "namespace": "default"
    }
  ]
}
name = "artifacts-worker"
main = "src/index.ts"
# Set this to today's date
compatibility_date = "2026-11-17"

[[artifacts]]
binding = "ARTIFACTS"
namespace = "default"

Run npx wrangler dev, then use the binding the same way you would in production:

const created = await env.ARTIFACTS.create("starter-repo");

return Response.json({
	remote: created.remote,
	token: created.token,
});
const created = await env.ARTIFACTS.create("starter-repo");

return Response.json({
	remote: created.remote,
	token: created.token,
});

The returned remote points to your local dev session, so you can use it with a standard Git client to clone and push.

Local development requires the latest version of Wrangler and Git 2.32 or later on your PATH.

When you develop with npx wrangler dev, the Cloudflare Vite plugin, or the Workers Vitest integration, Artifacts bindings use the local simulator by default. To use your deployed repos instead, set remote = true on the binding.

To learn more, refer to Local development.

Browser Run Quick Actions now work in local development

You can now test Browser Run Quick Actions locally. Under npx wrangler dev, the browser binding's .quickAction() method runs against a Chrome instance on your machine. Before, .quickAction() worked only in remote mode, and local calls failed with The RPC receiver does not implement the method "quickAction".

For details, refer to Test Quick Actions locally.

Manage AI Search instances in any namespace with Terraform

Starting with Cloudflare Terraform provider ↗︎ v5.29.0, you can manage AI Search instances in any namespace, not only default.

The cloudflare_ai_search_instance resource has a new namespace argument. It defaults to default, so existing configurations keep managing the same instances.

resource "cloudflare_ai_search_namespace" "support" {
  account_id = var.account_id
  name       = "support"
}

resource "cloudflare_ai_search_instance" "docs" {
  account_id = var.account_id
  id         = "docs"
  namespace  = cloudflare_ai_search_namespace.support.name
}

You can import existing instances and namespaces:

terraform import cloudflare_ai_search_instance.docs <account_id>/support/docs
terraform import cloudflare_ai_search_namespace.support <account_id>/support

The data sources read instances from the namespace you set:

data "cloudflare_ai_search_instance" "docs" {
  account_id = var.account_id
  namespace  = "support"
  id         = "docs"
}

data "cloudflare_ai_search_instances" "support" {
  account_id = var.account_id
  namespace  = "support"
}

When you upgrade to v5.29.0, review these changes:

  • The cloudflare_ai_search_instance import ID now includes the namespace: <account_id>/<namespace>/<id>. For instances in the default namespace, use <account_id>/default/<id>.
  • The cloudflare_ai_search_instance and cloudflare_ai_search_instances data sources require namespace. Set namespace = "default" for instances in the default namespace.
  • cloudflare_ai_search_instances returns the instances in one namespace. The filter.namespace argument of cloudflare_ai_search_instance is removed.
  • Changing namespace replaces the instance.

Set spending limits for Workers and Durable Objects

You can now set spending limits for Workers and Durable Objects to help control unexpected usage costs, or receive email alerts while your applications keep running. Support for more products is coming soon.

Use these controls alongside AI Gateway spend limits to manage compute and AI inference costs across your application. AI Gateway supports per-user and per-model budgets for Workers AI and other AI providers, applied to requests routed through your gateway.

Workers and Durable Objects limits apply across your account for the current subscription billing period. Each product has its own spending controls.

Set your limits and alerts

In the Cloudflare dashboard ↗︎, select your account and go to Billing > Spend limits. Choose a spending limit, notification email, and alert thresholds for Workers or Durable Objects.

For example, configure a $10 Workers spending limit with email alerts at $5 and $9. To receive alerts while your applications keep running, turn off Block usage.

Workers controls with usage blocking at $10, a notification email, and alert thresholds at $5 and $9.

See when a limit takes effect

The overview shows each product's recorded spend, alert thresholds, and pause status. Email alerts notify you without stopping usage. When a spending limit takes effect, Cloudflare blocks the product's supported operations.

Spend limits overview with Workers marked Services paused and separate spend and threshold indicators for Durable Objects.

To resume usage, raise the limit above current spend, turn it off, or remove it. Usage also resumes when the next billing period starts.

Usage reporting and blocking take time, so recorded spend can exceed a limit. Read about what counts toward a limit.

Choose alerts, limits, or both

For example, set a $50 spending limit for Workers and a $20 email alert for Durable Objects:

flowchart LR
    A["Durable Objects reaches $20"] --> B["Email alert sent"]
    B --> C["Usage continues"]
    D["Workers reaches $50"] --> E["Spending limit takes effect"]
    E --> F["New Worker invocations blocked"]

Set a spending limit with the cf CLI

Install the cf CLI and select your account, then run this command to set a $50 spending limit for Workers usage in the current billing period:

cf billing spend-policies create \
  --name 'Workers $50 spending limit' \
  --product-id workers \
  --enabled true \
  --threshold-cents 5000 \
  --action usage_block

The amount is in US cents: 5000 means $50. To set a spending limit for Durable Objects, use --product-id durable_objects and update the name. Limits count usage already recorded in the current billing period.

You can also give this prompt to your coding agent. It will ask which product you want to manage and what spending limit to set, then use the CLI to configure it.

Use spending limits alongside budget alerts

The budget alerts introduced earlier this year notify you about account-wide usage costs without stopping usage. You can keep using them alongside the new product-specific spending limits and email alerts for Workers and Durable Objects.

To configure account-wide alerts, go to Billing > Billable Usage or follow the budget alerts guide.

Read the spending limits and alerts guide to learn how spending limits work and manage limits and alerts through the dashboard or cf CLI.

AI Search supports D1 databases as a data source (beta)

AI Search can now use a D1 database as a data source. AI Search runs a read-only query that you provide and indexes each returned row as a separate document. Scheduled syncs keep the index current as rows are added, changed, or removed.

Create D1-backed instances from the dashboard, the REST API, or the Workers binding.

Selecting a D1 database as the data source when creating an AI Search instance in the dashboard
curl -X POST "https://api.cloudflare.com/client/v4/accounts/<ACCOUNT_ID>/ai-search/namespaces/default/instances" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  --data '{
    "id": "help-center",
    "type": "d1",
    "source": "<D1_DATABASE_ID>",
    "token_id": "<SERVICE_TOKEN_ID>",
    "source_params": {
      "d1": {
        "query": "SELECT article_id AS id, title, content, category AS meta_category\nFROM articles\nWHERE published = 1"
      }
    }
  }'

Learn more in D1 data source.

Kitesurf is now open source

Kitesurf ↗︎, Cloudflare's browser engine for AI agents, is now open source on GitHub ↗︎ under the Apache 2.0 license. You can inspect the source, run it locally, and deploy your own instance to your Cloudflare account.

Kitesurf runs entirely on Cloudflare Workers. It parses HTML, applies CSS, executes page JavaScript, and renders screenshots without a browser container. It supports the Chrome DevTools Protocol (CDP), so you can connect clients such as Puppeteer.

Kitesurf is still experimental and under heavy development. The team continues to improve web standards support, rendering fidelity, and performance.

Run locally or deploy to your account

Developers can run Kitesurf locally with Wrangler. After following the build requirements and setup instructions ↗︎, run pnpm run dev. This builds the engine and starts wrangler dev.

To run your own instance on Cloudflare, follow the deployment instructions ↗︎. Protect your deployment with Cloudflare Access or another authentication layer. Kitesurf does not provide built-in authentication.

Contribute and follow progress

Contributions and pull requests are welcome. The team remains focused on compatibility, reliability, and performance, with limited review capacity. Keep changes focused and follow the contribution guidelines ↗︎, including opening an issue and getting vouched by a maintainer before submitting a pull request.

Visit kitesurf.dev ↗︎, the main Kitesurf website and playground. Track Web Platform Tests (WPT) progress ↗︎ and performance benchmarks ↗︎ as development continues.

For background and technical details, refer to the introductory blog post ↗︎ and the Kitesurf update ↗︎. To use Kitesurf through Browser Run, refer to the Kitesurf documentation.

Export D1 databases with virtual tables

You can now export a D1 database that contains virtual tables, such as full-text search tables using SQLite's FTS5 module ↗︎ or spatial index tables using the R*Tree module. Previously, export failed for any database containing virtual tables.

To include virtual tables in the dump, set dump_options.compatibility to sqlite3_cli_only on the D1 export API. The same option is available as the --compatibility flag on wrangler d1 export.

curl "https://api.cloudflare.com/client/v4/accounts/$ACCOUNT_ID/d1/database/$DATABASE_ID/export" \
	--request POST \
	--header "Authorization: Bearer $CLOUDFLARE_API_TOKEN" \
	--json '{
		"output_format": "polling",
		"dump_options": {
			"compatibility": "sqlite3_cli_only"
		}
	}'

For more information, refer to Export a D1 database with virtual tables.

Set custom validity windows for RealtimeKit auth tokens

RealtimeKit auth tokens now support custom validity windows, and you can revoke a single token. When your backend adds a participant to a meeting, it gets back an auth token that the participant's app uses to join.

Previously, every token was valid for 100 days from the moment it was issued. Now you can choose when a token starts and stops working, for example only during a scheduled class or interview, so a shared link stops working once the session is over. Pass not_before and expires_on in the token object when you add a participant:

Required API token permissions

At least one of the following token permissions is required:
  • Realtime Admin
  • Realtime
Add a participantbash
curl "https://api.cloudflare.com/client/v4/accounts/$ACCOUNT_ID/realtime/kit/$APP_ID/meetings/$MEETING_ID/participants" \
	--request POST \
	--header "Authorization: Bearer $CLOUDFLARE_API_TOKEN" \
	--json '{
		"name": "Mary Sue",
		"preset_name": "<preset_name>",
		"custom_participant_id": "<uuid_of_the_user_in_your_system>",
		"token": {
				"not_before": "2026-12-01T15:00:00Z",
				"expires_on": "2026-12-01T17:00:00Z"
		}
	}'

Both fields are optional, so existing integrations keep getting 100-day tokens.

You can also revoke a single token without setting the whole meeting to INACTIVE. If the participant is in the meeting, RealtimeKit removes them. A revoked token can take up to 60 seconds to stop working everywhere, so delete the participant instead if you need to block them immediately.

RealtimeKit rejects expired, not yet valid, and revoked tokens before the participant enters the meeting, so you are not billed for them.

Learn more

Add noise cancellation to web apps built on RealtimeKit

You can now add noise cancellation to RealtimeKit web apps with the new @cloudflare/realtimekit-noise-cancellation package. RealtimeKit is a high-level SDK for adding real-time audio and video components, such as video meetings, to your web or mobile app.

Install the package:

npm i @cloudflare/realtimekit-noise-cancellation

After you initialize the meeting, pass it to init():

import { RealtimeKitNoiseCancellation } from "@cloudflare/realtimekit-noise-cancellation";

// Enables automatically when the mic is available, without delaying join.
void RealtimeKitNoiseCancellation.init({ meeting }).catch(console.warn);

How it works

  • Filters background noise in the participant's browser, before their audio is sent to the meeting.
  • Turns on automatically after init(), as soon as the participant's microphone is on.
  • Keeps running through mute, unmute, and reconnects, and cleans up when the participant leaves.
  • Never unmutes the microphone.

Noise cancellation works in React, Angular, and JavaScript apps on Chrome, Edge, Firefox, and Safari, including mobile browsers. The RealtimeKit iOS and Android SDKs do not yet support it.

Learn more

Cloudflare Tunnel extends URL normalization

Starting from version 2026.11.0, Cloudflare Tunnel extends the URL normalization introduced in 2026.10.0. Normalization now handles semicolon-delimited path parameters before matching ingress rules. This improves security for tunnels with rules that require Cloudflare Access validation. The URL path sent to your origin stays the same.

Starting 2027-02-08, new cloudflared releases will turn on URL normalization by default. This replaces the previously announced date of 2027-01-25, giving you time to test the updated behavior. Upgrade to version 2026.11.0 or later and test your path-based routing before that date, including rules that match paths containing semicolons. Configurations without rules requiring Access validation are unaffected.

This setting is currently off by default. To turn it on, run:

cloudflared tunnel --disable-path-normalization=false run <TUNNEL_NAME_OR_UUID>

Alternatively, set TUNNEL_DISABLE_PATH_NORMALIZATION=false on each cloudflared replica and restart it.

For more information, refer to ingress matching and Access validation at the origin.

EmbeddingGemma 2 now available on Workers AI

@cf/google/embeddinggemma-2 is now available on Workers AI. EmbeddingGemma 2 is an open multimodal embedding model from Google DeepMind. It maps text (including code), images, video, and audio into a single 768-dimensional vector space, so you can search a mixed collection of products, documents, and media with one text query.

Key capabilities:

  • Multimodal: Embed text, images, video, audio, or any combination of them in one input. Every embedding shares the same vector space.
  • Multilingual and code: Understands more than 100 languages and improves code retrieval over the original EmbeddingGemma.
  • Flexible dimensions: Set dimensions to 128, 256, or 512 to return shorter vectors and reduce storage, with a small cost to quality.
  • Long context: An 8,192 token context window, shared across all content in an input.
  • Task prefixes: Add short instructions such as task: search result | query: ... to tune embeddings for search, classification, clustering, or similarity.

Send text with input. Send images, video, and audio as base64 data URIs in messages:

const response = await env.AI.run("@cf/google/embeddinggemma-2", {
	messages: [
		[
			{
				role: "user",
				content: [
					{ type: "text", text: "Waterproof running shoes." },
					{ type: "image_url", image_url: { url: imageDataUri } },
				],
			},
		],
		[
			{
				role: "user",
				content:
					"task: search result | query: waterproof shoes for trail running",
			},
		],
	],
});
const response = await env.AI.run("@cf/google/embeddinggemma-2", {
	messages: [
		[
			{
				role: "user",
				content: [
					{ type: "text", text: "Waterproof running shoes." },
					{ type: "image_url", image_url: { url: imageDataUri } },
				],
			},
		],
		[
			{
				role: "user",
				content:
					"task: search result | query: waterproof shoes for trail running",
			},
		],
	],
});

Pricing is $0.0017 per million input tokens.

For more information, refer to the EmbeddingGemma 2 model page and pricing.

Inkling 2 Small now available on Workers AI

@cf/thinkingmachines/inkling-2-small is now available on Workers AI. Inkling 2 Small is the second generation of Inkling models from Thinking Machines Lab, and the first frontier open model from a US lab on Workers AI.

Inkling 2 Small is more capable than the previous generation. It is a multimodal Mixture-of-Experts model with 594B total parameters and 18B active parameters. Thinking Machines trained it much faster than previous models because of improvements to their pre-training and infrastructure.

Inkling 2 Small works well for:

  • Agentic coding: Plan, write, and edit code across multi-step tasks.
  • Vision understanding: Interpret images sent alongside text in the same request.
  • General agentic knowledge work: Research, analyze, and act on information with tools.

Key capabilities:

  • Vision: Accepts text and image inputs.
  • Reasoning: Reasoning is on by default at high effort. Set reasoning_effort to max, medium, low, or minimal to change the effort, or to none to turn reasoning off.
  • Function calling: Build agents that invoke tools and APIs across multiple conversation turns.
  • Long context: A full 1,048,576 token context window.

Inkling 2 Small requires the Workers Paid plan or prepaid AI Gateway credits. The default rate limit is 20 requests per minute with standard Workers AI billing and 50 requests per minute with prepaid AI Gateway credits. For details, refer to limits.

Use Inkling 2 Small through the Workers AI binding (env.AI.run()), the REST API, the OpenAI-compatible endpoint, or AI Gateway.

For more information, refer to the Inkling 2 Small model page and pricing.

Improved Request Routing to Durable Objects

Cloudflare has reduced the number of round trips needed to connect to a Durable Object when a location lookup follows a forwarding record to another data center.

When an object's destination isn't cached in Cloudflare's network, the first data center contacted may have a forwarding record pointing to another data center.

Previously, the first data center acquired a connection to the object at the destination and proxied it back to the caller. The caller then established its own direct connection to the object.

Now, the first data center returns the destination directly, without first acquiring a connection to the object. The caller then establishes a direct connection, avoiding the intermediate connection and duplicate acquisition.

Skipping this intermediate connection can reduce p99 connection latency for these relocation-related requests. Actual results depend on your workload and traffic patterns.

No code or configuration changes are required to benefit from this improvement.

To learn more about how Workers connect to Durable Objects, refer to Durable Object namespaces.

Hyperdrive raises limits for connections and configurations

Customers on a Workers Paid plan can now create up to 100 Hyperdrive configurations, up from 25, and configure up to 1,500 origin database connections per configuration, up from 100.

Configuration limit

The configuration limit is the maximum number of Hyperdrive configurations you can create per account. Workers Paid customers can now create up to 100 configurations, allowing more workloads to take advantage of connection pooling and query caching across different databases.

Origin connection limit

The origin connection limit is the maximum number of database connections that Hyperdrive can make to your origin database per configuration. Workers Paid customers can now configure up to 1,500 origin connections, increasing the connection pool size available for workloads that need more concurrent database access. You can configure this value via the dashboard, Wrangler, or the REST API.

We recommend setting the origin connection limit lower than your origin database's connection limit.

For more information, refer to Hyperdrive limits and Tune connection pooling.

Add a collaborative whiteboard to meetings built on RealtimeKit

You can now add a collaborative whiteboard to RealtimeKit meetings with the Whiteboard plugin, which Cloudflare hosts and runs for you. RealtimeKit provides SDKs for running live audio and video meetings in your app. Many companies use it today to run online education and interview platforms, where participants often need a shared whiteboard to work through ideas together.

You add the Whiteboard plugin with the same plugins API you use for your own plugins. Load it in an iframe, with the participant's auth token after # in the URL:

const WHITEBOARD_URL = "https://whiteboard-v2.plugins.realtime.cloudflare.com/";

function createWhiteboard(authToken: string): HTMLIFrameElement {
	const iframe = document.createElement("iframe");
	iframe.style.width = "100%";
	iframe.style.height = "100%";
	iframe.style.border = "none";
	// Lets participants copy and paste on the board.
	iframe.allow = "clipboard-read; clipboard-write";
	// The plugin does not need your page's address.
	iframe.referrerPolicy = "no-referrer";
	iframe.src = `${WHITEBOARD_URL}#authToken=${encodeURIComponent(authToken)}`;
	return iframe;
}

const whiteboardElement = createWhiteboard("<auth_token>");

Then pass whiteboardElement as the plugin's component when you initialize the SDK. The Whiteboard plugin guide has the registration code for web, Android, iOS, and React Native.

You can also build your own plugins and render them alongside the meeting UI. A whiteboard you build yourself needs a server that sends every stroke to every participant, saves the board between sessions, and checks who can open it. With the Whiteboard plugin, Cloudflare runs all of that for you.

How it works

  • Participants draw shapes, arrows, freehand strokes, and text on one shared board, and see each other's cursors and names.
  • Each meeting has one board. It stays the same across sessions, so participants pick up where they left off.
  • The plugin checks each participant's auth token, so only participants in the meeting can open its board.
  • It works on any domain, and you do not need to register your app's origin.

Learn more

Send custom API headers with Wrangler and Cloudflare CLI

Wrangler 4.160.0 and Cloudflare CLI (cf) 1.0.0-beta.29 support custom headers for Cloudflare API requests. Use CLOUDFLARE_API_HEADERS to add headers or override most generated values, with the exception of protected body and transport headers.

For example, to send X-Custom-Header: value, set:

export CLOUDFLARE_API_HEADERS='{"X-Custom-Header":"value"}'

Then run your Wrangler or cf command.

For usage and restrictions, refer to the Wrangler environment variable reference and Cloudflare CLI environment variable reference.

Serve a Worker's static assets from a URL path like /blog/

You can now serve your Worker's static assets from a URL path prefix, such as example.com/blog/, without changing your build output.

Previously, to serve assets from /blog/, you had to nest your files in a matching blog directory. Now, set assets.base_path in your Wrangler configuration file, or worker.assets.basePath in cloudflare.config.ts, and keep your files at the root of your asset directory.

Use Wrangler 4.148.0 ↗︎ or later. With cloudflare.config.ts, use cf 1.0.0-beta.13 ↗︎ or later.

For example, this configuration serves your built assets from /blog/:

cloudflare.config.tsts
import { defineConfig } from "cf/config";

export default defineConfig({
worker: {
  name: "blog",
  // Set this to today's date
  compatibilityDate: "2026-11-17",
  assets: {
    basePath: "/blog",
  },
},
});
{
  "$schema": "./node_modules/wrangler/config-schema.json",
  "assets": {
    "directory": "./dist",
    "base_path": "/blog"
  }
}
[assets]
directory = "./dist"
base_path = "/blog"

Requests to /blog/ serve dist/index.html, and requests to /blog/posts/post1 serve dist/posts/post1.html. Requests outside /blog/ do not match your static assets and run your Worker, if it has one.

Paths in _headers, _redirects, and run_worker_first use the full public path, including /blog. If you build with the Cloudflare Vite plugin, also set Vite's base option to /blog/.

For more information, refer to Serving a subdirectory.

Evaluate Flagship feature flags from Rust

Flagship now has an official Rust SDK. Use it to evaluate feature flags from async Rust server applications through OpenFeature, with the same targeting rules and percentage rollouts as the other Flagship SDKs.

Install the cloudflare-flagship ↗︎ crate:

cargo add cloudflare-flagship

Then register the provider and evaluate a flag:

let options = FlagshipClientOptions::builder()
    .app_id("<APP_ID>")
    .account_id("<ACCOUNT_ID>")
    .auth_token("<API_TOKEN>")
    .build()?;

let mut api = OpenFeature::default();
api.set_provider(FlagshipServerProvider::new(options)?).await;

let context = EvaluationContext::default().with_targeting_key("user-42");
let enabled = api
    .create_client()
    .get_bool_value("new-checkout", Some(&context), None)
    .await
    .unwrap_or(false);

The provider evaluates flags over HTTP by default. Turn on local evaluation to download flag definitions and evaluate flags in-process, without a network request per evaluation. The SDK also supports structured evaluation context, an optional response cache, and logging and telemetry hooks.

The SDK requires Rust 1.88 or later and a Tokio runtime. For setup and configuration options, refer to the Rust SDK documentation.

Faster MP4 downloads from Cloudflare Stream

Generating MP4 downloads from Cloudflare Stream is now up to 40% faster, with no changes to your implementation required. This improvement is most impactful for on-demand videos over 1 minute in duration.

You can generate an MP4 download in the Dashboard, with the cf, the Cloudflare CLI CLI, or by sending a POST request.

cf clish
cf stream videos downloads create default --identifier "$VIDEO_UID"
Create downloadbash
curl "https://api.cloudflare.com/client/v4/accounts/$ACCOUNT_ID/stream/$IDENTIFIER/downloads/default" \
	--request POST \
	--header "Authorization: Bearer $CLOUDFLARE_API_TOKEN"

Both of these response include the download URL and processing progress:

{
	"result": {
		"default": {
			"status": "inprogress",
			"percentComplete": 75.0,
			"url": "https://customer-<CODE>.cloudflarestream.com/<VIDEO_UID>/downloads/default.mp4"
		}
	},
	"success": true,
	"errors": [],
	"messages": []
}

For more information, refer to Generate downloadable MP4 files.

Workers Builds and Pages now list GitHub repositories based on your GitHub account

When you connect a GitHub repository to Workers Builds or Pages, the accounts and repositories you can pick from are now based on your own GitHub account, so the list reflects the repositories you work with on GitHub. Previously, the list was based on the Cloudflare Workers & Pages GitHub App installations linked to your Cloudflare account, so it could include repositories that you cannot access on GitHub.

Three developers on the same Cloudflare account have all authorized the app, and the app is installed on acme-corp and dev-1. Each sees a different repository picker. dev-1 can pick acme-corp or dev-1, with payments-api and website listed for acme-corp. dev-2 can only pick acme-corp, with only website listed. dev-3 has no accounts or repositories, only the option to add a GitHub account.

The list now shows:

  • Your own GitHub account, if the app is installed on it.
  • GitHub organizations that have the app installed, where you can access at least one repository.
  • The repositories you can access in each of them.

GitHub accounts that belong to other users are no longer listed, even if they have given you access to one of their repositories.

What this means for you:

Authorizing the app and installing it are two separate steps on GitHub. For more details, refer to Install and authorize the app for Workers Builds and Pages.

Authorize: tells Cloudflare who you are, once per person, listed under Authorized GitHub Apps. Install: decides which repositories Cloudflare can access, listed under Installed GitHub Apps.
  • If you have already authorized the app with your GitHub user: Nothing changes. You can check on the Authorized GitHub Apps page ↗︎ on GitHub.
  • If you have not: The next time you connect a repository, Cloudflare sends you to GitHub to authorize the app. You only need to do this once, even if someone else on your Cloudflare account already connected GitHub.
  • If the app is not installed on any GitHub account you can access: After you authorize, install the app on your own GitHub account or an organization, the same as before.
  • If an account or organization is missing from the list: Select Add GitHub account and install the app on it.

Projects that are already connected to a repository are not affected and keep building.

For more information, refer to Repository access for Workers Builds and Pages.

Set a concurrency limit for each Workflow

You can now set a concurrency limit on an individual Workflow to cap how many of its instances run at the same time. Use it to protect a database or third-party API that slows down or rejects requests past a certain number of concurrent connections, or to distribute load more evenly across your Workflows so that one high-volume Workflow does not use all of your account's concurrency.

For example, to allow only 10 instances of a Workflow to run at a time, set concurrency.limit on its workflows binding and redeploy:

{
	"workflows": [
		{
			"name": "my-workflow",
			"binding": "MY_WORKFLOW",
			"class_name": "MyWorkflow",
			"concurrency": {
				"limit": 10,
			},
		},
	],
}
[[workflows]]
name = "my-workflow"
binding = "MY_WORKFLOW"
class_name = "MyWorkflow"

  [workflows.concurrency]
  limit = 10

You can also set concurrency on a Workflow declared in exports, or with exports.workflow() in @cloudflare/config.

Instances above the limit are not rejected. They are queued and start automatically as running instances finish or move to the waiting state.

The limit must be a positive integer, and cannot be higher than your account's concurrency limit (100 on Workers Free, 50,000 on Workers Paid). Lowering the limit does not stop instances that are already running. Workflows without a concurrency limit can still use up to your account's full concurrency limit.

Per-Workflow concurrency limits require Wrangler 4.127.0 or above.

For more information, refer to Concurrency limits.

Run the Codex agent loop on Cloudflare Workers

Run the Codex agent loop in a Cloudflare Durable Object with this experimental Agents SDK example ↗︎. Conversations, files, and completed model and tool results persist across restarts, allowing the agent to recover after interruptions.

The example adapts Codex’s Rust turn-processing code ↗︎ to WebAssembly and uses Agents SDK capabilities for storage and recovery.

The harness combines Agents SDK capabilities for durable execution:

  • Tasks journals model calls and tool execution. Completed steps reuse their recorded results after a restart. Interrupted steps can run again.
  • Sessions stores conversation history and compacts the model context.
  • Streams stores ordered events for replay after reconnecting.
  • Workspace provides tools to read and write persistent files.

For example, use OpenAI's GPT-6.1 Sol through AI Gateway. Configure the model with createAI and install the capabilities on a Durable Object:

import { DurableObject } from "cloudflare:workers";
import { Workspace } from "@cloudflare/computer";
import { Lifecycle } from "agents/lifecycle";
import { createAI } from "agents/models/ai-sdk";
import { Sessions } from "agents/sessions";
import { Streams } from "agents/streams";
import { Tasks } from "agents/tasks";
import { CodexHarness } from "./codex-harness";

export class Coder extends DurableObject {
	tasks = new Tasks();
	streams = new Streams();
	sessions = new Sessions();
	workspace = new Workspace({ storage: this.ctx.storage });

	codex = new CodexHarness({
		tasks: this.tasks,
		streams: this.streams,
		sessions: this.sessions,
		workspace: this.workspace,
		model: createAI({ binding: this.env.AI, id: "default" })(
			"openai/gpt-6.1-sol",
		),
	});

	lifecycle = Lifecycle.install(this)
		.use(this.tasks)
		.use(this.streams)
		.use(this.sessions)
		.use(this.codex);
}
import { DurableObject } from "cloudflare:workers";
import { Workspace } from "@cloudflare/computer";
import { Lifecycle } from "agents/lifecycle";
import { createAI } from "agents/models/ai-sdk";
import { Sessions } from "agents/sessions";
import { Streams } from "agents/streams";
import { Tasks } from "agents/tasks";
import { CodexHarness } from "./codex-harness";

export class Coder extends DurableObject<Env> {
	tasks = new Tasks();
	streams = new Streams();
	sessions = new Sessions();
	workspace = new Workspace({ storage: this.ctx.storage });

	codex = new CodexHarness({
		tasks: this.tasks,
		streams: this.streams,
		sessions: this.sessions,
		workspace: this.workspace,
		model: createAI({ binding: this.env.AI, id: "default" })("openai/gpt-6.1-sol"),
	});

	lifecycle = Lifecycle.install(this)
		.use(this.tasks)
		.use(this.streams)
		.use(this.sessions)
		.use(this.codex);
}

To use this model, configure the default gateway with Unified Billing or a stored OpenAI API key.

For setup, models, tools, and recovery behavior, refer to the Codex harness guide.

Run Exo agents on Cloudflare

You can now run Exo agents on Cloudflare, with Durable Objects coordinating conversations and Cloudflare Sandboxes running Linux tools. Define an agent in Markdown, then use Exo's CLI or HTTP API to run it.

After deploying the Cloudflare adapter and configuring your Exo provider ↗︎, add an openai vault credential and save this definition as agent.md:

---
harness: basic
model:
  name: gpt-6.1-sol
  credential: openai
---

Help the user with their task.

Run the agent against your Cloudflare deployment with Exo's CLI:

exo --provider cloudflare agent run --agent-file agent.md

The Exo project maintains the Cloudflare adapter independently of Cloudflare. It does not require the Agents SDK.

Follow the Exo guide for architecture, recovery behavior, and upstream setup instructions.

Run the Nanocode agent harness in Cloudflare Durable Objects

You can now run Nanocode ↗︎ coding agents in Cloudflare Durable Objects, with persistent session history and recovery after interruptions.

Nanocode's Rust engine runs as WebAssembly and implements Codex and Claude Code prompt and tool conventions. Its Cloudflare host saves turn progress and tool results in SQLite and uses alarms to resume pending work. The Nanocode project maintains the host independently of Cloudflare; it does not require the Agents SDK.

Start with the reference Worker ↗︎ and follow Nanocode on Workers for setup, models, and recovery limits.

Improved Durable Object Startup Placement

Cloudflare has improved how it chooses where to start a Durable Object after the object has been inactive.

Reactivated Durable Objects now start on the machine that last ran them whenever possible, so their data doesn't need to be loaded again.

This can make cold starts less frequent for SQLite-backed Durable Objects that are reactivated soon after going idle. Actual results depend on your workload and traffic patterns.

The change is live in all regions. No action is needed by customers to see benefits from this change.

To learn more about how Durable Objects are placed, refer to Data location.