← All speakers

Bio, Work & Ideas

Robert Brennan

Conference affiliation: CEO · OpenHands · 2026

On this page

Robert Brennan is the co-founder and CEO of OpenHands, an open-source platform for coding agents that inspect files, edit code, run commands, and use browsers. His work combines agent development with the practical demands of operating the software: sustaining an open-source contributor community, running concurrent sessions, and limiting what agents can access. He also applies parallel agents to large maintenance projects, dividing migrations into changes that engineers can review separately.

From answer extraction to Kubernetes infrastructure

Robert studied computer science, mathematics, and linguistics. At Google, he developed an algorithm that extracted answers to open-ended questions from longer documents. The technology entered Google Search in 2013 and contributed to patent US9940367B1. At Fairwinds, where he became vice president of product development, he helped conceive Fairwinds Insights with the CTO and vice president of strategy, then built the engineering team that implemented the Kubernetes auditing platform. His personal projects include rss-parser, a library that converts RSS feeds into JavaScript objects for Node and browser applications.

His analysis of Kubernetes cost estimation explains why assigning separate prices to CPU and memory can misrepresent a workload’s actual cost. A CPU-heavy application may leave memory unused while still forcing the purchase of another node; complementary workloads can instead share capacity efficiently. Robert distinguishes optimistic and conservative estimates and explains when each is useful, rather than treating either formula as universally accurate.

Building a company around OpenHands

Robert joined the open-source project then called OpenDevin in 2024. Originally created by Binyuan Hui and Junyang Lin, it became OpenHands. Robert helped organize its early contributor community while handling issues, reviewing contributions, and untangling rapidly accumulated code alongside a full-time job. In his account of sustaining the project, even a beach vacation became another working week. As the workload approached burnout, he left his job to work on the project full time; investment subsequently allowed the team to hire developers and a community manager.

In July 2024, Robert, Graham Neubig, and Xingyao Wang announced All Hands AI, the company supporting the project. Robert also co-authored the OpenHands research paper, a collaborative account of its agent platform, sandboxed execution, multi-agent coordination, and evaluation infrastructure.

The move to a hosted service introduced problems that a single-user application could avoid. For the November 2024 online beta, the team added GitHub integration and refactored the server so one user’s failure would not freeze everyone else’s session. Removing in-memory application state allowed sessions to survive changes of server instance. Robert credited Paul Bloch and Stephan Psaras for interface design and implementation, and Tim O’Farrell for application-server reliability.

Running agents within engineering teams

Robert’s technical work addresses both what an agent can do and how engineers can supervise work spread across sessions and repositories.

  • Divide large migrations into reviewable changes. In his work on parallel agents for large refactors, Robert divides a project into independently verifiable tasks, gives agents separate branches or workspaces, and has engineers inspect intermediate results. In a Redux-to-Zustand migration, temporary scaffolding allowed both state-management systems to coexist while agents updated individual components. His CVE-remediation examples similarly use containerized agents to investigate vulnerabilities and prepare discrete pull requests. OpenHands assigns agent-generated pull requests to the humans who initiate them, retaining responsibility for review, merging, and subsequent failures.
  • Limit access as well as execution. Robert’s agent-security writing distinguishes protecting a laptop from protecting everything an agent can reach. A container can still hold valuable credentials and proprietary code, and network access can let data leave without a container escape. He advocates task-specific permissions and enforceable network policies to limit the consequences of malicious instructions or ordinary mistakes. His talk “Sandboxes Aren’t Optional” extends that argument to deployment choices, comparing local containers, GitHub Actions, dedicated machines, and Kubernetes sessions through their different isolation, persistence, and scaling tradeoffs.
  • Connect agent activity to costs and outcomes. Robert’s software agent control plane separates the model-and-tool loop from execution infrastructure and organization-wide oversight. He argues that teams need to attribute spending to repositories and workflows, audit actions, and measure outcomes. At OpenHands, that includes tracking rejected automated code-review suggestions and using those rejections to improve the reviewer.

The bargain behind open development

Robert’s approach to commercial open source keeps agent research available to individual developers while charging for complementary capabilities for teams. That division creates concrete disagreements: in June 2025, he described rejecting a Kubernetes Helm-chart contribution because it implied a deployment model the community edition was not intended to support. He treats such decisions as conflicts to explain openly to contributors and investors.

His support for open development also extends to model weights. Before All Hands AI’s launch, Robert opposed restrictions on distributing model weights, arguing that wealthy companies and governments could develop powerful models regardless, while independent researchers, nonprofits, and startups depended more heavily on shared models. He favors addressing harmful uses while preserving the public’s ability to study and adapt the technology.

Read the topics behind these talks

3 conference talks

Key ideas

Scroll to read ↓

Large refactors become tractable when agents receive bounded tasks, explicit dependencies, isolated workspaces, and verification that keeps human review ahead of accumulated mistakes.

  • The maintenance backlog exceeds one prompt
    0:36 ↗
  • From code snippets to coordinated execution
    3:20 ↗
  • Choose work with a repeatable unit of change
    8:50 ↗
  • Why a one-shot migration loses its way
    11:45 ↗
  • Make review part of the execution loop
    14:39 ↗
  • Turn a dependency graph into reviewable batches
    18:04 ↗
  • Verify, fix, review, and verify again
    21:44 ↗
  • Design tasks around verification and dependencies
    27:34 ↗
  • Share discoveries without sharing every trajectory
    31:52 ↗
  • Build a scanner that feeds independent remediation agents
    34:25 ↗
  • Prepare the repository, credentials, and execution environment
    37:35 ↗
  • Prove the LLM connection before adding agents
    45:23 ↗
  • Watch the scanner work inside its remote workspace
    59:33 ↗
  • Make the scan results usable by the host program
    1:02:18 ↗
  • Grow the working pipeline beyond the demo script
    1:09:37 ↗

Key ideas

Scroll to read ↓

Coding agents can take over the write–run loop, but effective delegation still depends on precise tasks, useful feedback, bounded permissions and human ownership.

  • Less typing, more engineering
    0:00 ↗
  • From autocomplete to delegated work
    1:52 ↗
  • The action and feedback loop
    3:38 ↗
  • Editing without rewriting everything
    4:33 ↗
  • Terminals and browsers need more than text input
    5:25 ↗
  • Bound the agent's reach
    6:43 ↗
  • Start small, then make the instructions precise
    7:27 ↗
  • Keep useful context; discard a bad direction
    9:22 ↗
  • Review the result and give it a human owner
    10:34 ↗
  • Pull-request maintenance and small fixes
    12:30 ↗
  • Infrastructure, migrations and tests
    14:22 ↗
  • Building internal applications from scratch
    15:47 ↗

Key ideas

Scroll to read ↓

Robert Brennan compares local Docker containers, GitHub Actions, dedicated machines and Kubernetes sessions—and explains why moving an agent off your laptop only helps when its access moves with the task.

  • Least privilege starts with the task’s required repository, secrets and tools. Restricting those inputs limits the damage from prompt injection or agent mistakes.
    4:33 ↗
  • Local Docker preserves an interactive checkout-based workflow; remote jobs make scheduled and event-driven execution independent of the laptop.
    6:13 ↗
  • A dedicated machine separates agents from your workstation, but colocated agents can still share unnecessary credentials and modify one another’s state.
    8:52 ↗
  • Disposable session environments avoid carrying broken machine state into later runs. Useful outputs can persist separately in files or external systems.
    9:51 ↗
  • Sandboxing reduces exposure without eliminating escape risks. Choose the execution environment deliberately, even when a tool makes switching environments easy.
    12:25 ↗

References