Introducing Labor0: A Graph-Native Approach to AI Engineering

Labor0 turns broad engineering requests into dependency-aware work across the coding agents developers already use.

Today, Zephyr Cloud Inc. is launching Labor0, a new engineering product in The AI Platform family.

Labor0 is an orchestration system for AI engineering. It turns a broad software request into a dependency graph of bounded tasks, runs the tasks that are ready through Codex, Claude Code, or OpenCode, and brings decisions back to a human when judgment is required.

Coding agents are already good at completing individual tasks. The bottleneck in larger projects is coordination: deciding what can safely begin, what must wait, and where a human decision must block downstream work.

I have led Labor0’s development from the beginning. I built SWC by focusing on a concrete bottleneck—JavaScript tooling was too slow. With Labor0, the bottleneck has shifted from the speed of one tool to the coordination of many capable agents.

The AI Platform organizes collaboration around rooms, specialists, model routing, and reusable workflows. Labor0 shares the same principle—agents should move independently when work is clear, while people retain control over consequential decisions—but applies a different execution model to software engineering.

The coordination bottleneck

Most meaningful engineering requests are not one task. A change may require a shared contract, backend implementation, interface work, migrations, tests, documentation, and a final release decision.

Assigning those pieces to agents is easy. Understanding which pieces are safe to start is harder.

Labor0 models the work as a durable dependency graph. Tasks can be ready, blocked, running, completed, or waiting for review. Independent tasks may run concurrently once their prerequisites are satisfied, while downstream work remains blocked.

Architecture, scope, security, and release decisions can also be real blockers in the graph—not comments buried inside an agent transcript. When a task completes or a person makes a decision, Labor0 recomputes what becomes ready next.

Parallel execution is not the starting assumption. It is a consequence of correctly modeled dependencies.

Keep the agents. Add orchestration.

Labor0 does not replace Codex, Claude Code, or OpenCode with a proprietary coding harness. It coordinates the agents developers already use while preserving the configured harness, model, repository scope, and execution environment.

When work becomes ready, Labor0 can run it in a disposable managed cloud environment. Hosted work can be started from mobile, so a developer does not need to keep a laptop awake or maintain a permanent runner. Managed runs use authorized repository access and explicitly configured credentials.

More autonomy should not mean removing human judgment. Labor0 connects the plan-oriented workflows of Codex, Claude Code, and OpenCode to Web Push. When a hosted task needs a decision, the user can inspect the plan, approve it, request changes, or terminate the task.

While it waits, the task remains durable. Labor0 can checkpoint and release compute, then continue the same provider conversation after the response where native continuation is supported.

The graph can continue through CI failures, review comments, and requested changes. Automation should know how to run—and when to wait.

A public, inspectable result

For the public Demo, we submitted one engineering request against a public repository. Labor0 turned it into six bounded tasks connected by eight dependency edges.

After the foundational model task completed, two independent branches became ready and ran in parallel. Documentation, integrated validation, and pull-request preparation waited for their prerequisites. Codex executed the work on a managed cloud runner and produced a public pull request for human review.

• Watch the request move through the graph
• Inspect the public repository
• Review the resulting pull request

No private workspace or customer data was used in this demonstration.

Pricing

Labor0 starts with a free Sandbox that includes a $5 lifetime hosted allowance. Paid plans start at $99 per month plus metered usage; the recommended Team plan is $199 per month and includes a $99 usage allowance per billing period. See full pricing.

What is available now—and what comes next

• Available now — dependency-aware cloud orchestration. Labor0 coordinates blockers, readiness, Codex, Claude Code, OpenCode, and managed cloud execution. Work can begin from mobile, and plan decisions can return through Web Push.

• Internal experimentation — local execution. The local runner is implemented and being tested internally. We will broaden access only after its setup, credential, lifecycle, and recovery behavior are ready. Local credentials are not silently copied into hosted environments.

• Beta — Slack and Discord. Labor0 can begin work from explicitly connected project channels through Workspace Chat. Actor identity, project binding, and Labor0 permissions still apply; a channel message does not bypass them.

• Internal experimentation — direct The AI Platform integration. The AI Platform has a much broader product surface than Slack or Discord, including multi-human rooms, specialists, model routing, workflows, and mini apps. We are designing a direct integration that respects both its collaborative model and Labor0’s dependency-aware engineering graph, rather than treating it as another chat endpoint. This requires more product and engineering work, will take longer, and is not part of the current public release.

• Beta roadmap — connected knowledge with L0 Nexus. Workspaces will be able to connect permission-scoped sources such as internal documentation, issue trackers, conversations, operational systems, and databases. The same sources can support Workspace Chat, agents running through Labor0, and queries from connected Slack or Discord channels. Over time, this can become an internal query tool available directly from a team’s messenger and allow agents to perform work that depends on an organization’s Knowledge Base or structured data.

• Alpha roadmap — evidence-backed QA. Agents should catch clear, reproducible errors. When the correct outcome requires product, design, security, or business judgment, Labor0 should ask the user with verifiable evidence such as screenshots, observed-versus-expected results, recordings, traces, or logs. The decision remains connected to any remediation work.

• Alpha roadmap — AutoPilot. Labor0 AutoPilot is being developed to evaluate production signals from systems such as Sentry and propose bounded investigation or repair work. Not every alert should start an agent, and human review should remain in control before the graph changes.

Roadmap capabilities may change in scope, interaction model, and availability as we expand access.

Labor0 is live

Engineering work may begin as a direct request, a team conversation, a question grounded in internal knowledge, or eventually an operational signal.

Labor0 turns that input into structured work, runs ready tasks through the coding harness the team already trusts, and returns to a person when a real decision is required.

You do not need another coding agent.

You need the agents you already have to work as one system.

This is the first release, and there is much more ahead.

Explore Labor0

Start with Sandbox