OpenAI Open-Sources OpenClaw Enterprise to Orchestrate Agent Fleets

ClawLabs: Building Open Source Together | DevDay 2026 — OpenAI

OpenAI

Autonomous software engineering requires shared multiplayer environments and strict security boundaries to eliminate the human bottlenecks of private, terminal-bound agent sessions.

AI-assisted summary of ClawLabs: Building Open Source Together | DevDay 2026 — original source. Check the original for full context.

Source published:

Key ideas

  • OpenClaw, stewarded by the independent nonprofit OpenClaw Foundation with OpenAI backing, transitions AI development away from isolated single-developer sessions toward persistent, multi-user collaborative runtimes. (3:18)
  • OpenAI officially open-sourced OpenClaw Enterprise (OCE), a vendor-neutral control plane developed alongside Red Hat and NVIDIA to provide Kubernetes-style governance, workload isolation, and sandboxing for autonomous agents. (32:49)
  • OpenAI scaled its internal deployment to more than 400 autonomous agents operating continuously to triage bug reports, reproduce issues in isolated environments, synthesize patches, and merge pull requests. (24:34)
  • Target-driven '/goal' directives demonstrated persistent multi-week autonomy, completing an 18-day asynchronous database migration that landed over 100 pull requests without breaking the codebase. (21:30)

Detailed notes

## Background Published on YouTube by OpenAI on October 7, 2026, 'ClawLabs: Building Open Source Together | DevDay 2026' explores how AI agents assist small open-source teams in building software collaboratively. According to the page description, the session showcases workflows for sharing context across projects and contributors through live demonstrations of cloud sessions and computer use.

## TL;DR The presentation examines the evolution of developer agent harnesses from isolated CLI setups—where humans acted as single-threaded 'meat proxies'—to OpenClaw, an open-source platform enabling shared, multi-user agent collaboration. Presenters Peter and Kevin Lin demonstrate live multiplayer agent canvases, malleable internal dashboards dubbed 'jellyware,' voice-enabled meeting agents, and continuous background loops that automatically triage, reproduce, and patch bugs. Kevin Lin formally announces the open-sourcing of OpenClaw Enterprise (OCE), an agent control plane governed by the nonprofit OpenClaw Foundation that implements workload isolation, sandboxing, and auto-review safeguards to orchestrate autonomous agents at scale.

## Atmosphere & style The talk delivers an energetic, candid developer-conference vibe, mixing practical architectural insights with lively audience interaction and live-demo troubleshooting. Presenters maintain a lighthearted, self-effacing rapport, poking fun at CLI purists, sharing the vulnerability of exposing raw prompt histories, and joking about averting 'lunchtime crises' during live pull request reviews. The mood transitions smoothly from the playful, experimental atmosphere of chaotic shared-canvas games and 'slop meters' to an authoritative, forward-looking presentation on open-source enterprise governance and security.

## Bulletin - [03:18](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=198s) OpenClaw, stewarded by the independent nonprofit OpenClaw Foundation with OpenAI backing, transitions AI development away from isolated single-developer sessions toward persistent, multi-user collaborative runtimes. - [32:49](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1969s) OpenAI officially open-sourced OpenClaw Enterprise (OCE), a vendor-neutral control plane developed alongside Red Hat and NVIDIA to provide Kubernetes-style governance, workload isolation, and sandboxing for autonomous agents. - [24:34](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1474s) OpenAI scaled its internal deployment to more than 400 autonomous agents operating continuously to triage bug reports, reproduce issues in isolated environments, synthesize patches, and merge pull requests. - [21:30](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1290s) Target-driven '/goal' directives demonstrated persistent multi-week autonomy, completing an 18-day asynchronous database migration that landed over 100 pull requests without breaking the codebase.

## Key takeaways - [00:31](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=31s) Terminal-bound AI workflows created the 'meat proxy' bottleneck, turning developers into manual intermediaries who copied prompts and outputs between teammates and isolated models. - [03:18](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=198s) OpenClaw provides a decentralized, self-hostable open-source platform managed by the OpenClaw Foundation, supporting unified ChatGPT single sign-on while preserving model neutrality. - [04:47](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=287s) Live 'multiplayer' agent sessions replace the traditional asynchronous pull request loop by allowing multiple users to concurrently steer and inspect the same running agent canvas. - [09:10](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=550s) Exposing raw prompt histories on pull requests initially met developer resistance, but ultimately eliminated team friction by making author intent transparent behind massive code diffs. - [13:08](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=788s) Traditional continuous integration is being reimagined using agent harnesses that dynamically determine and execute only the relevant subset of tests for a specific change. - [13:52](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=832s) Ephemeral, natural-language-generated dashboards and internal tooling—termed 'jellyware'—are replacing brittle, hardcoded internal utilities across development servers. - [16:56](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1016s) Meeting transcription and project workflows were replaced by voice agents integrated via GPT Live in Discord that share persistent session memory with engineering servers. - [19:32](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1172s) Autonomous software factories rely on human engineers primarily for aesthetic and architectural 'taste', while automated background loops triage bug reports, reproduce issues, and land fixes. - [21:30](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1290s) Development tasks are split architecturally between indefinitely running monitoring 'loops' and finite, target-driven '/goal' directives that execute multi-week code migrations. - [24:34](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1474s) OpenClaw Enterprise secures agent operations by separating deterministic workloads from agent runtimes across isolated containers and distinct clusters. - [24:34](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1474s) Agent security governance relies on strict tool sandboxing, secondary auto-review models that intercept dangerous operations, and auditable dedicated service accounts. - [32:49](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1969s) Collaborative security initiatives like 'Patch the Planet' pair open-source agent ecosystems with partners like Trail of Bits to systematically eradicate vulnerability classes across public repositories.

## Detailed walkthrough ### [00:31](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=31s) The Evolution of Agent Harnesses and the "Meat Proxy" Trap

The past year marked a massive shift in how developers interact with AI agents. Development originally lived entirely inside the command-line interface (CLI)—split terminals everywhere, multiple Codex sessions firing simultaneously, and code rapidly churning out left and right. In those early stages, developers had to constantly "smash escape to steer the agent" whenever it went off track. However, as foundation models grew smarter, the need to manually interrupt and steer dropped drastically, exposing the limits of a purely terminal-bound workflow.

```mermaid flowchart TD accTitle: Evolution of Developer Agent Workflows accDescr: Progression from local CLI setups to desktop GUIs, distributed devboxes, and shared multiplayer platforms.

subgraph Phase1["1. Local CLI"] A["Terminal / CLI"] -->|"Escape-smashing steers"| B["Single-box Codex"] end

subgraph Phase2["2. Local GUI & Distributed Cloud"] B --> C["Codex Desktop GUI"] C -->|"Fan noise & disk full"| D["DevBoxes & Cloud VNC"] end

subgraph Phase3["3. The Collaboration Bottleneck"] D -->|"Single point of contact"| E["'Meat Proxy' Bottleneck"] end

subgraph Phase4["4. OpenClaw Shared Sessions"] E -->|"Open session visibility"| F["OpenClaw Multiplayer"] end ```

Moving to Codex Desktop improved things considerably: it offered cleaner typography, inline browsers, integrated code review, visual progress indicators, and effortless parallel session orchestration. Yet this capability introduced hardware strain. Running high-volume experiments locally maxed out disk storage and made cooling fans sound "like a jet engine." The immediate fix was spreading execution across six to ten cloud DevBoxes, spinning up dedicated test runners, and checking in via VNC or remote Codex connections. But throwing more compute at the problem uncovered a structural team bottleneck: teammate collaboration. Every request had to route through a single developer acting as an intermediary to the AI.

- The term **meat proxy**, coined this year by Frank Allenby, describes a human developer who becomes a glorified communication layer, manually copying prompts and output back and forth between teammates and an AI model. - While everyone was utilizing agents, true collaboration was absent because contextual decisions remained isolated inside individual private sessions.

---

[03:18](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=198s) Introducing OpenClaw: Shared Context and Open-Source Governance

OpenClaw (OC) was created to escape the meat proxy pattern by providing an open-source platform for persistent, multi-user agents. It bridges local developer tooling, remote infrastructure, and team workflows. Rather than siloing work on one laptop, OpenClaw integrates directly with developer environments, incorporating ChatGPT account logins, active plugins, and existing Codex sessions into a shared runtime.

Governance is intentionally decentralized: OpenClaw is stewarded by the independent nonprofit **OpenClaw Foundation**, with ongoing backing from OpenAI. The OpenAI research team uses OpenClaw to investigate what an automated software engineer should look like, how to orchestrate autonomous agents at scale, and how modern development harnesses must change to keep pace with rapid model advances. Workflows that felt state-of-the-art only six months or a year ago already feel constrained and outdated.

- **Nonprofit backing:** OpenClaw is maintained under the OpenClaw Foundation to ensure platform openness, model neutrality, and independent governance. - **Unified auth:** Includes single sign-on using a "sign in with ChatGPT" button while retaining compatibility with personal subscriptions and custom plugins. - **Self-hosting:** Teams retain the freedom to modify the underlying agent code, select arbitrary models, and host the platform on their own private servers.

---

[04:47](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=287s) Live Demo: Multiplayer Agent Swarms and the Lobster Game

A live demonstration of the collaborative environment featured **PartyClaw**, an agent session operated via voice commands and real-time multi-user inputs. Moving beyond the conventional pull-request lifecycle—where an agent writes code asynchronously and returns an isolated branch for manual checkout—OpenClaw turns code generation into a shared, live workspace.

```mermaid flowchart LR accTitle: Pull Request Workflow vs Live OpenClaw Collaboration accDescr: Comparison between the traditional pull request loop and OpenClaw's shared session approach.

subgraph Traditional["Old Workflow: Asynchronous PR"] T1["Prompt Agent"] --> T2["Wait for PR"] T2 --> T3["Local Codex Review"] end

subgraph OpenClaw["New Workflow: Collaborative Session"] O1["Live Prompt"] --> O2["Shared State / Canvas"] O3["Teammate Prompts"] --> O2 O2 --> O4["Instant Multi-User Deploy"] end ```

When prompted to build an arcade game "where the frog has to go over a street with cars," PartyClaw immediately located and deployed an existing project, *Lily Lane* (Frogger), originally authored by Kevin on the team. Audience members were provided a live URL to join the session directly, turning the agent canvas into a multi-author party. The demo speaker quickly submitted a prompt to swap the player avatar into a lobster before the audience or teammates could turn it into an elephant. Within seconds, the agent updated the running canvas to feature lobsters dodging sharks.

- **Multi-user prompt injection:** Anyone connected to the session server can inspect executing prompts, steer the agent concurrently, and build on existing states. - **Contributor incentive model:** OpenClaw plans to invite top open-source contributors directly into hosted workspaces, offering compute tokens in exchange for architecture feedback and ideas: *"You get the tokens and we get a little bit of your ideas."* - **Audience participation:** Live attendees jumped onto the shared URL so quickly that the presenter had to jokingly tell staff to "close the gates" before the cluster became overwhelmed.

---

[09:10](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=550s) The Psychology of Sharing Prompts and Transparent PRs

Multiplayer agent sessions significantly altered internal team dynamics. While OpenAI's enterprise integration **Dots** supports agent collaboration inside enterprise boundaries, OpenClaw brings similar principles to open-source workflows with total infrastructure control and cross-system interoperability.

However, sharing the precise prompts that generate code exposed an unexpected human vulnerability: developers found raw prompts intensely private. Because a single natural-language instruction can produce tens of thousands of lines of code, code reviews without prompt context leave reviewers understanding *what* code changed without understanding *why*. An earlier attempt to require sanitized prompt transcripts on pull requests saw widespread resistance, with developers—including the speaker—refusing to attach them. Once team-wide session visibility was enforced by default, the initial awkwardness faded after a day, quickly replaced by earlier mistake detection and cross-pollination of prompt techniques.

A live code review demonstrated the concrete value of this visibility. Inspecting an unreviewed pull request from **Roboclaw**, the speaker found a commit that shrank UI table sizes—directly conflicting with work the speaker had completed the previous day to make them larger:

> "My cortisol level would go up. It's like, who did this? Like, why? What did Victor do? And maybe in the past, I would have dropped him a not very Californian message. But now, I can click on the work session and I can just check out what he did, right?"

Opening Victor's linked session revealed that Victor had actually reused the speaker's original session, pinged him for input, and left commentary expressing frustration with existing continuous integration (CI) runtimes. Transparent session context replaced workplace friction with immediate clarity on the engineer's true intent.

[13:08](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=788s) Rethinking CI and the "Lunchtime Crisis Averted"

Reflecting on how development workflows must evolve, the speaker questions whether traditional continuous integration still makes sense in the agent era. Running every test blindly is slow and outdated, prompting ongoing experiments with Codex to bring intelligence into the pipeline—allowing an agent to dynamically decide which subset of tests is actually relevant for a given change. Scrolling back through the pull request, the speaker realizes their initial skepticism was misplaced: Victor had actually thought through the problem thoroughly, cleaned up the code, and fixed the broken pieces. Relieved, the speaker announces that the "lunchtime crisis" has been safely averted.

[13:52](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=832s) From Software to "Jellyware": The Team Server as a Place

Turning to a live tour of their setup, the speaker explains that their team views their server less as a static application and more as an interactive place where work happens. A modern project encompasses far more than just writing code, which is reflected in a sidebar packed with custom dashboards and plugins. In the past, internal tooling was notoriously fragmented—scattered across separate servers, maintained through brittle GitHub Actions workflows, and powered by disparate databases and repos that nobody fully kept track of.

To demonstrate how low the barrier to entry has become, the speaker brings up an internal dashboard tracking continuous integration runtimes. Whenever styling or functionality needs tweaking, there is no need to write boilerplate code or deploy changes manually; one simply tells the agent, "make this blue," and it immediately updates the live view. Because these artifacts are generated and updated on the fly by agent sessions, the speaker questions whether this even qualifies as traditional software anymore, proposing the term "jellyware" to describe the malleable, fast-iterating code artifacts they build every day.

```mermaid flowchart TD accTitle: The Jellyware Feedback Loop accDescr: Diagram illustrating how team input and automated triggers generate and refine lightweight interactive dashboards. subgraph Trigger["Inputs & Automation"] A["Team Prompt / Natural Language<br>('make this blue')"] B["Scheduled Background Automation"] end

subgraph AgentRuntime["Agent Session"] C["Agent Execution & Code Generation"] end

subgraph Output["Artifact Layer ('Jellyware')"] D["Interactive HTML / UI Plugin"] E["Live Team Dashboard<br>(CI Runtimes, Community Metrics)"] end

A --> C B --> C C --> D D --> E ```

[15:33](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=933s) Internal Dashboards, The Daily Claw, and the "Slop Meter"

The server hosts a variety of purpose-built tools that mix utility with community culture: - **Community Analytics**: Tracking core metrics including open PRs, reported issues, and merge rates for team members who love data graphs. - **The Daily Claw**: An automated news generator that reads everything merged to the server that day and writes a daily newspaper summarizing the progress. While it occasionally gets facts hilariously wrong, it keeps the building process fun and engaging. - **The Slop Meter**: A dedicated gauge designed to combat the tendency of AI agents to endlessly emit bloated code. By visually raising awareness of code inflation, the dashboard encourages the team to prompt their agents to refactor and clean up their repositories. - **Activity Reports**: Dedicated code plugins showing member activity, including commit counts and Discord engagement levels.

The speaker emphasizes that maintaining a sense of playfulness is critical for high-performing engineering teams, noting that "you have to have fun when you build. That's the whole point if you want to do good work."

[16:56](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1016s) Voice-Enabled Meeting Agents in Discord

Internal meetings have also been completely re-architected. The team previously relied on a paid commercial SaaS product for meeting transcription until realizing that the entire service could simply be replaced by a prompt. Now, an in-house agent leverages Luna to ingest and summarize meeting transcripts directly within Discord.

Taking it a step further, the agent is wired into GPT Live, enabling it to verbally participate in real-time conversations rather than just quietly recording notes. Because this voice assistant shares the exact same persistent identity and main session memory as the rest of the team server, engineers can verbally query it about current tasks or instruct it to spin off new work mid-call without losing context.

[17:48](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1068s) Watching Colleagues Work: Victor's Design Iterations in Codex

Navigating down the server interface, the speaker highlights a presence view that shows which team members are active and what their agents are working on. Victor had criticized the speaker's rough initial implementation of the active-user view and spent the morning redesigning the sidebar. Scrolling through Victor's session log reveals his distinct prompting style—complete with "very colourful language" and a relentless drive for perfection.

Rather than settling for the first result, Victor pushed the agent through dozens of design iterations, at one point having the agent build dedicated interactive visual editors just to fine-tune the UI until other teammates jumped into the session to collaborate. The speaker notes that these rich visual artifacts work natively inside the Codex desktop application, teasing developers who remain bound to the terminal: "if you're still stuck in the CLI, it's time to upgrade. You're stuck in 2025."

[19:32](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1172s) The Software Factory: Autonomous Loops and Human Taste

Stepping back to outline the larger architectural philosophy, the speaker describes their goal: building an agent that builds their software, paving the way toward a fully functional software factory. While certain exploratory tasks require hands-on pairing between a human and an agent, background automation is driven by autonomous "loops."

Human developers provide the critical element agents cannot replicate: taste. Because taste is an intuitive feeling that is extraordinarily difficult to articulate in prompts, humans act as curators and directors while moving their local background loops onto shared team servers so the entire group can inspect, learn from, and maintain them.

```mermaid flowchart LR accTitle: Automated Issue Resolution Loop accDescr: Flowchart showing how incoming bug reports are triaged, reproduced, fixed, and reviewed by automated agents before landing in main. subgraph Ingestion["Triage & Detection"] A["External Monitors<br>(Discord, Twitter, GitHub)"] --> B["Category Classification<br>(CLI-assisted parsing)"] end

subgraph Resolution["Investigation & Patching"] B -->|"Update Issues"| C["Spin Up Isolated Test Box"] C --> D["Reproduce Bug"] D --> E["Synthesize Patch & Validate Fix"] end

subgraph Review["Review & Landing"] E --> F["Secondary Agent Review"] F --> G["Automatic Merge / Land Fix"] end ```

The issue-resolution loop operates continuously across public feedback channels: - Custom CLI tools stream bug reports from Discord, X (formerly Twitter), and GitHub into the agent. - For specific categories such as update failures, the agent spins up a clean test environment to reproduce the bug. - Once verified, the agent formulates a patch, tests the resolution, passes the diff to an independent reviewer agent, and automatically lands the fix into production.

[21:30](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1290s) Persistent Loops vs. Slash-Goal Migrations

The speaker clarifies the architectural distinction between continuous background operations and target-driven objectives: - **Loops**: Indefinitely running processes that monitor states and flag regressions. A performance loop, for example, watches the daily releases of the team server, captures snapshots, and flags performance dips. - **Goals (`/goal`)**: Structured agent directives working toward a specific, finite end state.

To illustrate a goal in practice, the speaker shows an ongoing initiative migrating their entire backend from synchronous SQLite access to an asynchronous database abstraction layer, preparing the architecture for swappable database backends in the future. As of the talk, this single goal had been executing autonomously on a local Codex instance for 18 days, landing over 100 pull requests without breaking the codebase. Ultimately, the team aims to assign an agent per project, equipped with dedicated memory, automations, and goals to maintain and upgrade software from high-level instructions.

[22:42](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1362s) Audience Sandbox Demos and the Enterprise Announcement

Switching back to the shared explorer, the speaker examines what attendees in the audience have been generating using the live system. Audience creations include a "release radar" tracker, an interactive game, an "island builder," and a collaborative game of Pictionary with the Claw where the agent attempts to guess concepts visually using Computer-Using Agent (CUA) capabilities. For those unable to claim a slot in the live cloud instance, the speaker notes that the software can be downloaded and run locally on any server with single-click Codex integration.

Concluding the walkthrough of how small, agile teams build alongside agents, the speaker introduces the next operational hurdle: as agent adoption spreads across large organizations, enterprises face severe challenges around deployment, configuration, security, and governance. To solve this dilemma, ClawLabs developed a dedicated enterprise control plane—and officially announces that it is being open-sourced today.

[24:34](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1474s) Introducing OpenClaw Enterprise and Security Fundamentals

Peter welcomes Kevin Lin to the stage to present the platform they have built. Kevin, who leads OpenClaw Enterprise (OCE) at OpenAI, introduces OCE as an open-source control plane designed to make OpenClaw multi-tenant while establishing strict governance and hard security boundaries around agent deployments. Emphasizing that a secure runtime is the essential foundation required to bring persistent agents to everyone, Kevin details the core security principles engineered directly into the system:

```mermaid flowchart TD accTitle: OpenClaw Enterprise Security Architecture accDescr: Diagram illustrating the four security boundaries of OpenClaw Enterprise including workload isolation, sandboxing, auto-review, and dedicated identities.

subgraph Boundaries["Isolation & Tool Access"] A["Deterministic Workload<br/>(Separate Container/Cluster)"] B["Agent Execution Runtime"] C["Sandboxed Tooling<br/>(Network, File Writes, Repos)"] A -.->|"Hard boundary"| B B --> C end

subgraph Governance["Safety & Identity"] D["Auto-Review Model<br/>(Blocks dangerous actions)"] E["Persistent Service Account<br/>(Auditable, Kill-switch ready)"] C --> D D --> E end ```

First, the architecture enforces strict isolation between trusted and untrusted workloads: deterministic code executes inside an isolated container and a distinct cluster completely separate from where the agent itself runs, preventing agents from altering their underlying runtime. Second, sandboxing tightly bounds agent capabilities, restricting network access, file write permissions, and target repositories so agents can leverage practical tools without being granted unrestricted authority. Third, the system layers automated model-based reviews via auto-review—a built-in mechanism found in Codex and OpenClaw that runs an independent model to inspect actions and intercept potentially dangerous calls before execution. Finally, every agent operates under its own distinct identity through dedicated service accounts and configurable connectors rather than impersonating individual human users, enabling teams to independently audit, control, or shut down any agent. Kevin explains that these safeguards have enabled OpenAI to scale its own internal deployment to over 400 active "Claws" operating around the clock to run experiments, patch code, analyze data, and flag security issues.

[27:31](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1651s) Live Demo: Creating Fred and Steering Cooper

Kevin transitions to a live demonstration, joking about an ambiguous graphic ("This is a hard Pictionary game. I don't know what that is") before walking through the deployment interface. He showcases presets—pre-packaged, configurable bundles that allow organizations to deploy agents adhering to internal security baselines. To mark the debut of OCE, Kevin configures a new community agent named "Fred":

- **Harness & Identity:** Configured with the Codex harness and assigned its own independent service account. - **Repository Access:** Restricted to read-only access on the code repository so Fred can inspect code to answer questions without modifying files directly. - **Project Tracking:** Connected to Linear for roadmap context, with hard governance requiring human team approval for any write actions. - **Communication:** Integrated with Slack using an existing bot token and pre-populated community channels.

While Fred initializes, Kevin shifts attention to "Cooper," an existing software development agent functioning as a persistent teammate that triages bugs, validates reproductions, and merges features end-to-end. Noting that the standard OCE console is functional but visually plain, Kevin prompts Cooper: *"Cooper, can you add a heat map of token usage per agent to the dashboard?"* He highlights that software engineering agents represent one of OpenAI's most heavily utilized internal workloads, observing that many public Codex issues submitted over the past month were triaged, reproduced, and merged by OpenClaw agents without manual intervention.

Kevin demonstrates the collaborative "multiplayer" capability native to all OCE deployments by opening an authenticated session directly into Cooper's team server. Within this web console view, team members can watch real-time execution or intervene directly; Kevin enters an additional steering instruction: *"Make sure dashboard has custom color palettes. I mean the web console."* Switching back to Fred, Kevin queries the freshly spawned agent: *"Hi, Fred. What are we launching today?"* Fred scans connected Slack channels and Linear boards to gather relevant context. Despite encountering a minor plugin hiccup during the live retrieval, Fred successfully pulls the release notes and locates the Linear task announcing the launch of OCE, prompting Kevin to tease, *"Fred, please do better next time."*

[32:49](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1969s) Launching OpenClaw Enterprise and Closing Remarks

Concluding his segment, Kevin formally announces the public release of OpenClaw Enterprise as a vendor-neutral, open-source control plane for agent operations. Drawing an analogy to cloud-native infrastructure, he notes that just as Kubernetes standardized container orchestration, OCE is designed to serve as the standard management and deployment platform for autonomous AI agents. Originally incubated internally at OpenAI, OCE was donated to the OpenClaw Foundation early in development and expanded in collaboration with enterprise partners, including Red Hat and NVIDIA. Kevin invites developers to adopt the platform, test edge cases, and help shape secure agent runtimes moving forward.

Peter returns to close the session, tying the release back to the core themes of the presentation: - **Codex Foundation:** OpenClaw relies fundamentally on Codex under the hood because Codex is open source, paired with expanded access programs for open-source maintainers. - **Patch the Planet:** Collaborative security initiatives with organizations like Trail of Bits leverage AI agents to systematically eliminate entire classes of software vulnerabilities across critical open-source infrastructure. - **Community Collaboration:** Peter encourages attendees deploying shared agent workflows in production teams—particularly at larger organizational scales—to connect with the team after the presentation to exchange insights on what patterns are succeeding and where friction remains.

## Notable quotes > [00:31](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=31s) smash escape to steer the agent

> [00:31](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=31s) like a jet engine

> [04:47](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=287s) You get the tokens and we get a little bit of your ideas.

> [04:47](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=287s) close the gates

> [09:10](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=550s) My cortisol level would go up. It's like, who did this? Like, why? What did Victor do? And maybe in the past, I would have dropped him a not very Californian message. But now, I can click on the work session and I can just check out what he did, right?

> [13:52](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=832s) make this blue

> [15:33](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=933s) you have to have fun when you build. That's the whole point if you want to do good work.

> [17:48](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1068s) if you're still stuck in the CLI, it's time to upgrade. You're stuck in 2025.

> [27:31](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1651s) This is a hard Pictionary game. I don't know what that is — Kevin Lin

> [27:31](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1651s) Cooper, can you add a heat map of token usage per agent to the dashboard? — Kevin Lin

> [27:31](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1651s) Make sure dashboard has custom color palettes. I mean the web console. — Kevin Lin

> [27:31](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1651s) Hi, Fred. What are we launching today? — Kevin Lin

> [27:31](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1651s) Fred, please do better next time. — Kevin Lin

## Mentioned ClawLabs, OpenAI, Codex, Codex Desktop, DevBoxes, VNC, Frank Allenby, OpenClaw, OpenClaw Foundation, ChatGPT, PartyClaw, Lily Lane, Frogger, Kevin, Dots, Roboclaw, Victor, GitHub Actions, The Daily Claw, Discord, Luna, GPT Live, X, GitHub, SQLite, Computer-Using Agent, Kevin Lin, Peter, OpenClaw Enterprise, Fred, Linear, Slack, Cooper, Kubernetes, Red Hat, NVIDIA, Trail of Bits

## Video description See how agents help small open-source teams build together. Explore workflows for sharing context across projects and working with contributors, with live demos of cloud sessions and computer use.

[Source](https://www.youtube.com/watch?v=wZYnJfL4c2Y)

中文简报

OpenAI开源OpenClaw Enterprise以编排智能体集群 自主软件工程需要共享的多人环境和严格的安全边界，以消除局限于终端的私有智能体对话中存在的人类瓶颈。 本次演讲探讨了开发者智能体治理工具的演进历程，从人类充当单线程“肉身代理”的隔离CLI配置，发展到支持共享、多用户智能体协作的开源平台OpenClaw。演讲者Peter和Kevin Lin现场展示了多人智能体画布、被称为“果冻软件”（jellyware）的可塑性内部仪表板、支持语音的会议智能体，以及能够自动分拣、复现和修补错误的持续后台循环。Kevin Lin正式宣布开源OpenClaw Enterprise（OCE），这是一个由非营利组织OpenClaw基金会管理的智能体控制平面，通过实现工作负载隔离、沙盒机制和自动审查安全防护，以大规模编排自主智能体。 OpenClaw由独立的非营利机构OpenClaw基金会在OpenAI的支持下进行管理，它推动AI开发从孤立的单开发者会话转向持久的多用户协作运行时。 (3:18) OpenAI正式开源了OpenClaw Enterprise（OCE），这是一个与Red Hat和NVIDIA联合开发的中立厂商控制平面，为自主智能体提供Kubernetes风格的治理、工作负载隔离和沙盒机制。 (32:49) OpenAI将其内部部署扩展至400多个持续运行的自主智能体，用于分拣错误报告、在隔离环境中复现问题、合成补丁并合并拉取请求（PR）。 (24:34) 目标驱动的“/goal”指令展现了长达数周的持续自主性，在未破坏代码库的情况下完成了一项为期18天的异步数据库迁移，并合入了超过100个拉取请求。 (21:30)

Reading summary

At DevDay 2026, ClawLabs presenters argued that software engineering with AI is shifting from isolated, terminal-bound developers to collaborative multi-user runtimes and autonomous agent loops. To support this transition, the team introduced OpenClaw and open-sourced OpenClaw Enterprise as a secure, vendor-neutral control plane for persistent agents. Breaking the Meat Proxy Bottleneck (0:31) Early agent workflows relied on split command-line terminals where developers manually interrupted and steered models. While Codex Desktop and remote cloud DevBoxes reduced local hardware constraints like disk usage and overheating, they created a team-level operational chokepoint: the human 'meat proxy.' As defined by Frank Allenby, this pattern occurs when an individual developer spends their time manually shuttling prompts and outputs between teammates and isolated agent instances, obscuring the reasoning behind code changes. Collaborative Runtimes and Transparent Workspaces (3:18) Stewarded by the independent nonprofit OpenClaw Foundation with OpenAI support, OpenClaw replaces asynchronous pull requests with shared, live agent canvases. Multiple team members can steer execution concurrently via voice or text, inspect live prompts, and interact with running deployments in real time. Although engineers initially hesitated to share raw prompts due to feeling scrutinized, defaulting to full visibility reduced friction during code reviews by contextualizing why code was generated. The platform also fosters malleable internal artifacts dubbed 'jellyware'—such as on-the-fly dashboards, automated daily summaries, and code-inflation gauges—that teams generate and tweak instantly through natural-language instructions. Building the Software Factory with Loops and Goals (19:32) Presenters outlined an architectural model where human developers supply high-level 'taste' and direction, while background agent processes automate continuous maintenance. These processes are divided into indefinite 'loops'—such as performance trackers and automated issue-resolution pipelines that stream bug reports from Discord, X, and GitHub to reproduce and patch issues—and finite objectives termed 'goals' (`/goal`). In one cited case, a goal ran autonomously on Codex for 18 days to migrate a backend from synchronous SQLite to an asynchronous abstraction layer across more than 100 merged pull requests without breaking the codebase. Enterprise Security and Multi-Tenant Control (24:34) To address deployment, configuration, and governance risks across large organizations, OpenClaw Enterprise (OCE) was open-sourced as a multi-tenant control plane. Kevin Lin outlined four foundational security principles: isolating deterministic execution into separate clusters away from agent runtimes, sandboxing permissions over files and networks, inserting independent auto-review models before executing sensitive actions, and assigning agents dedicated service accounts instead of human credentials. According to Lin, these safeguards allow OpenAI to run more than 400 internal agents around the clock to triage issues, run experiments, and submit patches. OpenClaw Enterprise has been donated to the OpenClaw Foundation and developed alongside partners like Red Hat and NVIDIA, aiming to serve as an orchestration standard for AI agents analogous to Kubernetes for containers. Presenters acknowledged that managing agent-driven development at scale remains an evolving challenge, inviting the open-source community to test operational edge cases and refine security boundaries.

Detailed notes — zh

## Background 该视频由 OpenAI 于 2026 年 10 月 9 日在 YouTube 平台发布，记录了 DevDay 2026 的演讲环节。视频简介指出，本次分享聚焦于智能体（Agent）如何协助小型开源团队高效协同，展示了跨项目共享上下文和贡献者协作的工作流，并包含了云端会话与电脑使用（computer use）的实时现场演示。 ## TL;DR 演讲回顾了团队从单机 CLI 终端演进至云端 DevBox，再到打破“血肉代理”瓶颈、用 OpenClaw 构建 OpenClaw 自身的心路历程。团队提出以透明的共享 Agent 会话替代传统陈旧的 PR 机制，并展示了包含代码废话计、实时语音参会及自治循环（Loops 与 Goals）在内的协作空间与“果冻件（Jellyware）”生态。随后，负责人 Kevin Lin 正式发布并开源了企业级控制平面 OpenClaw Enterprise（OCE），详细拆解了硬边界沙箱、Auto-Review 等四大安全支柱，并实机演示了社区智能体 Fred 与工程智能体 Cooper。最后，讲者总结了开源 Codex 与“Patch the Planet”安全修复计划，呼吁业界共建中立、安全的智能体软件工厂底座。 ## Atmosphere & style 整场演讲洋溢着硬核极客与前沿开发者大会特有的兴奋感，语调轻松幽默却充满技术张力。讲者们用“血肉代理”、“代码废话计”和“果冻件”等生动自嘲的名词引发全场共鸣，现场联机改游戏和实时下发任务的互动让演示充满临场感与不确定性的趣味。随着 OpenClaw Enterprise 正式开源及安全治理框架的铺开，情绪逐步收拢升华，传递出一种对未来软件工程范式被彻底重塑的笃定与野心。 ## Bulletin - [24:34](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1474s) OpenAI 宣布正式开源面向持久化智能体的控制平面 OpenClaw Enterprise（OCE），提供多租户支持、硬件级隔离与基于模型的自动审查，旨在确立智能体生产级部署的底座标准。 - [02:23](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=143s) 开发协作范式正从传统的异步 Git PR 审查跃迁至多人共享 Agent 会话（Multiplayer），使团队成员可直接介入彼此的会话调试，彻底终结信息中介“血肉代理”（Meat Proxy）的孤岛困境。 - [19:32](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1172s) 团队提出了由持续监听循环（Loop）与长期目标（Goal）构成的自治软件工厂架构，已实现自动捕获并修复杂项异常，以及耗时 18 天、自动化落地逾 100 个 PR 的数据库架构迁移。 - [33:45](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=2025s) OpenAI 内部目前已常态化运行超 400 个 Claw 实例执行工程与安全任务，并联合 Trail of Bits 启动“Patch the Planet”计划，借助开源生态系统性根除开源软件安全漏洞。 ## Key takeaways - [00:31](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=31s) 从纯终端 CLI 到 Codex 桌面端的大并发工作流虽然降低了交互门槛，但单机算力与磁盘迅速过载，倒逼开发环境全面迁移至多台云端 DevBox 与自动化跑测集群。 - [02:23](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=143s) 传统单兵作战的 Agent 交互模式使工程师沦为在队友与 AI 之间搬运信息的“血肉代理”（Meat Proxy），OpenClaw 旨在通过多端协同的持久化 Agent 会话打破这一隔离局面。 - [07:10](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=430s) 在智能体极速生成代码的时代，异步代码 PR 审查机制已显迟滞，团队内部正转向允许多人实时观察、甚至直接输入 Prompt 协同干预的“Multiplayer”工作流。 - [09:10](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=550s) 强制公开团队所有与 Agent 的交互记录可打破 Prompt 隐形壁垒，不仅便于全员共享提示词技巧，还能直接还原代码改动的真实意图（Why），消除协作误解与沟通内耗。 - [13:08](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=788s) 经由 Agent 会话产出并通过自然语言实时高频微调的轻量级工具呈现出极强的灵活性，传统“软件”概念已演进为更加柔软可塑的“果冻件”（Jellyware）。 - [15:35](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=935s) 团队将 The Daily Claw 新闻排版、代码废话计（Slop Meter）及集成 GPT Live 语音的会议助手深度整合进统一服务器身份，替代了零散分布的第三方 SaaS 服务。 - [17:48](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1068s) 纯命令行终端已无法承载现代 Agent 的多维交互与协作需求，新一代可视化工作台能够完整回溯决策链路并支持多人同屏介入调试。 - [19:32](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1172s) 软件工厂依赖持续运行机制的分工：持续监听型 Loop 负责从多渠道捕获异常并在沙盒中闭环修复，而目标导向型 Goal 则负责拆解执行周期长达数周的基础设施重构。 - [24:34](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1474s) OpenClaw Enterprise 建立了四大企业级安全支柱：可信工作负载硬隔离、最小权限沙箱、基于模型的实时自动审查（Auto-Review）以及独立的持久化服务账号身份。 - [27:32](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1652s) 在大规模工程验证中，OpenAI 内部大部分 Codex Issue 已由内部 OpenClaw 实例独立完成分拣、沙盒复现与端到端代码合入。 - [27:32](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1652s) 企业级预设包（Presets）支持对 Slack、Linear 等第三方工具施加只读或人工审批流等细粒度约束，使多源检索与工具调用在严格受控的前提下运行。 - [31:06](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1866s) OpenClaw Enterprise 保持中立与非营利治理，项目已捐赠给 OpenClaw 基金会并联合红帽与英伟达共建，致力于打造智能体生产级部署的核心基石。 ## Detailed walkthrough ### [00:31](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=31s) 从 CLI 终端到桌面端：个人 Agent 工作流的演进与算力瓶颈 讲者回顾了过去一年中维护开源项目的心路历程，特别是将 OpenClaw 的开发迁移至 OpenClaw（简称 OC）自身平台上的全过程。整场变革最初始于命令行（CLI）：一年前，开发完全依赖终端环境，分屏运行大量 Codex 会话，代码在各个窗口之间穿梭。然而随着底层模型能力的快速跃迁，模型越来越聪明，开发者不再需要频繁狂按“Esc”键去打断和纠偏 Agent，这使得旧有的交互范式逐渐失效，工作流亟待革新。 随后，开发环境迁移至 Codex Desktop（桌面端）。桌面端大幅降低了并发开启大量会话的门槛，文本更易阅读，并且内置了可视化界面、内联浏览器（inline browser）以及便捷的代码审查工具。但这一进化迅速引发了本地硬件的危机——随着并发实验的大量运行，本地电脑不堪重负，磁盘空间告罄，风扇轰鸣如喷气发动机。为了分流负载，讲者开始将 Codex 连接到云端 DevBox，并构建了在云端跑测试的 Grabbox。在高峰期，甚至有 6 到 10 台云端机器（部分通过 Codex 连接，部分通过 VNC 远程桌面）日夜不停地处理代码和实验。 ```mermaid flowchart TD accTitle: 工作流演进历程 accDescr: 展示从单机终端分屏到多机云端扩展再到团队协作卡点的演化过程 subgraph Phase1["阶段一：单机本地"] CLI["CLI 终端分屏<br/>频繁按 Esc 纠偏"] --> Desktop["Codex Desktop<br/>并发会话 / 内联浏览器 / 可视化"] end subgraph Phase2["阶段二：分布式扩展"] Desktop --> DevBox["连接多台云端 DevBox"] DevBox --> Grabbox["Grabbox 云端自动化跑测<br/>(6-10 台机器并行处理)"] end subgraph Phase3["阶段三：遇到天花板"] Grabbox --> Bottleneck["团队协作瓶颈：沦为 'Meat Proxy'<br/>队友无法直接参与，信息隔绝"] end ``` --- ### [02:23](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=143s) 破除“血肉代理”（Meat Proxy）：OpenClaw 的开源使命 尽管堆叠了大量云端机器，讲者却遭遇了一个仅靠增加硬件无法解决的核心痛点：团队成员一旦想要介入，依然必须通过讲者本人。每个人都在单独与 Agent 协作，团队内部却处于割裂状态。Frank Allenby 在年内创造了一个生动的词汇——“血肉代理”（Meat Proxy）。当一名开发者成为人肉接口、在人类队友和 AI 之间来回搬运信息与 Prompt 时，他就沦为了“血肉代理”。 为了让团队成员能够直观看到 Agent 的工作过程、理解其决策路径并共同推展项目，团队开始探索用 OpenClaw 构建 OpenClaw 自身。OpenClaw 是一个面向持久化 Agent（persistent agents）的开源平台，能够跨工具、跨设备和跨团队运行。用户不仅可以通过订阅登录，平台还新增了“Sign in with ChatGPT”快捷登录方式，能自动挂载各类插件，并无缝同步查看个人的 Codex 会话。在治理架构上，OpenClaw 由独立的非营利机构 OpenClaw Foundation 拥有，并获得 OpenAI 的赞助支持。讲者团队的核心使命是探索实用级 Agent 的设计与规模化部署，探寻其如何改善工作生活，并最终勾勒出自动化软件工程师（Automated Software Engineer）的终极形态。讲者指出：“模型的发展如此迅猛，以至于我们的工作方式和配套 Harness 完全赶不上。一年前甚至半年前合理的工作流，如今已经显得处处受限且陈旧过时。” - **OpenClaw 核心特性**：跨工具、跨硬件设备协同，多团队共享会话状态。 - **生态集成**：支持 ChatGPT 授权登录，直接拉取已有插件配置与 Codex 会话。 - **开源中立性**：归属于独立的 OpenClaw 基金会，坚持中立与非营利属性。 --- ### [04:40](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=280s) 现场多人演示：PartyClaw 与 Frogger 游戏改造 讲者进行了现场实时演示，唤醒了名为“PartyClaw”的协作 Agent，展示语音交互与极速生成能力。讲者发出指令，要求构建一款类似经典街机“青蛙过河”（Frogger）的小游戏。在传统开发流程中，通常是 Agent 默默生成代码并提一个 Pull Request（PR），开发者再将 PR 拉到本地 Codex 逐步修改；而在 OpenClaw 中，协作节奏被彻底重构。 Agent 迅速识别出游戏原型并定位到一个名为“Lily Lane”的既有版本。原来团队成员 Kevin 早已提前用超快速度完成了基础框架。讲者在现场尝试玩了一局，随后当众提议将游戏主角从青蛙改成龙虾（Lobster）。此时后台多名协作者已经在同步敲入指令，讲者抢先一步发出了“修改为龙虾”的 Prompt。在等待游戏更新的间隙，讲者还向 PartyClaw 抛出并行任务：针对 OpenAI DevDay 2026 Keynote 中发布的最新特性汇总，生成一个结构化的展示仪表盘（Dashboard）。 --- ### [07:10](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=430s) 多人协作“Multiplayer”工作流：从 PR 机制跃迁到共享 Agent 会话 为进一步展示协同效应，讲者放出了访问链接，邀请现场观众加入服务器一起“联机做游戏”。讲者阐述了这套体系的设计哲学：开源项目历来习惯以 Git Pull Request 为核心进行协作，但在高度 Agent 化的时代，PR 机制已经显得陈旧且效率低下。在 OpenClaw 的共享服务器上，每个团队成员都可以实时查看他人的会话，甚至直接向彼此的会话输入 Prompt 进行干预与协助。 这种模式天然适用于互相信任的紧密团队。未来 OpenClaw 计划将这套多端协作体系开放给核心社区贡献者，建立“项目方提供算力 Token，贡献者贡献创意与代码”的高效合作机制。伴随着大量观众涌入，后台游戏被迅速改造成由龙虾与鲨鱼构成的海底冒险，火爆程度甚至让讲者开玩笑喊着“快把大门关上，人太多了”。 - **协作范式变革**：由异步离线的“代码 PR 审查”，转向实时的“多人多 Prompt 协同会话”。 - **贡献者激励模式**：官方分发会话 Token，外部开发者直接远程参与核心模块构建。 - **访问控制提醒**：共享模式具有完全平等的干预权限，目前主要针对互信团队与核心贡献者。 --- ### [09:10](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=550s) 告别 Prompt 隐形壁垒：透明化会话消除团队摩擦 几秒钟内，一句简单的 Prompt 就能生成成千上万行代码，但这些催生代码的背后对话，过去往往被锁死在各个工程师的本地电脑上。讲者在日常代码审查中，常陷入“知道改动了什么，却完全不知道为什么改”的困境，甚至不得不去主动追问：“把你的 Prompt 拿出来给我看”。讲者曾尝试编写工具，要求开发者将清洗后的脱敏对话记录附加在 PR 中，但几乎无人愿意配合——因为向别人展示自己与 Agent 的私密交互过程，会产生极强的被窥视感和心理负担，连讲者自己有时也本能抗拒。 几个月前，团队打破了这一禁忌，强制在内部将所有 Agent 会话完全透明公开。起初大家围观彼此的对话记录确实会感到一两天的尴尬，但随后便迅速习惯并显现出巨大收益：团队不仅能互相学习与 Agent 沟通的高效 Prompt 技巧，还能极早发现错误假设。这与现场发布的 Dots 等企业级官方集成相得益彰，而 OpenClaw 则赋予了社区自由切换模型、魔改源码以及全私有化部署的权力。 讲者现场展示了这一模式消除误解的实例：某天清晨没喝咖啡、睡眼惺忪时，讲者收到了来自机器助手 Roboclaw 的 PR，发现前端表格样式被人改小了；而就在前一天，讲者本人才刚把它改大。如果换在过去，讲者体内的皮质醇（压力荷尔蒙）必然飙升，可能立刻会发去一条充满火药味的信息质问：“这到底是谁干的？Victor 究竟在搞什么？”但在透明机制下，讲者直接点击嵌入在 PR 里的工作会话链接，瞬间查明真相——原来 Victor 是直接复用了讲者之前的会话，并附带了改动逻辑的上下文，甚至此前还专门发了提醒邮件。翻看会话不仅还原了上下文，还看到 Victor 在对话中吐槽持续集成（CI）耗时过长，进而引出了当前开发流程与 Agent 速度脱节的下一个深层矛盾。 | 对比维度 | 传统协作流（旧范式） | OpenClaw 多人协同（新范式） | |:--- |:--- |:--- | | **沟通中介** | 依赖单个开发者作为“血肉代理”（Meat Proxy） | 全员直面持久化 Agent，直接观测与调试 | | **PR 审查** | 仅看到 Git Diff 代码结果，缺失设计意图（Why） | 关联原始 Prompt 与完整上下文会话记录 | | **冲突处理** | 提交后才发现逻辑相左，容易产生团队情绪内耗 | 实时围观彼此会话，尽早拦截错误假设与重复劳动 | | **知识沉淀** | Prompt 技巧与调试经验孤立于个人本地终端 | 团队公开互相学习提问方式，全员共享最佳实践 | ### [13:08](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=788s) 智能 CI 设想与团队服务器：从“软件”到“果冻件（Jellyware）” 讲者反思了当前的持续集成（CI）体系，直言它在当前技术环境下已经逐渐失效，无法跟上日常开发的需求节奏。他正在探索使用 Codex 引入智能化能力，让 AI 来智能判定哪些测试子集是真正必要且有用的，不过他认为这是一个值得单独做一场演讲的深入话题。随后讲者翻看代码记录，发现队友 Victor 实际上投入了大量精力，“直接拿走我的工作并把我写烂的东西全修好了”，成功化解了一场午餐危机。 由此，讲者带领观众参观团队的服务器环境。他们不再将服务器视作单纯的应用程序，而是当成一个协作空间（a place）。做项目绝不仅仅是写代码，因此侧边栏中集成了许多自研的小程序、仪表盘和插件。在过去，这些工具零散分布在不同的服务器、GitHub Actions 工作流、独立数据库和各个代码库中，不仅难以维护，甚至连团队内部都记不清到底有哪些工具。讲者展示了一个用于监控 CI 耗时的仪表盘，并戏称只要给智能体下指令“把它改成蓝色”，智能体就会毫无怨言地自动调整。 对于这些轻量级工具，讲者给出了一个独特的哲学定义：大多数仪表盘本质上只是一个运行会话生成了某种产物（Artifact），外加一个自动定时更新该会话的自动化流程，产物本身包含代码，因此算得上是软件。然而，在如今以极快速度反复迭代的节奏下，硬梆梆的“软件（software）”概念已不再贴切，讲者更喜欢称之为灵活柔软的“果冻件（jellyware）”。 ```mermaid flowchart LR accTitle: 果冻件生成与迭代架构 accDescr: 展示自动化会话如何生成包含代码的产物并由智能体通过自然语言指令快速迭代修改。 subgraph S1["核心生成逻辑"] A["运行会话 Session"] --> B["生成产物 Artifact (内含代码)"] C["自动化调度 Automation"] -->|"定期更新"| A end subgraph S2["动态迭代反馈"] D["开发者自然语言指令"] -->|"例如: 改成蓝色"| E["Codex 智能体"] E -->|"实时就地重写"| B end ``` ### [15:35](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=935s) 团队协作空间中的插件生态：从 Daily Claw 到语音智能体 讲者继续演示侧边栏中的各种插件与工具。团队对社区生态的各项指标进行图表化跟踪，包括拉取请求（PR）数量、Issue 提交量以及合入量等。除了正经的统计，团队还会做一些好玩甚至带点恶搞的尝试，比如名为“The Daily Claw”的日报工具，它会汇总当天服务器上合入的所有代码并自动编排成一份“报纸”——虽然经常会解读失误，但为日常开发增添了不可或缺的乐趣。为了应对 AI 生成代码失控膨胀的通病，讲者还特意制作了一个“代码废话计（Slop Meter）”，时刻提醒并敦促智能体主动精简、重构代码，切实改善了代码库质量。 在团队报表页面，讲者不仅跟踪大家的开发活跃度（如提交频率），还记录 Discord 里的沟通活跃度。谈到会议系统时，讲者坦言团队过去曾为专业的会议总结软件付费，后来意识到“这本质上不就是一个 Prompt 吗？”，便自己基于 Luna 模型做了一个 Prompt 工具，在 Discord 开会时由智能体自动加入并实时转录总结。更进一步的是，通过接入 GPT Live 实时语音，智能体如今已经能直接在会议中开口对话，开发者可以随时向它询问工作进展或派发新任务；因为它是代表整个服务器、共享主会话上下文的同一身份，协作体验极为无缝。 - **The Daily Claw**：自动聚合团队代码合并动态并排版成新闻日报，兼具信息同步与团队娱乐功能。 - **Slop Meter（代码废话计）**：可视化监控 AI 生成代码冗余程度，倒逼模型精简代码结构。 - **自研会议插件**：替代第三方付费 SaaS，利用 Luna 进行会议转录，并可通过 GPT Live 参与团队语音讨论。 ### [17:48](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1068s) 实时透明的协作流与超越命令行的新一代工作台 讲者切换到团队成员实时动态视图，查看 Victor 的当前进度。Victor 早上调侃了讲者之前搭的成员在线列表侧边栏太丑，并着手重写。在系统界面中，讲者可以完整回溯 Victor 与智能体交互的工作流：Victor 采用了极为多样的设计迭代策略，甚至为了微调界面而让智能体临时搭了一套完整的编辑器；当遇到瓶颈时，另一位同事无缝加入会话共同调试，最终敲定了满意的方案。 讲者强调，这类可视化协作流不仅存在于这套网页系统里，在 Codex 官方应用中也同样完整支持。他半开玩笑地呼吁开发者：如果到了 2026 年还在纯命令行（CLI）终端里跟智能体死磕，或者还在视频通话里给别人共享终端屏幕，那就是“被困在 2025 年了”，是时候升级到更先进、可视化的协作工作台。 ### [19:32](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1172s) 自治软件工厂：持续运行的 Loop 与目标导向的 Goal 讲者分享了更深远的愿景——打造能自主构建软件的智能体，即通往“软件工厂（Software Factory）”的演进路径。开发模式不仅包含人与智能体结对编程的高强度交互，更依赖后台大量持续运行的循环任务（Loops）。这些循环原本分散在讲者各台本地机器上，用于监听反馈并自动修复问题，但随着数量增多，不仅机器间的同步和维护变得混乱，更关键的是——“审美与品味（Taste）”是极难向智能体准确传授的主观感觉，不能完全放权。因此，团队逐步将分散的本地循环统一部署到团队服务器上集中治理。 系统明确区分了“循环（Loop）”与“目标（Goal）”两套自动化机制： - **循环（Loop）**：无休止的持续监听任务。例如监控 Discord、Twitter 和 GitHub 动态的小型 CLI；智能体捕获异常后，会在测试沙盒中复现错误、生成补丁，再交由另一个评审智能体校验并自动落地（Land）。团队每日发布版本后，更新循环也会自动截屏比对性能退化。 - **目标（Goal）**：具有明确终止状态的长期任务。例如讲者正在执行的架构演进目标——将代码库底层从同步 SQLite 平滑迁移至异步数据库访问。该任务在本地 Codex 上持续跑了 18 天，期间自动拆分并合入了超过 100 个 PR。 讲者的长远构想是为每个软件项目配备一个专属智能体，拥有独立的记忆上下文、自动化规则、目标列表与监听循环，开发者只需下达高级指令，智能体即可自主完成软件的终身维护与升级。 ```mermaid flowchart TD accTitle: 软件工厂中 Loop 与 Goal 的运行机制 accDescr: 对比展示持续监听型 Loop 修复流程与目标导向型 Goal 渐进式架构迁移的执行差异。 subgraph LP["持续监听机制: Loop (以 Bug 修复为例)"] L1["CLI 扫描多渠道 (Discord / X / GitHub)"] --> L2["分类异常并启动测试沙盒复现"] L2 --> L3["生成修复代码并通过自动化验证"] L3 --> L4["独立评审智能体 Review 并合入主干"] end subgraph GL["终止状态驱动: Goal (以数据库迁移为例)"] G1["设定最终目标 (如: 同步 SQLite 转异步访问)"] --> G2["拆解微小改造步骤"] G2 --> G3["连续运行 18 天 / 自动落地 100+ PR"] end ``` ### [22:42](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1362s) 现场互动体验与企业级控制平面的开源发布 讲者查看了现场观众在刚刚开放的在线环境中的体验情况。大家在平台中迅速构建了诸如发布雷达（Release Radar）、岛屿建造游戏（Island Builder）以及与 Claw 玩看图猜词（Pictionary with the Claw）等轻量级互动应用。讲者指出，由于平台深度集成了电脑使用（Computer Use / CUA）能力，智能体自己玩这些图形游戏甚至比人类还要熟练。未能抢到线上体验资格的观众也可以直接下载源码并一键在自己的服务器上部署，全面兼容 Codex 订阅。 最后，讲者将话题从小型团队的协作痛点引化到组织级规模：随着越来越多团队开始拥抱多智能体架构，如何在企业全局范围内实现智能体的统一部署、安全合规与权限配置，成了必须解决的严峻挑战。为此，团队研发了一整套企业级控制平面（Enterprise Control Plane），并在此正式宣布将其完全开源。 ### [24:34](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1474s) 推出 OpenClaw Enterprise：面向智能体的开源控制平面与安全底座 Kevin Lin（OpenAI 的 OpenClaw Enterprise 负责人）登台介绍了团队最新构建的核心基础设施——OpenClaw Enterprise（简称 OCE）。Kevin 指出，OCE 为 OpenClaw 引入了开源的控制平面（Control Plane），使其不仅具备多租户（Multi-tenant）支持，还为各类智能体（Agent）部署引入了严格的治理体系与硬件级安全边界。团队坚信，只有建立起极其坚固的安全运行时（Secure Runtime），像 OpenClaw 和 dots 这样具有持久化生命周期的智能体才能真正走向大规模普及。 ```mermaid flowchart TD accTitle: OpenClaw Enterprise 安全防护体系架构 accDescr: 展示 OCE 包含的四个核心安全防御层级 subgraph Boundaries["硬隔离与沙箱"] A["确定性工作负载<br/>(独立容器/集群)"] -.->|硬边界隔离| B["智能体执行环境<br/>(防止篡改运行时)"] B --> C["细粒度沙箱控制<br/>(网络/文件读写/代码库推送限制)"] end subgraph SecurityAudit["模型审查与独立身份"] C --> D["Auto-Review 模型审查<br/>(阻断高风险操作)"] D --> E["独立持久实体与服务账号<br/>(可审计/独立关闭，杜绝冒用用户)"] end ``` Kevin 详细拆解了平台内置的四大安全支柱机制： 1. **可信与不可信工作负载的硬边界隔离**：确定性代码与智能体执行环境完全剥离，运行在独立的容器甚至完全不同的集群中，杜绝智能体擅自修改自身底层运行时的可能性。 2. **严格的沙箱（Sandboxing）限制**：精准控制智能体的网络出入权限、可写入的文件范围以及能够推送的代码仓库。这种最小权限设计让智能体能够使用各种强大的工具，而不会暴露整个系统权限。 3. **基于模型的自动审查（Model-Based Reviews）**：在基础控制之上叠加了 Codex 和 OpenClaw 均内置的 Auto-Review 功能。系统会调用另一个模型实时审视智能体的拟执行动作，在潜在危险操作真正生效前直接予以拦截。 4. **独立的身份凭据与服务账号**：智能体不再冒用人类用户的身份，而是作为独立的持久化实体存在，分配专属的服务账号和可配置的连接器。这使得每个智能体都可以被独立控制、精细审计，并在必要时一键关停。 - 这套严密的安全控制体系支撑着 OpenAI 内部日常运行超过 400 个 Claws 实例，全天候执行代码修复、实验运行、数据分析以及安全风险上报。 --- ### [27:32](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1652s) 实机演示：现场配置社区智能体 Fred 与协作智能体 Cooper 为了展示 OCE 的实际能力，Kevin 在现场展开了实操演示。首先展示的是预设模板（Presets）功能——企业可以通过定义预设包，确保所有拉起的智能体默认遵循组织的安全最佳实践。Kevin 在控制台现场配置了一个名为“Fred”的社区智能体： - **运行框架**：挂载 Codex harness； - **身份认证**：分配专属的服务账号； - **代码库权限**：授予只读权限，确保其仅用于解答技术疑问； - **项目管理工具**：打通团队用于存放产品路线图的 Linear，但强制开启审批流——任何向 Linear 写入数据的操作都必须先经过人工团队批准； - **沟通平台**：绑定预先准备好的 Slack 应用与 Bot Token，并自动关联指定的频道。 ```mermaid flowchart LR accTitle: 多人实时协同操作智能体 Cooper accDescr: 展示人类工程师与智能体之间的交互及团队多端接入方式 Eng["工程师 (Kevin)"] -->|"自然语言提问与需求微调"| Cooper["Cooper 智能体<br/>(软件工程持久助手)"] Cooper -->|"生成仪表盘热力图 PR/代码"| Repo["代码库与 OCE Web 控制台"] Team["其他团队成员"] -.->|"共享认证 Session<br/>协同跟进/方向介入"| Cooper ``` 在等待 Fred 初始化的间隙，Kevin 将画面切换到 OpenAI 内部已经稳定运行的另一位全职“虚拟同事”——软件工程智能体 Cooper。Cooper 能够处理端到端的功能合并、Bug 修复和 Issue 分拣。由于当前的 OCE 控制台虽然实用但略显单调，Kevin 现场给 Cooper 下达任务：“Cooper，能否在仪表盘上为每个智能体添加一个 Token 使用量的热力图？”Kevin 补充道，这类软件智能体是 OpenAI 内部最受欢迎的形态；在过去一个月内提交给 Codex 的各类 Issue 中，很大一部分都是由内部的 OpenClaw 实例独立完成分拣、复现并最终端到端合并代码的。 此外，基于 Peter 之前提到的“未来工作多人协作（Multiplayer）”理念，OCE 部署的每个智能体都原生支持多人实时会话。Kevin 打开了直连 Cooper 团队服务器的已认证 Session，界面上清晰呈现了刚才的对话流。工程师不仅能在会话中进一步追加要求（例如补充强调“让 Web 控制台的仪表盘支持自定义调色板”），其他团队成员也能随时登入同一个会话，实时旁路围观或介入微调任务方向。 --- ### [31:06](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1866s) 跨工具上下文查询展示与 OpenClaw Enterprise 正式开源发布 随后，Kevin 回到已就绪的社区智能体 Fred 界面，测试其跨平台整合信息的能力。他在控制台中向 Fred 提问：“Hi Fred, what are we launching today?（Fred，我们今天发布了什么？）” 在后台，Fred 正在并发检索 Linear 看板任务、扫描 Slack 对话历史，并融合多源上下文来生成答案。尽管在现场演示中由于插件偶尔的小故障引发了些许波折，并打印出了一段 OpenClaw 发布说明，但 Fred 依然成功检索到了当天的核心 Linear Issue——发布 OCE。Kevin 笑着打趣说：“Fred，下次可得表现得更好一点啊。” 玩笑过后，Kevin 正式宣布：**OpenClaw Enterprise（OCE）今日正式向全球公开发布**。 - **定位**：一个中立、完全开源的智能体部署与管理平台。 - **行业愿景**：正如 Kubernetes 最终成为云原生容器编排的事实标准一样，OCE 旨在成为智能体生产级部署的核心基石。 - **治理与生态**：该项目最初孵化于 OpenAI 内部，在开发早期便已捐赠给 OpenClaw 基金会（OpenClaw Foundation），并与红帽（Red Hat）和英伟达（NVIDIA）等行业伙伴共同推进生态演进。团队呼吁社区共同测试并完善这套安全框架。 --- ### [33:45](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=2025s) 结语：开源生态、系统安全与“Patch the Planet”计划 Peter 重新回到演讲台对全场内容进行总结与呼应。他强调，OpenClaw 之所以能够灵活调用底层 Codex 的能力，根本原因在于 Codex 本身也是开源项目。为了让更多开发者触达先进 AI，团队近期大力拓展了 Codex 开源计划。 不仅如此，针对开源作为全球关键数字基础设施的现实，OpenAI 正在通过“Patch the Planet”计划与 Trail of Bits 等顶尖安全研究团队紧密携手，利用智能体系统性地消灭一整类开源软件安全漏洞。Peter 总结道：“这就是我们今天利用 OpenClaw 构建 OpenClaw 的方式。”最后，他热情邀请现场探索多智能体共享工作流的团队会后进行深度交流。 - **核心合作与安全举措**：联合 Trail of Bits 推进“Patch the Planet”，集中力量修复类漏洞。 - **技术闭环**：以开源的 Codex 为基础，结合 OCE 安全底座，实现“用智能体协助智能体开发”的正向循环。 ## Notable quotes > [02:23](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=143s) 模型的发展如此迅猛，以至于我们的工作方式和配套 Harness 完全赶不上。一年前甚至半年前合理的工作流，如今已经显得处处受限且陈旧过时。 > [13:08](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=788s) 把它改成蓝色 > [13:08](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=788s) 直接拿走我的工作并把我写烂的东西全修好了 > [15:35](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=935s) 这本质上不就是一个 Prompt 吗？ > [17:48](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1068s) 被困在 2025 年了 > [27:32](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1652s) Cooper，能否在仪表盘上为每个智能体添加一个 Token 使用量的热力图？ — Kevin Lin > [31:06](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1866s) Hi Fred, what are we launching today? — Kevin Lin > [31:06](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=1866s) Fred，下次可得表现得更好一点啊。 — Kevin Lin > [33:45](https://www.youtube.com/watch?v=wZYnJfL4c2Y&t=2025s) 这就是我们今天利用 OpenClaw 构建 OpenClaw 的方式。 — Peter ## Mentioned OpenAI, OpenClaw, Codex, Codex Desktop, DevBox, Grabbox, Frank Allenby, OpenClaw Foundation, ChatGPT, PartyClaw, Kevin, Dots, Roboclaw, Victor, The Daily Claw, Slop Meter, Luna, GPT Live, Discord, GitHub, Twitter, SQLite, OpenClaw Enterprise (OCE), Kevin Lin, Fred, Cooper, Linear, Slack, Kubernetes, Red Hat, NVIDIA, Trail of Bits, Patch the Planet, Peter ## Video description See how agents help small open-source teams build together. Explore workflows for sharing context across projects and working with contributors, with live demos of cloud sessions and computer use. [Source](https://www.youtube.com/watch?v=wZYnJfL4c2Y)

Source quotes

[2:23] 模型的发展如此迅猛，以至于我们的工作方式和配套 Harness 完全赶不上。一年前甚至半年前合理的工作流，如今已经显得处处受限且陈旧过时。 [13:08] 把它改成蓝色 [13:08] 直接拿走我的工作并把我写烂的东西全修好了 [15:35] 这本质上不就是一个 Prompt 吗？ [17:48] 被困在 2025 年了 [27:32] Kevin Lin: Cooper，能否在仪表盘上为每个智能体添加一个 Token 使用量的热力图？ [31:06] Kevin Lin: Hi Fred, what are we launching today? [31:06] Kevin Lin: Fred，下次可得表现得更好一点啊。 [33:45] Peter: 这就是我们今天利用 OpenClaw 构建 OpenClaw 的方式。

Source quotes

[0:31] smash escape to steer the agent [0:31] like a jet engine [4:47] You get the tokens and we get a little bit of your ideas. [4:47] close the gates [9:10] My cortisol level would go up. It's like, who did this? Like, why? What did Victor do? And maybe in the past, I would have dropped him a not very Californian message. But now, I can click on the work session and I can just check out what he did, right? [13:52] make this blue [15:33] you have to have fun when you build. That's the whole point if you want to do good work. [17:48] if you're still stuck in the CLI, it's time to upgrade. You're stuck in 2025. [27:31] Kevin Lin: This is a hard Pictionary game. I don't know what that is [27:31] Kevin Lin: Cooper, can you add a heat map of token usage per agent to the dashboard? [27:31] Kevin Lin: Make sure dashboard has custom color palettes. I mean the web console. [27:31] Kevin Lin: Hi, Fred. What are we launching today? [27:31] Kevin Lin: Fred, please do better next time.

Original transcript

[0:31] Let's talk, we have a really [0:33] exciting session today. [0:35] I'm going to show you what I [0:37] learned over the year maintaining [0:38] my open source projects, [0:40] how my workflows evolved, and what [0:43] happened when we moved development [0:45] of OpenClaw to OC itself. [0:50] Now, let's talk a little [0:52] bit about the harnesses we [0:53] use to talk to our agent. [0:54] This whole year, this whole [0:56] revolution started in the CLI. [0:59] Last year, I was fully [1:02] living in the terminal. [1:04] Split screen, [1:06] lots of Codex sessions, my code [1:08] was flying around left and right. [1:10] And then over time, the models [1:12] got better and smarter. [1:15] And the time where I had to smash [1:17] escape to steer the agent decreased. [1:20] It's not really needed anymore. [1:23] It was clear my workflow [1:25] needed a change. [1:27] Then I moved to Codex Desktop. [1:30] Now the chat should be there. [1:32] It made it far easier to start [1:34] a large number of sessions concurrently. [1:36] The text is easier to read. [1:38] It has visualization. [1:40] It has an inline browser. [1:41] It has really code review. [1:42] I don't even know. It's nice. [1:44] Now that it's so easy to run [1:47] all these sessions and experiments, [1:49] my machine was dying. [1:52] I ran out of disk space. [1:53] My fans sounded like a jet engine. [1:55] So I started using multiple [1:57] computers to run more work. [2:00] I connected [2:03] Codex to DevBoxes. [2:06] So I could spread the load. [2:07] And I built Grabboxes so agents [2:09] would run the tests in the cloud. [2:11] I think I'd peek ahead, [2:13] I don't know, six or ten machines [2:14] that were crunching through [2:15] all my code and my experiments. [2:18] Sometimes in one Codex [2:19] and sometimes they used VNC. [2:23] And then I realized that was a problem [2:24] all these machines [2:26] wouldn't solve. [2:28] When my teammates wanted [2:31] to get involved, they still [2:33] had to come through me. [2:35] You know, we were all working [2:37] with agents, but we weren't [2:38] really working together. [2:41] By the way, I love this slide. [2:43] It's like, that's how tokens look? [2:46] Frank Allenby, he coined [2:48] this term this year, meat proxy. [2:52] You know what I'm talking about. [2:57] Let's not be a meat proxy. [2:58] That's when you are the interface [3:00] to AI and you pass [3:02] messages back and forth. [3:07] So how does the rest [3:07] of the team get involved? [3:08] How do you see what it's [3:11] doing, understand the decisions, [3:13] and help move the work forward? [3:18] That's what we started [3:19] exploring as we began [3:20] using OC to build OC. [3:25] And for those of you who haven't [3:26] used it, OpenClaw is an open source [3:28] platform for persistent agents. [3:31] It works across your tools, [3:32] your devices, your teams. [3:34] You can sign in with your subscription. [3:37] There's now a fancy sign [3:38] in with ChatGPT button. [3:41] It picks up your plugins, and you [3:43] can even see your Codex sessions. [3:46] Also let's talk about governance. [3:49] OpenClaw is open source, [3:50] and it's owned by the OpenClaw [3:53] Foundation, an independent nonprofit. [3:56] And OpenAI generously [3:58] supports our mission. [4:01] My team at OpenAI explores how [4:03] to design agents that are useful, [4:06] how to run them at scale, [4:08] how they can help us improve both [4:10] our work and our personal lives. [4:12] And ultimately also how [4:15] an automated software [4:16] engineer could look like. [4:18] My thesis is [4:20] that the models are getting [4:22] so good so fast. [4:24] The way we work, [4:25] the way our harnesses work, [4:29] we just can't keep up. [4:31] Workflows that made sense a year ago, [4:34] or even six months ago, [4:36] already feel constrained and outdated. [4:38] Now, [4:40] part of my work is to explore [4:42] where things go. [4:44] Should we take a look? [4:47] You already saw that the demo [4:48] gods love us today. [4:50] So let's see if PartyClaw is online. [4:53] Hey PartyClaw, are you alive? [4:58] Well, [5:00] the voice translation works, [5:02] even though it's not perfect. [5:05] Perfect. [5:06] So, [5:07] I'm going to build a game. [5:09] You know what's this game called [5:10] where the frog has [5:13] to go over a street with cars? [5:16] Can you build it for me? [5:19] You know, [5:20] I mean, so far it's nothing new, right? [5:22] So far your agent would build this, [5:23] and eventually it will, like, [5:27] get you a pull request back. [5:29] And then you probably would, like, take [5:30] that pull request and, like, open it [5:32] in your Codex and keep working on it. [5:36] I think there's a better way. [5:38] Oh, yeah, Frogger. [5:39] Oh, I'm so silly. [5:40] It already found a version we can use. [5:43] Lily Lane. [5:44] Okay. [5:45] Who made Lily Lane? [5:46] Let's click on that. [5:50] Okay. [5:51] Well, damn. [5:52] I mean, I'm using ultrafast. [5:54] It is amazing. [5:55] But that was faster than ultrafast. [5:57] Who did that? [5:59] Okay, Kevin and my team already [6:00] built the game. [6:02] Oh, well, let's see if I can [6:06] make a joke out of myself on stage. [6:08] Will I manage? [6:10] Oof. [6:11] Whoop. [6:12] Whoop. [6:14] Oh, God. [6:14] You know, in all the demos, [6:16] I always, like, miss that. [6:19] But... Ah. [6:21] I don't really want [6:22] this to be a frog. [6:23] Can this be a lobster? [6:27] I don't know. [6:28] No! [6:28] See, I was faster. [6:29] You see all those people typing. [6:31] But, like, I did the first prompt. [6:32] Ha, ha, ha. [6:34] Should not be an elephant. [6:35] We'll do a lobster. [6:39] Ah. [6:40] Let's see how long that takes. [6:42] Well, while we wait, [6:43] there are so many cool things [6:44] that, like, [6:46] were in the keynote. [6:47] Hey, [6:49] I'm just at OpenAI DevDay here [6:50] and doing a workshop, and I think I [6:52] missed a little bit of the keynote. [6:53] What are all the cool things that OpenAI [6:55] released in DevDay 2026? [6:58] Can you make me a dashboard? [7:00] All right. [7:01] While it works, should we check [7:03] back on Frogger? [7:09] All right. [7:10] And I also see there's, like, [7:11] three people online. [7:13] That's not a lot of people. [7:15] Should we make this a bit more [7:16] of a party? [7:17] Yeah! [7:18] Okay. [7:21] I think I have to click the button. [7:25] So if you're very fast, you can, [7:27] like, use this URL and then [7:29] join me to make silly games. [7:34] What is it doing here? [7:36] So this is [7:39] designed for teams that all [7:40] have the same access. [7:42] Think about you doing [7:44] open source and you [7:46] want to work with a team. [7:47] And we used to have pull requests [7:48] to collaborate, but that just [7:50] feels not the future anymore. [7:54] So here on the server, anyone [7:56] can see each other session. [7:59] You can prompt each other session. [8:03] It's meant for people [8:05] that work together. [8:07] Don't invite anyone who you don't [8:09] want to mess with your sessions. [8:11] We're going to use this in the future [8:13] as we build OpenClaw to invite [8:16] some of our top contributors. [8:18] You know, like, you get the tokens and [8:19] we get a little bit of your ideas. [8:21] I think it's an amazing deal. [8:26] And this whole workshop, [8:28] this, like, idea, this is really [8:30] to, like, get you thinking. [8:31] Which other workflows do we currently do [8:34] in the old way that we could do [8:37] so much better in this agentic age? [8:41] Oh, I think my lobster game is ready. [8:44] Oh, it's lobsters and sharks now? [8:46] Okay. [8:48] Oh, it died. Damn it. [8:49] Well, while you all are having [8:50] fun here, and oh, my God, [8:53] how many people did we let in? [8:54] We need to close the gates, guys. [8:56] Yeah, you already see [8:57] that stuff's happening. [8:59] We're going to check back later on this. [9:02] Let's switch back to the slides. [9:10] So, you just saw us working [9:12] a little bit together on a game. [9:15] Now, we started experimenting [9:17] with how would multiplayer work [9:20] with agents a few months ago. [9:21] And it has changed [9:24] how we work as a team. [9:26] Not only has it increased velocity, [9:29] it also just made us happier. [9:31] You know, there's so many conflicts [9:32] that you can avoid if you [9:34] see each other's prompts. [9:37] And now it feels like we're [9:39] actually more working like a team. [9:42] And earlier today, [9:44] you saw dots, which is a really [9:46] cool first-party integration [9:48] of the OpenAI experience [9:51] for companies to work with agents. [9:54] OpenClaw explores some [9:55] of the same ideas. [9:56] Agents working alongside [9:58] a whole team of people. [10:02] OpenClaw gives you the freedom [10:03] to choose your model, [10:06] change the code, and you can fully [10:09] run it on your own infrastructure. [10:12] And I think we should celebrate that. [10:13] I love that OpenAI is supporting [10:15] all these different approaches. [10:16] And that the open source community [10:18] can take these ideas in directions [10:20] we haven't even imagined. [10:23] And of course, [10:25] we're really thinking about ways [10:26] how your dots can talk [10:27] to your claw and vice versa. [10:31] Now, one thing I didn't [10:33] talk about is your prompts. [10:35] A single sentence can now [10:38] produce thousands or tens [10:40] of thousands of lines of code. [10:43] But the conversation behind [10:44] it often stays [10:47] on someone's local machine. [10:50] I reviewed so many PRs where I [10:52] understood what changed, but not why. [10:56] You know, show me the prompt. [10:59] So I tried this. [11:01] I added a skill that asked [11:04] people to send a sanitized [11:07] version of the transcript [11:08] and attach it to the PR. [11:11] And very few said yes. [11:15] Sharing how you talk to your agent [11:18] feels surprisingly personal. [11:21] Heck, even I sometimes said no. [11:23] I don't know. You know? [11:24] So when we made sessions [11:26] visible to the whole team, [11:29] it did feel awkward for a day. [11:32] We were reading each [11:34] other's conversations. [11:36] We laughed a little. [11:37] And then it became the new normal. [11:39] And now we learn from each other. [11:43] And we catch mistakes earlier. [11:46] Let me show you how it looks like. [11:57] So, the demo gods [11:58] are still on our side. [12:00] And I imagine I wake up. [12:03] I didn't have my coffee yet. [12:04] And I see this pull [12:06] request from Roboclaw. [12:07] And I scroll through it. [12:11] And there, somebody changed how [12:13] tables look and made them smaller. [12:17] But I did the same work. [12:18] And I made them bigger just [12:19] the day before. [12:21] You know, like my cortisol [12:22] level would go up. [12:23] It's like, who did this? [12:24] Like, why? [12:25] What did Victor do? [12:27] And maybe in the past, [12:29] I would have dropped him a not [12:31] very Californian message. [12:35] But now, I can click [12:36] on the work session. [12:38] And I can just check [12:40] out what he did, right? [12:42] And it actually looks like [12:43] he reused my session. [12:46] Or he even pinged me. [12:47] I should read my emails more often. [12:51] I love this. [12:52] See this? [12:53] We were just talking about [12:55] how we talked to our agents. [12:56] And Victor clearly is not [12:58] happy about our CI times. [12:59] I could probably fill [13:00] a whole talk about just CI. [13:04] And that it's another point of like, [13:07] the way we currently work did not [13:08] catch up with all the things that we [13:11] now need in this new day and age. [13:13] And I think CI, as it currently [13:15] doesn't make any sense anymore. [13:16] I'm currently experimenting with Codex. [13:19] Maybe if we add intelligence, it could [13:22] be more easier to decide which subset [13:24] of the tests are actually useful. [13:25] But I feel that's a talk in itself [13:27] and maybe something for another day. [13:30] But if I keep scrolling up, [13:33] you know, it actually looks like Victor [13:35] put a lot of thought into it. [13:37] I was wrong. [13:38] This is actually really good. [13:40] He basically took my work [13:42] and then just fixed my stuff. [13:45] This is awesome. [13:47] You know? Lunchtime crisis averted. [13:52] Now, I give [13:53] you a little bit of a tour. [13:54] We see our server less like [13:57] an app but more like a place. [14:01] You know, there's a lot more [14:02] that goes on when you build a project. [14:05] It's not just about the code. [14:07] So naturally, we have a lot [14:09] of apps in the sidebar. [14:11] And some are dashboards [14:12] and some are plugins. [14:14] Of course, there's nothing new as well. [14:16] Like we used to have them. [14:17] They were just scattered around [14:18] on different servers. [14:21] Some used GitHub actions to update. [14:23] There were databases. [14:24] There were different repositories. [14:26] Like I didn't even [14:27] know which one we all had. [14:28] And clearly, it was not very inviting [14:30] for the team to work [14:32] on an update on these. [14:34] Like I give you a simple one. [14:35] Because we were just talking about CI. [14:41] So I made this dashboard that tracks [14:43] how our CI times are. [14:44] And clearly, clearly, we [14:46] need to do more work. [14:49] But the beauty is, any time I want [14:51] to tweak the dashboard, I can just tell [14:54] the agent, make this blue. [14:57] And it will not like me about this. [14:59] And then we'll just update [15:00] the dashboard as we go along. [15:02] Now, [15:04] what are most dashboards really? [15:06] It's like a session that generates [15:08] some artifact. [15:09] And then there's an automation [15:10] that updates that session. [15:13] And of course, [15:14] the artifact contains code. [15:16] So, it's software [15:18] in a way. [15:20] But there's a better word [15:22] now if you think about it. [15:25] We iterate so fast on things. [15:27] Is it still software or is it jellyware? [15:30] I like jellyware. [15:33] So let me show you [15:34] a few other things. [15:35] Of course, we have [15:36] the community. [15:41] Here we go. [15:41] We track all these numbers. [15:43] How many PRs do we have? [15:45] How many issues are reported? [15:46] How many are merged? [15:48] Some people are really into graphs. [15:51] We also do silly things on the server. [15:54] Like the daily Claw that tries [15:56] to make sense of all the things [15:57] that merge on the server. [15:59] And then makes a newspaper out of it. [16:01] And sometimes it's actually quite good. [16:03] But many times it's very wrong. [16:04] But it's just, you know, you [16:06] have to have fun when you build. [16:07] That's the whole point if you [16:09] want to do good work. [16:11] I also have a slop meter. [16:13] Because if you all work with agents, [16:15] you know, it's very easy to like [16:16] agents generate more and more [16:17] and more and more and more code [16:19] until you're like in a bad place. [16:21] So you should always like try [16:22] to push the agent to clean up. [16:27] And as you see, ever since [16:28] I started the dashboard, [16:30] I definitely raised awareness. [16:31] And things are moving [16:33] in the right direction. [16:35] Now these were all just HTML plugins. [16:37] We also have some that are actual code. [16:39] Like if you go on reports. [16:41] I'm a curious person. [16:43] So I always want to see how [16:45] busy is everyone. [16:46] And as you can see, [16:47] the activity, how many commits do they [16:50] do, how active they are on Discord. [16:56] Now we also built meetings. [16:58] And it looks like there's a meeting [16:59] in progress right now. [17:01] We used to have our own software [17:04] that we paid for until I was [17:05] like, why do we pay for this? [17:07] This is a prompt. [17:08] So we just made it a prompt. [17:10] It uses Luna to summarize [17:12] our transcripts. [17:14] And the agent just joins us [17:16] in Discord whenever we have a meeting. [17:19] And the coolest thing, [17:21] but I'm not going to show you [17:22] that today because we already angered [17:24] the demo gods with voice, [17:26] is our agent [17:29] can now talk back. [17:30] You know, like just taking notes. [17:32] That's nothing new. [17:33] But connect GPT Live. [17:35] And then you can actually ask the agent [17:37] about your work or spin off new work. [17:39] And because it's the same identity [17:41] that represents the server and the same [17:43] main session that knows everything. [17:44] This works really, really well. [17:48] Now, let's see who is actually online. [17:50] If I go down there a little bit. [17:52] I love this view. [17:54] And I'm always curious what [17:55] Victor is up to. [17:56] Because he usually takes [17:58] my code and makes it pretty. [18:01] So it looks like Victor is [18:03] working on some emoji stuff. [18:05] But I know he gave me [18:06] a shot this morning. [18:12] He told me that he [18:14] made the sidebar nicer. [18:15] Like I added this little view so you [18:17] could see who is online, who is running. [18:19] But it doesn't look very good. [18:21] So he told me he does it better. [18:25] And then let me scroll through. [18:27] And the cool part is you can [18:28] actually see how he works. [18:31] And just seeing how he [18:33] approaches his agents. [18:35] And sometimes he uses very [18:36] colourful language. [18:38] But he manages to squeeze out [18:40] so many different design iterations. [18:45] Let me scroll a little [18:46] bit more so you see. [18:48] Look at this. [18:48] He built whole editors [18:50] to tweak this. [18:52] And then he was still not happy. [18:54] I think it's very hard to please Victor. [18:56] Oh, and then somebody [18:57] else was joining in. [18:58] And then they were collaborating [19:00] together on this. [19:02] There's more versions. [19:04] I don't even know which one we updated. [19:06] But eventually, eventually [19:09] they found something that looks [19:10] very compelling. [19:12] And by the way, all these [19:13] visualizations, they work [19:14] in the Codex app as well. [19:16] So if you're still stuck [19:17] in the CLI, it's time to upgrade. [19:20] You're stuck in 2025. [19:23] Even better, I know [19:24] some companies that jump on [19:26] a video call with a terminal. [19:27] And then use that to talk [19:28] to your agent. [19:30] There's a better way. [19:32] Now, I want to give you a little [19:35] bit of the broader vision here. [19:39] Ultimately, what we are building [19:41] here is an agent [19:43] that builds our software. [19:46] This is kind of like the way [19:47] to the software factory. [19:50] And some of the work [19:51] has to be very hands-on. [19:54] You want to pair directly with an agent. [19:56] But I also run a lot of loops. [20:00] So I use them to monitor feedback [20:02] and then automatically land fixes. [20:06] And some of those loops [20:08] run on different machines. [20:09] And sometimes they stop [20:12] or they need adjustment. [20:13] And sometimes I wasn't even sure where [20:15] on all my machines they were. [20:19] Those loops need maintenance. [20:21] And also, [20:23] ultimately, where do [20:26] we still bring value? [20:27] It's about taste. [20:29] Taste is uniquely hard to describe. [20:31] It's often just a feeling. [20:35] And that's not something I want [20:37] to fully entrust on our agent. [20:39] So this didn't really [20:40] work well in the team. [20:41] Like, [20:42] I was running too many. [20:44] And slowly, one by one, we're moving [20:46] all these loops to our team server [20:48] so other people can learn. [20:49] Because ultimately, we maintain [20:51] the agent that builds our software. [20:55] Now, what types of loops do [20:57] we run and how does that work? [20:58] Like, I have a monitor [20:59] that scans Discord, [21:01] Twitter, and GitHub. [21:02] I built little CLIs. [21:03] So this is very easy for the agent [21:05] to get a lot of data. [21:06] And then we categorize them. [21:08] And for certain categories, [21:10] like update issues, [21:13] the agent will read [21:14] the report, will investigate. [21:16] It will spin up a new test [21:17] box to reproduce the error. [21:18] If it can clearly reproduce it, [21:20] it will come up with a fix. [21:22] It will see if it's fixed. [21:23] And if all of that works, [21:25] there's going to be another agent [21:26] that reviews that work. [21:27] And then your work can [21:28] automatically land. [21:30] Now, what's the difference [21:32] between a loop and a goal? [21:34] So the loop basically keeps checking. [21:37] This is something we do continuously. [21:38] I have another one for performance. [21:40] We do another release [21:42] of the team server every day. [21:43] And then my update loop will [21:45] detect that. [21:46] We'll take snapshots and we'll see [21:48] if there's anything that regressed [21:49] or it needs improvement. [21:52] Now, if I do, [21:54] you know, slash goal, [21:56] that work [21:59] is towards a defined end state. [22:02] Like right now, I have a goal [22:03] that slowly, bit by bit, migrates [22:05] the code base from synchronous SQLite [22:08] to async database access. [22:11] We're still using SQLite here, [22:12] but as the server grows and as [22:14] we do more, we're thinking about maybe [22:16] making the database itself swappable. [22:18] So this has been running for 18 days. [22:22] It's still running on my local [22:23] Codex and it has landed [22:24] over 100 PRs so far. [22:28] Over time, I want [22:30] an agent per project. [22:32] It should have its own memory, [22:34] automations, goals, loops, and I can [22:36] give it those high-level commands and it [22:38] maintains and improves my software. [22:42] Now, should we check back what [22:44] people are building so far? [22:45] Who got lucky enough to actually [22:46] use online? [22:48] I see a few hands. [22:49] Yeah, you were fast. So here we go. [22:53] And okay, we have [22:54] the release radar here. [22:59] We have... [23:00] Oh, this is a cool game. [23:03] Okay. [23:04] You don't mind me. [23:05] I'm just going to... [23:09] What do you mean? [23:10] Should the agent play? [23:11] I mean, yes. [23:12] By now, agents are probably [23:15] better, especially because [23:17] this all supports CUA. [23:20] Ooh, island builder. [23:21] Okay. What is this? [23:26] I have no idea how that works. [23:29] What should we assure next? [23:31] Okay. [23:33] Play Pictionary with the Claw. [23:36] Name the concept. [23:42] Can anyone else help me? [23:43] Who's online? [23:44] Help me. Give me a hint. [23:49] Well, anyhow, I'll keep letting [23:51] you play in the Explorer. [23:53] And if you didn't get a spot, [23:54] you can just download it and set [23:55] it up on your own server. [23:57] Again, it fully works with Codex. [23:59] We made sure it's a one-click [24:01] to get your subscription included [24:03] and you can play along. [24:07] So, we've been showing you how a small [24:10] team can work with agents together. [24:12] And as more and more teams started using [24:14] agents, we ran into another question. [24:18] How do you run, configure, and secure [24:20] them all across an organization? [24:22] And we definitely felt that pain. [24:25] That's why we built [24:27] an enterprise control plane. [24:29] And today, we are open sourcing it. [24:32] And with that, I'm going [24:34] to bring up Kevin Lin. [24:35] He's going to show you what we built. [24:39] Hey, Kevin. [24:45] Hi, everyone. [24:47] I'm Kevin Lin. [24:48] And I lead OpenClaw [24:49] Enterprise at OpenAI. [24:51] Now, OpenClaw Enterprise, [24:54] or OCE in short, [24:57] introduces an open source [24:59] control plane to OpenClaw. [25:02] It makes OpenClaw multi-tenant [25:04] and adds governance and hard security [25:07] boundaries to agent deployments. [25:10] Now, we believe that a secure [25:13] runtime is a necessary foundation [25:16] for bringing persistent agents [25:18] like dots and OpenClaw to everyone. [25:21] And so, today, I'll walk you through [25:24] some of the security fundamentals [25:26] that we've built into the platform. [25:30] First, we enforce hard [25:33] boundaries between trusted [25:35] and untrusted workloads. [25:37] This means that deterministic [25:39] code runs in a separate container, [25:42] and in our case, a separate cluster [25:45] from where the agent is executing. [25:47] This prevents agents from [25:49] changing their runtime. [25:53] Second, [25:55] we constrain what agents [25:56] can do with sandboxing. [25:58] We control their network access, what [26:00] files they can write to, and what [26:02] repositories they push to. [26:04] This lets us give agents [26:06] useful tools without giving [26:09] them access to everything. [26:13] Next, we add model-based [26:16] reviews on top of our existing controls. [26:19] We use auto-review, which [26:21] is a feature in both Codex [26:23] and OpenClaw that uses another [26:25] model to review the agent's actions [26:28] and block potentially dangerous [26:30] ones before they execute. [26:34] And finally, [26:37] agents run as their own identities [26:38] with dedicated service accounts [26:40] and configurable connectors. [26:43] This means that agents [26:44] aren't impersonating users. [26:46] They are themselves persistent entities. [26:49] They can be independently controlled, [26:51] audited, and if needed, turned off. [26:57] Now, it's these controls [27:00] that have helped us scale [27:02] our internal OpenClaw [27:04] deployments to over 400 Claws. [27:07] They work around the clock, [27:09] fixing code, doing experiments, [27:12] analyzing data, and escalating [27:15] security concerns. [27:17] So now, I'm going to show you [27:19] guys what that looks like. [27:23] This is a hard Pictionary game. [27:25] I don't know what that is. [27:31] Okay. [27:32] Because we are unveiling [27:34] OC to the world today, [27:36] let's create a community agent. [27:39] What you're seeing right [27:40] now are presets. [27:41] Presets are [27:43] configurable agent bundles [27:46] that an organization can configure [27:48] so that agents are launched [27:50] with your security best practices. [27:53] Let's call our agent Fred. [27:58] For Fred, we're setting up [28:01] with the Codex harness. [28:02] We're going to give him [28:03] a service account. [28:04] We're going to give Fred [28:06] read-only access to the code base [28:08] so that he can answer questions. [28:11] We keep our roadmap on Linear. [28:15] So let's give Fred [28:17] access to Linear. [28:20] But let's make sure that if [28:22] we're writing to Linear, [28:24] that those go through team approval. [28:27] Next, let's make sure [28:29] that Fred is in Slack. [28:31] I already have a Slack [28:33] app and bot token. [28:35] And because this is a preset, [28:37] Fred is already configured [28:39] with the necessary channels. [28:42] So let's bring Fred forth. [28:46] Now, while Fred is coming online, [28:49] I want to switch to another [28:52] agent that we have, Cooper. [28:56] So Cooper is [28:58] a software agent. [29:00] And think of him [29:02] as a persistent teammate. [29:03] He helps us triage issues, [29:05] solve bugs, and merge [29:07] features end to end. [29:08] Now, the OCE console, [29:11] it's functional, but it's a bit plain. [29:14] So let's spice it up. [29:17] Cooper, can you add [29:20] a heat map [29:23] of token usage [29:25] per agent to [29:27] the dashboard? [29:32] Now, software agents are [29:35] one of the most popular [29:37] agents that we deploy. [29:38] inside of OpenAI. [29:40] In fact, if you've submitted a Codex [29:42] issue any time within the last [29:44] month, there's a good chance [29:45] that an OpenClaw has triaged it, [29:48] reproduced it, and in many [29:50] cases, merged it end to end. [29:56] All right. [29:57] So Cooper is working. [29:58] And a lot of what Peter talked [30:00] about today is the future [30:02] of work and multiplayer. [30:03] Every agent that is deployed [30:06] with OCE comes with that built-in. [30:10] So here is Cooper's dashboard. [30:13] And I can open up [30:15] an authenticated session [30:17] to Cooper's team server. [30:25] Let's see. [30:26] Okay. [30:26] Perfect. Now, here you can see [30:30] the conversation I just had, and you [30:33] can further steer the conversation [30:35] to precisely define how [30:38] you want the feature to be created. [30:43] Make sure dashboard [30:45] has [30:49] custom color palettes. [30:52] And teammates can also sign [30:54] into the same session to either [30:55] follow along or steer it. [31:02] I mean the web console. [31:05] All right. [31:06] Now, while Cooper is working, [31:08] I think Fred should be ready now. [31:10] So let's check out the community page. [31:15] Hi, Fred. [31:18] What are we launching [31:21] today? [31:28] It's not every day I get [31:30] to message this Peter. [31:31] So I'm wondering what [31:33] other messages I can send. [31:45] Right now, what Fred is doing is [31:48] he's looking for Linear issues, [31:50] looking through Slack, and then [31:52] using that context [31:55] to answer this question. [31:58] Ideally, in the next 10 seconds, [32:00] or we're going to work, [32:01] or we're going to go onwards. [32:09] We have a big Linear board. [32:17] Okay. We got a reply. [32:21] Oops. [32:22] I think we have some plug-in issues. [32:24] But it does look like [32:25] we got [32:28] the OpenClaw release notes. [32:32] Well, we have a Linear issue for today. [32:35] And the issue for today [32:37] is launching OCE. [32:39] So, Fred, please do better next time. [32:49] I'm going to recap. [32:50] So, today [32:53] we are launching OpenClaw Enterprise. [32:57] This is a vendor-neutral open [33:00] source platform for managing [33:02] and deploying agents. [33:04] Similar to how Kubernetes was [33:06] the standard for deploying containers [33:08] in the cloud, we envision OCE [33:11] to do the same for agent deployments. [33:14] We first started OCE at OpenAI, [33:17] and we donated it to the OpenClaw [33:20] Foundation early in its development. [33:23] There, we've continued building it [33:25] with partners like Red Hat and NVIDIA. [33:28] And today, we're opening [33:30] it up to the world. [33:31] Try it out. [33:33] Tell us how we can make it better. [33:34] And help us build a secure [33:36] foundation for agents. [33:38] Thank you. [33:39] Back to you, Peter. [33:45] Hey, thank you, Kevin. [33:48] I want to come back [33:49] to where we started. [33:53] OpenClaw can use Codex under the hood [33:55] because Codex is open source. [33:57] We also expanded the Codex [34:00] open source program so more [34:02] people have access to AI. [34:05] And through Patch the Planet, we're [34:07] working with groups like Trail of Bits [34:09] to make open source more secure. [34:12] Open source is critical infrastructure, [34:14] and part of the ambition here is [34:16] to fix a whole class of vulnerabilities. [34:20] That's how we're building [34:21] OpenClaw with OpenClaw today. [34:24] If you're trying shared agent [34:26] workflows with your own team, [34:28] especially larger ones, I'd love [34:30] to hear what's working and what isn't. [34:33] Come find me after the talk. [34:34] Thank you.