Show HN: Broccoli, one shot coding agent on the cloud

Broccoli: The Open-Source Coding Agent That’s Changing How Teams Ship Code

In the fast-moving world of software development, time is the most valuable currency. Whether you’re fixing a bug, refactoring legacy code, or building a new feature, the bottleneck is rarely the code itself—it’s the coordination. Context switching, environment setup, test runs, and PR reviews can turn a simple task into a multi-day ordeal. Enter Broccoli, a quietly revolutionary open-source tool that’s redefining how teams handle coding tasks by automating the entire workflow from ticket to pull request—all in isolated cloud sandboxes.

Developed by a small team at BeSimple, a company primarily focused on voice data, Broccoli emerged not from a Silicon Valley moonshot, but from a very real, very frustrating problem: managing multiple coding tasks across a team without losing momentum. The founders found themselves juggling local agent sessions, leaving laptops running overnight, and constantly switching contexts just to keep development moving. Sound familiar? You’re not alone.

Broccoli solves this by treating every coding task—whether it’s a bug fix, a feature request, or an internal tool update—as an independent, self-contained job. Each task is spun up in its own cloud sandbox, where an AI coding agent works through the implementation, runs tests, iterates based on feedback, and ultimately opens a pull request for human review. The result? A seamless, scalable, and secure pipeline that’s already transforming how teams ship code.

The Problem Broccoli Solves: Context Switching and Development Friction

Modern software teams are drowning in tasks. A developer might start the day with a bug report from QA, pivot to a feature request from product, then switch to reviewing a teammate’s PR—only to realize they forgot to test their own changes. This constant context switching isn’t just inefficient; it’s mentally taxing and error-prone.

Broccoli was born from this exact pain point. The BeSimple team noticed that even with powerful local coding agents like GitHub Copilot or Claude Code, the overhead of managing multiple concurrent tasks was overwhelming. Laptops were left running for hours, worktrees became tangled, and critical tasks stalled because someone forgot to push a branch.

Broccoli eliminates this friction by decoupling task execution from the developer’s local machine. Instead of running agents locally, each task is offloaded to a cloud sandbox. This means no more overheating laptops, no more forgotten terminals, and no more context-switching fatigue. The agent works autonomously, and the developer only steps in when it’s time to review the final PR.

The system integrates seamlessly with tools teams already use: Linear for project management, GitHub for code hosting and CI/CD, and GCP or Blaxel for sandboxing. A webhook triggers the process when a new task is created in Linear, and Broccoli takes over from there.

How Broccoli Works: From Ticket to PR in the Cloud

Broccoli’s architecture is elegantly simple yet powerful. When a new task is logged in Linear—say, “Fix login timeout bug”—a webhook notifies Broccoli. The system then spins up an isolated cloud sandbox, checks out the relevant repository, and feeds the task description and context to an AI coding agent.

The agent doesn’t just write code—it thinks like a developer. It analyzes the codebase, identifies the root cause of the issue, implements a fix, runs unit and integration tests, and iterates based on test results. If a test fails, the agent adjusts the code and retries. This loop continues until the solution passes all checks.

Once the agent is satisfied, it opens a pull request on GitHub, complete with a detailed description, test results, and suggested reviewers. A human developer then reviews the PR—just as they would any other—ensuring quality and alignment with team standards.

This workflow isn’t just faster; it’s safer. Because each task runs in an isolated sandbox, there’s no risk of breaking the main branch or contaminating other work. It’s like having a dedicated junior developer for every task, working around the clock without ever needing a coffee break.

Why Open Source? The Case for Building Your Own Coding Harness

One of the most surprising aspects of Broccoli is that it’s open source. In an era where AI coding tools are increasingly locked behind proprietary APIs and paywalls, BeSimple made a bold decision: to release their internal tooling to the public.

The reasoning is simple: if coding is core to your business, you should own your automation stack. Relying on third-party agents means ceding control over your development process, your data, and your intellectual property. With Broccoli, teams can inspect, modify, and extend the system to fit their unique workflows.

Broccoli isn’t just a tool—it’s a philosophy. It argues that the future of software development isn’t about replacing developers with AI, but about empowering them with better systems. By open-sourcing Broccoli, BeSimple is inviting the community to build a more transparent, customizable, and collaborative future for coding automation.

The project is hosted on GitHub at github.com/besimple-oss/broccoli, and already has contributors from outside the company. This kind of community-driven development ensures that Broccoli evolves to meet real-world needs, not just the priorities of a single vendor.

Real-World Impact: How Teams Are Using Broccoli Today

Broccoli’s adoption at BeSimple offers a compelling case study. Non-developers—such as product managers, QA engineers, and designers—are now able to ship code changes without writing a single line. For example, a designer might request a UI tweak in Linear, and Broccoli will generate the necessary CSS and React components, run visual regression tests, and open a PR—all without human intervention.

For developers, Broccoli handles the “grunt work”: bug fixes, small refactors, and internal tooling updates. This frees them to focus on high-value tasks like architecture design, performance optimization, and mentoring junior team members.

One developer at BeSimple described Broccoli as “like having an intern who never sleeps, never complains, and always follows best practices.” While the analogy is humorous, it captures the tool’s real value: it augments human capability without replacing it.

The system isn’t perfect—complex features still require human-led design sessions—but for the majority of day-to-day tasks, Broccoli delivers consistent, reliable results. And because it’s built on open standards, it integrates smoothly with existing DevOps pipelines.

The Future of Coding Agents: Autonomy, Safety, and Human Oversight

Broccoli represents a new generation of coding agents—ones that are autonomous, safe, and deeply integrated into the development lifecycle. Unlike chat-based assistants that require constant prompting, Broccoli operates end-to-end, from task inception to PR submission.

This shift toward autonomous agents is part of a broader trend in software engineering. As AI models become more capable, the focus is moving from “Can the AI write code?” to “Can the AI manage a development task?” Broccoli answers with a resounding yes.

Looking ahead, tools like Broccoli could become the default way teams handle routine development work. Imagine a world where every Jira or Linear ticket automatically triggers a sandboxed coding session, with PRs generated within minutes. Human developers would shift from writing code to curating, reviewing, and strategizing.

But this future isn’t without challenges. Ensuring code quality, preventing hallucinations, and maintaining security in sandboxed environments will require ongoing innovation. Broccoli’s open-source nature positions it well to address these issues through community collaboration.

Should You Build Your Own Coding Harness?

BeSimple’s decision to open-source Broccoli comes with a powerful message: if coding is essential to your business, you should invest in your own automation infrastructure. Off-the-shelf agents may offer convenience, but they lack the customization, transparency, and control that internal tools provide.

Building a system like Broccoli isn’t trivial—it requires expertise in cloud infrastructure, AI orchestration, and DevOps. But for teams that ship code frequently, the ROI is clear. Faster iteration, reduced overhead, and happier developers are just the beginning.

For companies already using AI coding assistants, Broccoli offers a path to greater autonomy. Instead of relying on external APIs, you can host your own agent, fine-tune it on your codebase, and ensure compliance with internal policies.

Final Thoughts: A New Era of Collaborative Development

Broccoli isn’t just a tool—it’s a glimpse into the future of software development. One where humans and AI work in harmony, each playing to their strengths. Developers focus on creativity, strategy, and oversight, while agents handle the repetitive, time-consuming tasks.

By open-sourcing their solution, BeSimple has done more than share code—they’ve sparked a conversation about ownership, transparency, and the role of AI in engineering. As more teams adopt systems like Broccoli, we may see a shift toward decentralized, community-driven development tools that prioritize control and collaboration over convenience.

The age of the autonomous coding agent is here. And with Broccoli leading the way, it’s open, safe, and built for the people who write the code.

This article was curated from Show HN: Broccoli, one shot coding agent on the cloud via Hacker News (Top)