The Agent Behind the Curtain: Building the Oz Cloud Agent Platform — Safia Abdalla, Warp
Safia Abdalla discusses Warp's cloud agent platform, emphasizing its core principle of absorbing complexity from the user. She details features like flexible sandboxes, multi-harness support, and API-driven agent orchestration. The talk highlights how agents manage Warp's open-source repository—from issue triage to PR review—and introduces the "potter's workshop" analogy as a superior model to the "software factory" for modern, human-centric software development.
Safia Abdalla, with eight years of experience building developer tooling, emphasizes that effective tools “meet devs where they are and grow with them,” adapting to workflows and changing complexities. This philosophy underpins Warp’s transition from a local terminal to a cloud-based agentic development environment.
The shift to cloud agents became necessary for handling “long-running” tasks beyond local machine capabilities, though it introduces a “messier stack of infrastructure concerns.” Warp’s core principle for its cloud agent platform is to “absorb complexity before it reaches the user.” This is implemented through several key features:
- Flexible Sandboxes: Agents require isolated environments. While managed sandboxes offer an easy on-ramp, Warp also provides self-hosted options. This accommodates professional teams with existing infrastructure, security, and deployment practices, abstracting infrastructure complexity.
- Multi-Harness Support: Recognizing diverse developer preferences for tools like Cloud Code or Codex, the platform supports multiple harnesses. Crucially, it ensures a consistent experience by structuring conversation state and agent-produced artifacts (e.g., PRs, issues, new files) across all harnesses, preventing fragmentation.
- Agent Orchestration: Real engineering tasks rarely fit a single prompt. Warp’s platform supports orchestrating sub-agents for different stages (research, implementation, validation), potentially using various harnesses and models. Orchestration can occur via:
- Prompt-based delegation: An orchestrator agent handles the complexity of interacting with sub-agents, mediating messages, and tracking progress from a single user prompt.
- API-driven interaction: Every primitive in the stack is exposed via an API, allowing programmatic control for spinning up agents, managing environments, and working with artifacts, fostering composability.
- API/SDK Extensibility: The robust API and SDK enable users to build custom tools. Non-engineering teams at Warp, for instance, used the SDK to create Slack bots for triaging social media mentions, performing sentiment analysis, and drafting responses.
Upon open-sourcing three months ago, Warp saw its GitHub stars jump from 20,000 to over 60,000, with thousands of pull requests. To manage this influx, agents were integrated into the repository process, not merely for code generation:
- Issue Triage: Agents automatically triage new issues (bug reports, feature requests), research the codebase, and ask clarifying questions to gather necessary details, addressing a common challenge in open source where initial reports lack sufficient information.
- PR Review Gate: All pull requests undergo an agent-managed review process, iterating until approved. Human reviewers are only pinged for “high-signal, high-quality” PRs that have already passed agent review, significantly reducing human workload. This process incorporates “self-improvement loops,” where agents learn and refine their performance based on new code examples and PRs.
This agent-driven structure allows anyone, including non-developers with domain expertise, to translate their intent into implementation and contribute “serious software.”
Abdalla pushes back on the term “software factory,” which she finds impersonal, preferring the analogy of a “potter’s workshop.” A potter meticulously crafts items, focusing on details and ergonomic design, while also developing a “serious and repeatable system” in their workshop—with dedicated stations, sourcing processes, verification steps, and continuous refinement by the owner. Applying this to software development means building systems with:
- Automation: Agents implement automations reacting to real-world events.
- Observability: Systems must be inspectable to understand workflows and refine processes.
- Improvement: Workspaces are dynamic, adapting to evolving goals and product needs.
- Cost-effectiveness: Aim to reduce “broken mugs” (buggy software) and optimize resource usage.
The ultimate goal is to “remove toil and drudgery from our software process” through robust, reliable systems, empowering more people to build, including those in non-technical roles.