ClawLabs: Building Open Source with Shared Agents

The first presenter describes how maintaining open-source projects changed as coding agents became more capable. The talk follows a move from individual terminal sessions toward shared infrastructure for a team working with agents.

The presenter initially ran many Codex sessions in terminal panes, then moved to a desktop interface that made sessions, review and visualizations easier to manage. As more work ran concurrently, local hardware became a bottleneck.

Remote development machines and cloud test boxes spread out the computational load. That solved part of the capacity problem, but teammates still depended on one person to relay context between sessions.

The presenter calls this person a “meat proxy”: an intermediary who manually passes instructions and results among people and agents. The proposed team server makes more of that work visible to collaborators.

The team describes OpenClaw governance and its relationship with OpenAI, then demonstrates a shared environment. Access and governance arrangements are specific to the project and should not be inferred from a single demo for every installation.

A live demo begins with an agent building a Frogger-like game. The presenter changes the theme and lets attendees interact, illustrating a shared session where collaborators can see work as it develops.

On the team server, participants can view one another’s sessions. The presenter says shared visibility helps coordinate concurrent work and can reveal conflicts before multiple people duplicate an effort.

The team also experiments with attaching sanitized agent conversations to pull requests. Seeing the prompts and intermediate decisions can help reviewers understand how a change was produced, provided sensitive information is removed.

The presenter admits that sharing prompts initially felt personal and awkward. After trying it, the team found a common record made it easier to learn from each other and spot mistakes.

One example involves a teammate’s CI work that initially appeared to overlap with the presenter’s own effort. Reading the conversation revealed the reasoning behind the work and helped replace an assumption with context.

The presenter speculates about using agents to choose useful tests as code output grows. Any selective testing scheme needs evidence that it catches relevant failures; the demo does not establish that CI can safely be skipped.

The shared server also hosts small dashboards and tools previously scattered across machines. One dashboard tracks CI duration; the presenter asks an agent to modify its appearance as an example of conversational maintenance.

Other views track pull requests, activity and project reports. The presenter notes that automatically generated reports can be wrong, so people still need to review what the tools show.

The team demonstrates an agent joining meetings and taking notes, with shared project context available to the same system. Such integrations also need appropriate access controls and consideration for the people in the meeting.

A teammate’s visual work is visible in the shared environment, including the tools and iterations used to make it. The presenter highlights learning from the process, not only seeing the finished artifact.

The presenter describes ongoing automated loops that monitor feedback, reproduce issues and propose fixes. These loops need maintenance: they can stop, produce bad output or require adjustment as the project changes.

A loop repeatedly checks an ongoing condition, while a goal works toward a defined end state. The example goal gradually changes database access over many days; its claimed pull-request count is the presenter’s own report.

The broader vision is an agent associated with each project, carrying context, automations and goals. This is an aspirational workflow and does not remove the need for people to set boundaries and evaluate results.

The session turns to OpenClaw Enterprise. Kevin Lin says the open-source control plane is intended to support multi-tenant agent deployments, governance and isolation across an organization.

Lin describes separating trusted control code from agent execution and constraining network, filesystem and repository access through sandboxes. The exact security guarantees depend on deployment and configuration.

He adds model-based action review and dedicated service identities as additional layers. A reviewer can help flag actions, but it is not a substitute for independently enforced permissions and isolation.

Lin reports that the company uses many persistent agents internally for engineering and security tasks. The figure and outcomes are presented by the vendor and are not an independent measurement of effectiveness.

In the demonstration, an administrator creates an agent with a service account and connectors. A policy routes writes to the project-management system through team approval, while the agent can use authorized context to answer questions.

Lin shows a software agent that triages issues and works on code, then opens its authenticated session to inspect progress. He describes end-to-end automation as an internal use case, not a promise that every issue is solved correctly.

A second agent reads authorized project and messaging context to answer a roadmap question. The demo illustrates the benefit of connected context as well as why each connector’s permissions and approval rules matter.

Lin recaps the control plane and says the project was donated to the OpenClaw Foundation. The presenters close by inviting the open-source community to build on the work and improve it.