GitHub's model assumes human developers: repositories, branches, commits, issues, pull requests. If the next wave of software is written by agents, that foundation starts to strain. Hundreds or thousands of agents working on one codebase at once raise questions the current tooling does not answer — how does an agent know what its peers are touching, what happens when their changes collide, how is their output reviewed, and how is the reasoning behind a change preserved alongside the diff?

Cloudflare's answer is to hand the problem to developers. Earlier this year the company launched Artifacts, a versioned filesystem that speaks Git and scales to millions of repositories, and designed it from the outset as a set of programmable primitives rather than a finished product. Artifacts now sits in open beta, and Cloudflare has opened a competition to build the next Git platform on top of it using Workers.

The foundation covers repositories that can be created and forked programmatically, versioned storage for code and agent context, and the Git operations agents already understand. Everything above that — coordination between agents, review and merge flows, and the developer experience at that scale — is the part Cloudflare wants entrants to design.

What's new in Artifacts

Since launch, developers have put Artifacts to work in several patterns: vibe-coding platforms storing the projects their users generate, agent sessions persisting code and context, and isolated repositories that let multiple agents start from the same point and compare or merge results later. The open beta adds a set of capabilities on top of that base.

Git-connected deployments

An Artifacts repository can now be connected to a Worker through Workers Builds. A push triggers a build, and pushes to the production branch deploy the updated Worker. Pushes to any other branch create or update Workers Previews, giving each change an isolated, shareable version of the Worker to test before it goes live. You can attach an existing Worker to a repository or start a new project that is stored in Artifacts automatically.

Programmable repos from inside Workers

The Artifacts binding lets a Worker create or fork repos, inspect files and commits, and issue repo-scoped Git tokens directly. That turns the Git workflow into code: when a task arrives, a Worker can fork the project for an agent, read the files it needs for context, hand it a repository to work in, and then inspect the result and kick off a review when the agent pushes.

A fork-and-read example shows the pattern — forking a project for a new agent task and pulling its AGENTS.md for instructions:

Events for every repository action

Artifacts emits events on repository creation, import, fork, deletion, push, clone, and fetch. Subscribers decide the follow-up: run CI, launch a code review agent, or deploy. A Worker subscribed to push events, for instance, can start a review workflow and pass the repository, branch, and new commit along so the review agent has the context to inspect the change.

using project = await env.ARTIFACTS.get("my-project");
const { defaultBranch } = await project.info();
const workspace = await project.fork(`task-${crypto.randomUUID()}`);

using repo = await env.ARTIFACTS.get(workspace.name);
const instructions = await repo.readFile({
  ref: defaultBranch,
  path: "AGENTS.md",
});

const agentTask = {
  remote: workspace.remote,
  token: workspace.token,
  instructions: instructions ? await instructions.text() : null,
};

Data residency and observability

Repository data can now be pinned to a jurisdiction. Setting a U.S. or EU jurisdiction on a namespace applies that restriction to every repository created within it.

export default {
  async queue(batch, env) {
    for (const message of batch.messages) {
      const event = message.body;
      if (event.type !== "cf.artifacts.repo.pushed") continue;

      await env.REVIEW_WORKFLOW.create({
        params: {
          namespace: event.source.namespace,
          repo: event.source.repoName,
          ref: event.payload.ref,
          commit: event.payload.after,
        },
      });
    }
  },
};

The dashboard also exposes per-repository metrics: total operations, pulls, pushes, errors, and error rate. The same Artifacts metrics can be queried directly for custom dashboards and monitoring.

curl "https://api.cloudflare.com/client/v4/accounts/$ACCOUNT_ID/artifacts/namespaces" \
  -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" \
  --json '{"namespace":"my-eu-namespace","jurisdiction":"eu"}'

Pricing

Artifacts is priced on repository operations and stored data. Billing begins October 15, 2026.

The competition

Entrants are asked to build their vision of a Git platform for the agentic era on Workers and Artifacts. The scope is open — repositories, branches, pull requests, worktrees, code review, merge conflicts, agent context preservation, or new ways to compare several concurrent changes and choose which ships.

Cloudflare is explicit that a GitHub clone with agents bolted on will not qualify. At minimum, a submission must demonstrate multiple agents working on changes concurrently. Beyond that, the brief is to show what you think comes next.

Submission requirements

  • A 5-10 minute video covering what you built, what it enables agents and developers to do, and how it works
  • A link to the source code under a permissive open source license (MIT, Apache, BSD)
  • Instructions for running or trying the project

Submissions are open until October 14, 2026.

Prizes

The top three projects are selected, with up to two members from each team flown to San Francisco for Cloudflare Connect to present their work. The first-place team receives $25,000 in Cloudflare credits and invitations to the VIP speaker dinner on Monday night at Connect.

Getting started

Artifacts is available in open beta to customers on the Workers Paid plan. Copy the prompt below to set up a first repository and push code to it with your coding agent.

Repositories can be viewed or created in the dashboard, and the documentation covers the rest.