How Cloudflare Turns Building Office Tools into a Dialogue with an Agent

Inside most IT companies, the zoo of work tools looks the same: endless Google Docs, Notion, a couple of internal dashboards on Retool, and dozens of scattered scripts written by a colleague who left two years ago. When an employee needs a simple tool for a narrow task, they either go ask the internal development team for resources, or try to cobble something together on the fly.

The Cloudflare team has open-sourced the repository cloudflare-os. This is their internal working environment, where employees from engineers to salespeople create micro-applications directly through chat with a language model.

What Hides Behind the Bold Name

The name "operating system" here is more about managing computational tasks and processes than replacing Linux. The authors put two meanings into the term: a secure environment for running AI workloads and a common platform for everyday productivity within the company.

The core concept is built around abandoning centralized SaaS in favor of so-called Gadgets. When you need an interactive presentation or a Kanban board for a specific sprint, the system doesn't open a third-party service. Instead, a built-in agent generates an isolated web application personally for you.

This approach changes a couple of familiar things:

• Data security. The application runs in a separate isolated sandbox and physically cannot send information outside without explicit permission.
• Customization. If the generated table is missing a chart or an export to CSV button, you simply ask the agent to add this function in the application code.

If the result turns out good, you can export it as a Blueprint and share the codebase with colleagues so they can deploy independent copies.

What the System Can Do

The repository features the second version of the platform, which developers completely rewrote from scratch after internal usage experience.

Generating Work Applications on the Fly

Instead of ready-made document templates, the system offers to generate interactive software. A prompt like "build me a Kanban board with a Pomodoro timer" creates a full-fledged client interface and backend.

The agent works in Code Mode: it writes code chunks, immediately runs them in the runtime, catches errors, and fixes itself until the application works as intended. You can connect any supported LLM through the Pi library adapter.

Real-Time Collaboration

Each created application immediately supports multiplayer. If you share the link with a colleague, you both see each other's actions on screen in real time. Developers don't need to manually configure WebSockets because each gadget has a distributed state powered by Cloudflare Durable Objects under the hood.

Smart Security Model with Gatekeepers

Usually, agent integrations with external services via MCP suffer from giving the bot overly broad permissions. Here, access is structured differently:

• Each external service (GitHub, Slack, Google Docs, Notion, Supabase) is protected by its own Gatekeeper gateway.
• By default, the agent has no access to anything. The user manually "introduces" it to the needed repository or document.
• All actions with side effects require human confirmation.

The authors solved the main problem with Human-in-the-loop mode—agents constantly getting stuck waiting for user clicks. Gatekeeper simulates a successful service response and returns synthetic data. The bot continues the reasoning chain, and the person later approves a batch of accumulated actions in bulk at a convenient time.

Built-in Human and AI Communication Inside Finished Software

The client and server in gadgets communicate through a lightweight Cap'n Web RPC protocol. This provides an unexpected benefit: the application interface is automatically understandable to the language model. After the agent assembles an interactive questionnaire for you, you can ask it to fill in some data or recalculate statistics right inside the created window.

How It's Structured Under the Hood

Cloudflare OS architecture mirrors a traditional operating system but built on serverless primitives:

• The Kernel is implemented in package workshop-backend. It handles sandbox launching, access control, and process coordination.
• Device drivers are represented by gatekeepers in packages packages/gatekeeper-*. They connect the system with external APIs.
• Processes and executables are gadgets and their blueprint templates.
• The user interface (Shell) is built on Vite and CodeMirror.

Each gadget's server-side component runs in a Dynamic Worker Facet with internet access completely disabled. The client opens in a protected iframe with strict Content-Security-Policy and can only communicate with the parent window through postMessage.

Interestingly, the project was created by the same authors who built the Workers runtime itself. Essentially, features like Dynamic Workers and Facets were added to the Cloudflare platform specifically to enable this architecture. However, being tied to the cloud isn't mandatory: the system can run on the open engine workerd.

How to Launch and Try It Out

For local testing, you need the pnpm package manager and Node.js installed.

Clone the repository and start the local stack:

After that, the interface will open at http://localhost:8787. The local database and environment will spin up through the built-in Wrangler emulator, and data will be saved to the .wrangler folder.

If you want to tweak the frontend or backend, you can run them separately in two terminals:

To work with external services, you'll need to set up OAuth keys for the required gateways in the packages/gatekeeper-* folders. The repository already includes ready-made connectors for GitHub, Google API, Notion, Slack, Spotify, and Home Assistant.

Impressions and Nuances

Cloudflare OS looks like a bold experiment in how companies can write software for internal needs. The idea of giving each employee a personal copy of a web application instead of one shared instance sounds unconventional, but it perfectly solves security and customization problems.

It's important to remember that the project is in early access status. Documentation is still minimal, deployment on your own server via pure workerd is still being polished, and the authors barely accept third-party PRs in the repository due to the high review complexity.

If you're looking for a ready-made replacement for Jira or Notion out of the box, the project will still seem raw. But if you're interested in exploring cutting-edge architecture based on Durable Objects or want to see how to safely embed agents into internal company processes, the source code is definitely worth a couple of free evenings.