Cloudflare OS：一个面向智能体、应用与工作的开放平台
每个组织都有一项使命，一个存在的理由。组织会将这项使命——连同其术语、流程、系统、标准和工作方式——传递给自己的员工。而员工则将这些背景信息与自身的经验结合起来，朝着使命努力。
工作的形式多种多样，从代码，到文档和幻灯片，到人际关系，再到物理世界中的成果。
其中有些是直截了当的：代码要么能运行，要么不能。过去几年里，智能体一直在利用这一反馈循环，为开发者产出“能用”的代码。但我们其他人呢？
将同样的杠杆效应带给组织中的其他部分，是一个更难的难题。智能体需要理解公司的背景，并且能够触达人们完成工作所使用的系统。它们需要将这种背景信息和访问权限转化为推动组织朝着使命前进的工作。
这就是我们创建 Cloudflare OS 的原因。它为每个人提供一个围绕其公司构建的智能体和工作空间：公司如何运作、它知道什么，以及它所依赖的系统。
今年 5 月，我们让 Cloudflare 的每个人都用上了第一版 Cloudflare OS。各个职能部门的数千人——其中许多人并非工程背景——每天都在使用它来创建文档和幻灯片、自动化重复性任务，以及构建小型应用来可视化数据并帮助他们完成工作。
Cloudflare OS 还为每个人提供了一个由 Cloudflare 各团队构建的共享上下文与技能库。它把我们的术语、流程以及处理重复性工作的最佳已知方法，固化为智能体可以遵循的指令。当某个人找到更好的做事方式时，其他人也都能使用。
今天，我们开源了 Cloudflare OS 的新版本。任何组织都可以部署它，将其连接到内部系统，并把它改造成自己的版本。
我们从第一版中学到了什么
我们今天开源的 Cloudflare OS，基于我们在内部运行第一版时所学到的东西，我们的 CIO Sam Rhea 在他的博客文章中讲述了这段历程。
第一版的核心是个人通过私有工作区与智能体协作。应用是静态的，而不是连接到内部系统的实时软件，而且大多数确定性任务仍然需要再次运行智能体技能，并消耗更多模型 token。
协作暴露了一个更根本的挑战。对 MCP server 的访问权限能告诉我们智能体可以调用哪些工具，却不能告诉我们该智能体观察到了哪些底层资源。一旦人们开始共享工作区、应用和输出，我们就需要确保协作不会暴露某人无权查看的信息。
我们在一套全新的基础上重建了 Cloudflare OS，以解决这些问题。安全必须成为平台的一部分，而不是每个构建应用或使用智能体的人都必须正确实现的东西。
最终成果是一个旨在归属于运行它的公司的平台。你可以自定义界面、连接你的工具，并添加能够体现你组织运作方式的技能和上下文。
隆重推出 Cloudflare OS
Cloudflare OS 从你在浏览器中的一次对话开始，就像许多其他 AI 工具一样。它的不同之处在于，每一次对话都扎根于你的组织所精心整理的上下文和技能。给你的工作空间一个目标，它就能借助这些知识，并与你的组织已经在使用的工具和数据协同工作来实现它。
Cloudflare OS 结合了三个部分：
- 一个智能体工作空间，扎根于你的公司所精心整理的上下文和技能，并配备一个隔离的运行时，智能体可以在其中编写和运行代码。
- 一个全新的安全与治理框架，用于安全地访问内部数据和服务。
- 一个用于个人化、可修改应用的平台，人们可以构建、分享并持续修改这些应用。
起初只是一次对话，最终可以变成一个文档、一个应用，或一个持续完成工作的工作流。
为贵公司每位成员打造的智能体工作空间
智能体工作空间的设计初衷，就是让组织中的每个人都能使用。你在浏览器中与它们交互，因此无需是开发者，也不必懂得如何使用终端。
一个工作空间将智能体会话、持久状态、输出与文件、资源访问，以及一个可供智能体编写和运行代码的隔离运行时整合在一起。
它们预装了你的团队或公司所积累的精选上下文与技能。无需再为每项任务重复造轮子——如果团队中有人已经摸索出做某件事的最佳方式，所有人都能受益。人们不再需要在每次开始任务时，向模型反复解释相同的流程、术语和最佳实践。
你可以做的几件事：
调研与提问
让工作空间利用公司上下文和你提供给它的资源来调研某个主题。智能体可以编写代码来搜索、筛选、连接和分析信息，而不是把整个数据集塞进模型的上下文窗口。
创建文档、幻灯片和电子表格
工作空间可以将其研究成果转化为文档、演示文稿或电子表格，供你继续编辑。这些产出不必是静态文件。它们可以保持与实时数据的连接，随着数据源的变化而更新，并且仍可导出为 Google Drive 等熟悉的格式或服务。
为你的团队创建可协作、互联的应用
当文档或电子表格不够用时，智能体可以构建一个拥有自身界面、逻辑和状态的应用。该应用可以使用已连接的公司资源，并支持多人协同工作。
运行确定性工作流
并非每项工作都需要一个完整的智能体会话。许多工作只是一系列已知的步骤，其中只有一两处需要用到判断力。工作空间可以将这些工作转化为基本确定性的工作流，对可预测的步骤使用代码，只在能带来价值的地方使用模型。工作流可以按需运行、按计划运行，或在所连接系统中发生某个事件时运行。
Cloudflare OS 通过 Gatekeepers 为智能体和应用提供对记录系统的受治理访问（更多内容见下文安全部分）。它还支持现有的模型上下文协议（MCP）服务器，你的组织已通过以下方式在使用MCP 服务器门户.
一个全新的安全与治理框架，用于安全访问内部数据和服务
当人们开始在工作中尝试 AI 时，他们最先提出的请求之一往往是获取公司系统的 API key。这很合理：如果 AI 无法访问人们用来完成工作的系统，它在工作中就没什么用处。
但把 API key 交给人和智能体既危险又无法规模化。key 通常提供宽泛、长期有效的访问权限，难以约束、安全共享和审计。
MCP 为智能体提供了使用这些系统的更好方式。MCP server 可以持有凭证，并暴露一组定义明确的工具，而不是把 key 直接交给智能体。但控制智能体可以调用哪些工具只是第一步。仅靠 MCP 并不能告诉我们智能体观察到了哪些底层资源。智能体可以跨系统组合信息，将其发送到限制更少的地方，或通过应用和输出将其暴露给可能无权查看原始资源的人。授权必须考虑数据接下来会流向何处。
智能体从零访问权限开始
Cloudflare Access 控制谁可以进入 Cloudflare OS。在内部，每个智能体和应用一开始都没有任何访问权限。智能体可以请求访问特定资源，你可以授予或拒绝。生成的代码会以类型化绑定的形式接收该资源：
const issues = await env.PROJECT.listIssues({
teamId: "ENG",
state: "open",
});env.PROJECT 是一种能力，代表在特定策略下使用特定资源的权限。凭证与智能体及任何生成的代码完全隔离。
服务端代码运行在禁用了全局出站网络的 Dynamic Worker 中。客户端代码运行在浏览器中的沙箱化 frame 内。除非通过你明确提供的能力，否则两者都无法访问互联网。
Gatekeeper 管控资源与操作
Gatekeeper 是一种针对特定服务的 Worker，位于 Cloudflare OS 与外部服务之间。它了解该服务的 API、其资源，以及可对这些资源执行的操作。
让智能体访问你的整个 GitHub 账户很可能权限过宽。Gatekeeper 可以让它只访问单个仓库，允许它读取 issue 但不允许读取源代码，屏蔽特定字段，施加速率限制，并要求在合并 pull request 之前获得批准。
智能体及其应用看到的是一个精简的 TypeScript API。Gatekeeper 负责处理 OAuth、保管凭证、执行策略、记录读取内容，并对任何具有外部可见副作用的操作进行中介。
策略跟随智能体所看到的内容
仅控制初始读取是不够的。举例来说，假设智能体读取了数据仓库中的一张敏感表，并用它生成一个实时仪表盘。共享该仪表盘绝不能成为将这张表分享给那些无法直接访问它的人的一种途径。
Cloudflare OS 会记录智能体观察到的每一项资源。这些观察记录始终附属于该智能体及其工作。当其他人试图打开该工作区、与智能体交互或查看其产出时，Gatekeepers 会验证此人对所观察资源的访问权限。
同一份观察日志也被用于制定策略，以决定智能体何时可以发起外部请求。对敏感数据的一次读取，可以阻止智能体将数据写入某些来源、邀请新的协作者、将工作移交给另一个智能体，或发起对外请求。
使用智能体或构建应用的人不必担心犯这些错误。该平台现在可以用来处理这件事。
一个用于构建和分享个人化、可修改应用的平台
大多数生产力套件只给你一组固定的应用：文档、电子表格和演示文稿。而在 Cloudflare OS 中，每个“文件”都可以是它自己的应用，由智能体为一个人、一个项目或一个团队编写。
这些不是那种你必须导出并部署到别处的原型。每一个都是全栈应用，包含客户端代码、服务器代码、API 和持久化状态。应用默认是私有的，但可以像文档一样分享。
每个应用都是一个 Worker
当你要求你的工作区构建一个应用时，智能体会编写两个部分：
- 在浏览器中渲染应用 UI 的客户端代码
- 存储状态并实现应用行为的服务端代码
服务端按需以 Dynamic Worker 的形式加载，并实例化为 Durable Object Facet（两者都是我们为这个项目构建的功能）。该 facet 为应用提供其专属的 SQLite 数据库，独立于管理它的 Cloudflare OS 运行时。Dynamic Workers 使用轻量级的 V8 isolate，因此每个应用都可以拥有自己隔离的运行时，而无需常驻一台专用服务器或容器。
浏览器客户端使用 Cap'n Web 与服务端通信，这是 Cloudflare 开源的 object-capability 远程过程调用（RPC）系统。客户端可以像调用普通 JavaScript 函数一样调用服务端方法：
const issues = await app.listIssues({
status: "done",
});特别之处在于，智能体也可以调用同一个方法。
所以，如果你能构建一个工具来自己完成某项工作，那么当你不在时，智能体也能使用你的工具来完成这项工作。
分享应用，或分享它是如何构建的
当你在 Cloudflare OS 中构建应用时，有两种分享方式：
- 分享应用本身，可以让其他人使用同一状态进行实时协作。
- 分享应用的蓝图，其他人就能创建属于他们自己的应用副本。
从蓝图实例化出的应用包含原始应用的代码，但不包含其 SQLite 数据、对话历史、凭证或已连接资源。每个新应用都从独立的状态和资源开始。
这意味着当你把应用分享给团队时，他们可以用 AI 自行修改，而不必提交功能请求并指派给你。
使用任意模型，并掌控其成本
Cloudflare OS 可与任意模型配合使用。每一次推理调用都经由 Cloudflare AI Gateway，让你的组织在一个地方决定哪些模型可用，以及每项任务应由哪个模型处理。
并非每项任务都需要最昂贵的模型。你可能并不想每天早上用最昂贵的前沿模型来总结未读邮件。AI Gateway 为你提供所需的控制力，确保昂贵模型只用于最困难的工作。
每个请求都归属于发起它的人、团队或工作区。管理员可以查看推理开销流向何处，设置预算和速率限制，并决定达到限制时会发生什么。
开源，因此你可以将其打造成属于自己的东西
Cloudflare OS 今日起可用，并且是开源的。请查看 cloudflare-os GitHub 仓库。你可以将它部署到你自己的 Cloudflare 账户中，并使用你自己的 Access 策略、AI Gateway 配置、数据和集成。
我们的内部部署体现了 Cloudflare 的系统、术语、策略和工作方式。你的部署则应体现你的组织。
Cloudflare OS 的设计目标是让你能够自定义界面、添加内部 Gatekeeper，并构建组织专属功能，而无需改动核心产品。
我们将发布两个仓库：Cloudflare OS 核心以及一个基于我们在 Cloudflare 内部运行方式的示例部署。该部署仓库以不打补丁的方式消费核心，为配置、自定义 UI、内部集成、分析和部署流水线提供了一个场所。
与我们的合作伙伴共同交付
源代码只是起点。上下文、技能、工作流、内部系统和策略，才是让 Cloudflare OS 对你的组织更有用的关键。
Cloudflare 的战略合作伙伴 Presidio 和 Happy Cog 将与你合作，围绕你的组织运作方式定制 Cloudflare OS，并在你的全体员工中推广部署。
合作伙伴可以帮助你策划共享技能与机构上下文，通过 Gatekeepers 和 MCP Server Portals 连接内部系统，并配置安全、模型和成本控制。
你将获得一个自有品牌的 Cloudflare OS，连接你的系统，运行在 Cloudflare 上，并围绕你团队实际的工作方式量身打造。
Cloudflare OS 即日起已在 GitHub 上提供。你可以浏览源代码、试用演示，或使用我们的 starter repository 在几分钟内将其部署到你自己的 Cloudflare 账户中。
我们才刚刚起步。我们正在努力将 Cloudflare OS 作为一款完全托管的产品引入 Cloudflare dashboard，为开发工作流添加容器，并将工作区引入 Slack 和其他聊天工具。
如果你有兴趣与我们的团队交流，我们非常乐意聊聊。请使用 此表单 联系我们！
Cloudflare OS: an open platform for agents, apps, and work
Every organization has a mission, a reason for being. Organizations pass that mission — along with their terminology, procedures, systems, standards, and ways of working — to their people. People, in turn, take this context together with their own experience and work towards the mission.
Work can take many forms, from code, to documents and slides, to relationships, to outcomes in the physical world.
Some of these are straightforward: code either runs or it doesn’t. Agents have been using this feedback loop to produce code that “works” for developers over the last couple of years. But what about the rest of us?
Bringing the same leverage to the rest of the organization is a harder problem. Agents need to understand the context of the company and be able to reach the systems people use to do their jobs. They need to turn that context and access into work that moves the organization towards its mission.
That’s why we created Cloudflare OS. It gives every person an agent and workspace built around their company: how it works, what it knows, and the systems it relies on.
In May of this year, we gave every person at Cloudflare access to the first version of Cloudflare OS. Thousands of people across every function, many of them outside of engineering, use it every day to create documents and slides, automate repeatable tasks, and build small apps to visualize data and help them do their work.
Cloudflare OS also gave everyone a shared library of context and skills built by teams at Cloudflare. It captures our terminology, procedures, and best-known ways of doing recurring work as instructions an agent can follow. When one person figures out a better way to do something, everyone else can use it.
Today, we are open sourcing a new version of Cloudflare OS. Any organization can deploy it, connect it to internal systems, and make it their own.
What we learned from the first version
The Cloudflare OS we are open sourcing today is based on what we learned from running the first version internally, a journey our CIO, Sam Rhea, covers in his blog post.
The first version centered on individuals working with agents through private workspaces. Apps were static rather than live software connected to internal systems, and mostly deterministic jobs still required running an agent skill again and consuming more model tokens.
Collaboration exposed a more fundamental challenge. Access to an MCP server told us which tools an agent could call, but not which underlying resources the agent had observed. Once people began sharing workspaces, apps, and outputs, we needed to ensure that collaboration could not expose information someone was not permitted to see.
We rebuilt Cloudflare OS on a new foundation to solve these problems. Security had to be part of the platform, not something every person building an app or using an agent has to implement correctly.
The result is a platform designed to belong to the company running it. You can customize the interfaces, connect your tools, and add the skills and context that capture how your organization works.
Introducing Cloudflare OS
Cloudflare OS starts with a conversation in your browser, like many other AI tools. What makes it different is that each conversation is grounded in the context and skills your organization has curated. Give your workspace a goal, and it can draw on that knowledge and work with the tools and data your organization already uses to achieve it.
Cloudflare OS combines three parts:
- An agent workspace grounded in context and skills your company curates, with an isolated runtime where agents can write and run code.
- A new security and governance framework for safe access to internal data and services.
- A platform for personal, modifiable apps that people can build, share, and continue changing.
What begins as a conversation can become a doc, an app, or a workflow that continues doing the work.
An agent workspace for everyone in your company
Agent workspaces were designed for everyone in your organization to use. You interact with them in your browser, so you don’t have to be a developer or know how to use a terminal.
A workspace combines agent sessions, persistent state, outputs and files, resource access, and an isolated runtime where the agent can write and run code.
They come loaded with the curated context and skills your team or company has collected. No more reinventing the wheel for every task — if someone on your team has figured out the best way to do something, everyone benefits. People no longer have to explain the same process, terminology, and best practices to a model every time they start a task.
A few things you can do:
Research and ask questions
Ask a workspace to research a topic using company context and the resources you make available to it. The agent can write code to search, filter, join, and analyze information instead of pulling an entire dataset into the model’s context window.
Create docs, slides, and spreadsheets
A workspace can turn its research into a document, presentation, or spreadsheet that you can continue editing. These outputs do not have to be static files. They can remain connected to live data, be updated as their sources change, and still be exported to familiar formats or services such as Google Drive.
Create collaborative, connected apps for your team
When a document or spreadsheet is not enough, the agent can build an app with its own interface, logic, and state. The app can use connected company resources and support multiple people working together.
Run deterministic workflows
Not every job needs a full agent session. Many are a known sequence of steps with one or two places where judgment is useful. A workspace can turn those jobs into mostly deterministic workflows, using code for the predictable steps and a model only where it adds value. Workflows can run on demand, on a schedule, or when an event occurs in a connected system.
Cloudflare OS gives agents and apps governed access to systems of record through Gatekeepers (more on this in the security section below). It also supports existing Model Context Protocol (MCP) servers your organization already uses via MCP Server Portals.
A new security and governance framework for safe access to internal data and services
As people begin experimenting with AI at work, one of their first requests is often for API keys to company systems. This makes sense: AI isn’t much use at work if it doesn’t have access to the systems people use to do their jobs.
But handing over API keys to people and agents is dangerous and does not scale. Keys often provide broad, long-lived access that is difficult to constrain, share safely, and audit.
MCP gives agents a better way to use these systems. An MCP server can hold the credential and expose a defined set of tools instead of handing the key directly to the agent. But controlling which tools an agent can call is only the first step. MCP alone does not tell us which underlying resources an agent has observed. The agent can combine information across systems, send it somewhere less restricted, or expose it through apps and outputs to people who may not be allowed to see the original resources. Authorization has to account for where the data can go next.
Agents start with no access
Cloudflare Access controls who can enter Cloudflare OS. Inside, every agent and app starts with access to nothing. An agent can ask for access to a specific resource, which you can grant or deny. Generated code receives that resource as a typed binding:
const issues = await env.PROJECT.listIssues({
teamId: "ENG",
state: "open",
});env.PROJECT is a capability representing permission to use a specific resource under a specific policy. The credential remains completely isolated from the agent and any generated code.
Server code runs in a Dynamic Worker with global outbound networking disabled. Client code runs in a sandboxed frame in the browser. Neither can reach the Internet except through capabilities you explicitly provide.
Gatekeepers govern resources and actions
A Gatekeeper is a service-specific Worker that sits between Cloudflare OS and an external service. It understands the service’s API, its resources, and the operations that can be performed on them.
Giving an agent access to your entire GitHub account is likely too broad. A Gatekeeper can give it access to a single repository, allow it to read issues but not source code, mask particular fields, apply rate limits, and require approval before merging a pull request.
The agent and its apps see a small TypeScript API. The Gatekeeper handles OAuth, holds the credential, enforces policy, records what was read, and mediates anything with an externally visible side effect.
Policy follows what the agent has seen
Controlling the initial read is not enough. Take, for example, the case where an agent reads a sensitive table in a data warehouse and uses it to produce a live dashboard. Sharing the dashboard must not become a way to share the table with people who could not access it directly.
Cloudflare OS records every resource agents observe. These observations remain attached to the agent and its work. When another person tries to open the workspace, interact with the agent, or view what it produced, Gatekeepers verify that person's access to the observed resources.
The same observation log is used to inform policies that determine when agents can make external requests. A read of sensitive data can prevent the agent from writing data to certain sources, inviting new collaborators, handing work to another agent, or making an outbound request.
People using agents or building apps do not have to worry about making these mistakes. The platform can now be used to handle this.
A platform for building and sharing personal, modifiable apps
Most productivity suites give you a fixed set of applications: documents, spreadsheets, and presentations. In Cloudflare OS, each “file” can be its own application, written by an agent for one person, one project, or one team.
These are not prototypes that you have to export and deploy somewhere else. Each one is a full-stack application with client code, server code, an API, and durable state. Apps are private by default, but can be shared like documents.
Every app is a Worker
When you ask your workspace to build an app, the agent writes two parts:
- Client code that renders the app’s UI in the browser
- Server code that stores state and implements the app’s behavior
The server is loaded on demand as a Dynamic Worker and instantiated as a Durable Object Facet (both are features we built for this project). The facet gives the app its own SQLite database, separate from the Cloudflare OS runtime managing it. Dynamic Workers use lightweight V8 isolates, so every app can have its own isolated runtime without needing a dedicated server or container sitting around.
The browser client talks to the server using Cap’n Web, Cloudflare’s open source object-capability Remote Procedure Call (RPC) system. A server method can be called from the client like a normal JavaScript function:
const issues = await app.listIssues({
status: "done",
});The special part is that the agent can also call the same method.
So if you can build a tool to do a job yourself, agents can use your tool to do the job when you’re not there.
Share the app, or share how it was built
When you build an app in Cloudflare OS, you have two ways to share them:
- Sharing your app itself lets other people collaborate in real time using the same state.
- Sharing a blueprint of your app lets other people create their own copy of your app.
An app instantiated from a blueprint contains the original app’s code. But it does not contain its SQLite data, conversation history, credentials, or connected resources. Each new app starts with independent state and resources.
This means when you share apps with your team, they can modify them themselves with AI instead of filing a feature request and assigning you.
Use any model, and control what it costs
Cloudflare OS can be used with any model. Every inference call runs through Cloudflare AI Gateway, giving your organization one place to decide which models are available and which model should handle each job.
Not every task needs the most expensive model. You may not want to run the most expensive frontier model to summarize your unread emails every morning. AI Gateway gives you the control needed to make sure expensive models are only being used for the hardest work.
Every request is attributed to the person, team, or workspace that made it. Administrators can see where inference spend is going, set budgets and rate limits, and decide what happens when a limit is reached.
Open source, so you can make it yours
Cloudflare OS is available today and is open source. Check out the cloudflare-os GitHub repository. You can deploy it into your own Cloudflare account and use your own Access policies, AI Gateway configuration, data, and integrations.
Our internal deployment reflects Cloudflare’s systems, terminology, policies, and ways of working. Yours should reflect your organization.
Cloudflare OS is designed so you can customize the interface, add internal Gatekeepers, and build organization-specific features without changing the core product.
We are releasing two repositories: the Cloudflare OS core and an example deployment based on how we run it internally at Cloudflare. The deployment repository consumes the core without patching it, providing a place for configuration, custom UI, internal integrations, analytics, and deployment pipelines.
Delivered together with our partners
The source code is only the starting point. The context, skills, workflows, internal systems, and policies are what make Cloudflare OS even more useful for your organization.
Cloudflare’s strategic partners, Presidio and Happy Cog, will work with you to customize Cloudflare OS around how your organization operates and roll it out across your workforce.
Partners can help you curate shared skills and institutional context, build custom interfaces, connect internal systems through Gatekeepers and MCP Server Portals, and configure security, model, and cost controls.
You get your own branded Cloudflare OS, connected to your systems, running on Cloudflare, and shaped around how your people actually work.
Cloudflare OS is available today on GitHub. You can explore the source code, try the demo, or deploy it into your own Cloudflare account in a few minutes using our starter repository.
We’re just getting started. We’re working on bringing Cloudflare OS to the Cloudflare dashboard as a fully managed product, adding containers for development workflows, and bringing workspaces into Slack and other chat tools.
If you’re interested in talking with our team, we would love to chat. Use this form to reach out!