ClawLabs: Building Open Source Together | DevDay 2026

**TL;DR:** At DevDay 2026, OpenClaw maintainers shared how their workflow evolved over a year of open source maintenance — from CLI to Codex Desktop, and eventually to building OC with OC. Through multi-user collaborative agent sessions, session visibility, and automation loops, they turned the "meat proxy" problem into real team collaboration, moving toward the vision of a "software factory." ## Starting in the CLI Era This revolution started in the terminal. Last year, the speaker's entire workflow lived in the CLI — split panes, tons of Codex sessions, code flying back and forth between the left and right sides. As models got stronger and smarter, the number of times they needed to frantically mash Escape to intervene with the agent decreased, eventually disappearing altogether. The workflow needed to change. ## Migrating to Codex Desktop Conversations belonged on the desktop. Codex Desktop made it much easier to spin up large numbers of concurrent sessions, text was easier to read, there were visuals, a built-in browser, and real code review. But running lots of sessions and experiments was straining the machine — running out of disk space, fans roaring like jet engines. So the speaker started spreading the load across multiple machines: connecting Codex to DevBoxes to distribute the workload, and setting up Grabboxes to run tests in the cloud. At any given time, six to ten machines were running his code and experiments, sometimes through Codex, sometimes via VNC. **But this wasn't a problem more machines could solve: when teammates wanted to get involved, they still had to go through the speaker.** Everyone was working with agents, but they weren't truly working *together*. ### Don't Be a "Meat Proxy" Frank Allenby coined the term "meat proxy" this year. **Let's not be meat proxies** — you become the interface for AI, relaying messages back and forth. How does the rest of the team participate? How do they see what the agent is doing, understand the decisions behind it, and help drive the work forward? This is where building OC with OC came into the picture. ## Introducing OpenClaw OpenClaw is an open source persistent agent platform that spans your tools, devices, and teams. You can log in with a subscription — now with a nice ChatGPT login button. It loads your plugins, and you can even see your own Codex sessions. ### Governance Structure OpenClaw is open source, owned by the OpenClaw Foundation, an independent nonprofit organization, with OpenAI supporting its mission. The speaker's team at OpenAI explores how to design useful agents, how to run them at scale, how they can help improve work and life, and ultimately what automating software engineering might look like. ## Models Are Evolving Too Fast for Our Workflows The core thesis: **models are becoming more powerful and faster, and the way we work and use tools simply can't keep up.** Processes that made sense a year ago — or even six months ago — now feel constrained and outdated. ## Live Demo: PartyClaw The speaker connected to PartyClaw live and asked it to build a frog-crossing-the-road game. Nothing new so far — your agent does this too, eventually handing you a pull request, and then you might take the PR into Codex to continue working. The speaker believes there's a better way. A finished product called "Lily Lane" appeared on stage, absurdly fast. It turned out Kevin from the same team had already finished it. The speaker then asked to swap the frog for a lobster, joking: "See? I'm faster, right? See those people typing? But I wrote the first prompt." While waiting for the lobster game, the speaker gave the agent another task: he'd missed the keynote, so he asked the agent to research what cool things OpenAI announced at DevDay 2026 and build a dashboard. ### Multi-User Collaborative Agent Sessions The speaker noticed only three people were online, so he opened a URL and invited the audience to join in making "silly cute games." This is a scenario designed for teams with shared access — think open source, think working alongside your team. They used to collaborate through pull requests, but that doesn't feel like the future anymore. On the server, anyone can see each other's sessions and send prompts to each other's sessions. **Don't invite people you don't want messing with your sessions.** When they build OpenClaw in the future, they'll use this to invite top contributors: you get a token, we get your creativity. After experimenting with multi-user agent collaboration a few months ago, it changed how the team worked — it didn't just improve speed; it made everyone happier. When you can see each other's prompts, you avoid a lot of conflicts, and it genuinely feels like a team working together. Earlier that day, OpenAI released dots, an official integration for enterprise agent collaboration. OpenClaw explores a similar philosophy — agents working alongside the entire team. The difference is that OpenClaw gives you the freedom to choose models, modify the code, and even run entirely on your own infrastructure. The team is also exploring how dots and OpenClaw can talk to each other. The whole point of the workshop is to get everyone thinking: **which of our workflows are we still doing the old way that could be done so much better in the agent era?** ## Share Your Prompts A single sentence can now produce thousands of lines of code, but the conversation behind it often stays on someone's local machine. The speaker has reviewed many PRs and can understand *what* changed, but not *why* — **show me the prompt.** They tried adding a skill that asked people to send a sanitized transcript of their conversation and attach it to the PR. Very few said yes. **Sharing your conversations with agents feels surprisingly personal.** Even he sometimes says no. ### Session Visibility When they opened sessions to the entire team, it was genuinely awkward for a day — everyone reading each other's conversations. After a few laughs, it became the new normal. Now the team learns from each other and catches mistakes earlier. ## A Story About Resolving Conflict The speaker demonstrated a real scenario: waking up without having had coffee, he saw a PR on Roboclaw — someone had made the table styling smaller, and he'd done the exact same thing the day before but made it *bigger*. Cortisol levels rising. Was this Victor? He might have sent a less-than-California message before. But this time, he simply opened Victor's work session to see what he'd done. It turned out Victor had apparently reused his session and had even pinged him ("I should check my email more"). And Victor was clearly unhappy with the project's CI times. Scrolling further up, Victor was evidently being thoughtful — the speaker was wrong; Victor had actually done a good job, basically fixing the speaker's problems based on his own work. Lunchtime crisis averted. ### CI Needs to Be Rethought The speaker believes the current way of working hasn't caught up with the demands of the new era — **the current shape of CI no longer makes sense.** He's experimenting with using Codex, and with some intelligence added, it might be easier to figure out which subsets of tests are actually useful. ## The Server: Not Just an App, but a Place The team sees the server as a "place," not just an "application." Building a project involves far more than code, so the sidebar has many apps — some are dashboards, some are plugins. These things existed before too, just scattered across different servers: some updated via GitHub Actions, with databases, different repos, and the team had no incentive to update them. ### Dashboards as Software The speaker built a dashboard to track CI times. The beauty of it is that when you want to change something, you just tell the agent "make this blue," and it does it — and it doesn't lie, the dashboard updates in real time. So what is the dashboard, exactly? It's a session that produces an artifact, with automation to update that session, and the artifact contains code. In a sense, it *is* software. But if it iterates that fast, is it still software? Or is it **jellyware**? ### Community Metrics, Daily Claw, and the Slop Meter There's a community page on the server tracking various metrics — how many PRs, how many issues were reported, how many were merged. There's also Daily Claw, which analyzes everything merged on the server and generates a newspaper. "Sometimes the quality is decent, but a lot of times it's wildly off. But building should be fun." There's also a slop meter. When using agents, it's easy to let them generate more and more code until things spiral out of control, so you should always push the agent to clean up. Once this dashboard went up, it noticeably raised everyone's awareness. ### Plugins and Meeting Integration All of the above are HTML plugins, but there are also real code plugins, like Reports — showing each person's activity, how many commits, how active they are on Discord. The meeting feature was built in-house: they used to pay for software, then thought, "Why pay? This is just a prompt." They use Luna to summarize meeting notes, and the agent joins meetings on Discord. And agents can now *talk* — after integrating GPT Live, you can ask the agent directly about your work, or assign new tasks. Because it's the same identity representing the server, the same master session that understands the full picture, it works really well. ### Seeing What Team Members Are Working On Victor issued a challenge that morning: he improved the sidebar. The speaker had previously added a small view showing who was online and who was running, but it wasn't pretty. Victor said he could do better. The coolest part was being able to see his actual work process — how he interacted with the agent, "sometimes his language was colorful, but he successfully wrung out many different design iterations." Victor even built a complete editor to tweak it and was still unsatisfied. Then others joined and started collaborating, producing even more versions — "I honestly don't know which version we ended up updating." In the end, they landed on something that looked quite convincing. These visualizations also work in the Codex app. **If you're still stuck in the CLI, it's time to upgrade — you've fallen all the way back to 2025.** Even more striking: some companies hold video calls while everyone stares at a single terminal window, then use that terminal to talk to the agent — there's a better way. ## The Bigger Vision: A Software Factory What they're ultimately building here is **an agent that builds our software** — and this feels like a path toward a "software factory." Some work has to be very hands-on — you want to pair program directly with the agent. But the speaker also runs many automation loops, using them to monitor feedback and automatically ship fixes. Some loops run on different machines, sometimes stopping or needing adjustment, sometimes he's not even sure which machine they're running on. **These loops need maintenance.** ### Taste: Where We're Still Indispensable Ultimately, the value we still bring is **taste**. Taste is hard to describe — it's usually just a feeling, and it's not something he's willing to fully hand over to the agent. This didn't run well within the team — he was running too many loops himself. The team is migrating these loops one by one to the team server so others can learn from them too, because what they're ultimately maintaining is that agent that builds the software. ### Types of Automation Loops There's a monitor that scans Discord, Twitter, and GitHub. The speaker built some small CLIs that let agents easily pull in large amounts of data, and then triage them. For certain categories, like updating issues, the agent will read the report, investigate, and spin up a fresh test environment to reproduce the bug. Source: ClawLabs: Building Open Source Together | DevDay 2026 (https://www.youtube.com/watch?v=wZYnJfL4c2Y)