Block Open-Sources Berd: A Local-First Desktop Workspace for AI Agents Built on Goose

On August 18, 2026, Block — the fintech company behind Square and Cash App — announced that it is open-sourcing Berd, the desktop application its own engineers and designers use every day to work with AI agents. “We often build the tools we need ourselves,” the company wrote. “Berd is the desktop application our teams use to work with AI agents across projects, skills, tools, and models. Today, we’re making it open source and sharing what we’ve learned.”

The release, published under the Apache 2.0 license at github.com/block/berd, lands at a moment when the “agent workspace” has become one of the most contested categories in software. Cursor, Claude Desktop, ChatGPT’s desktop app, and a wave of startups are all racing to become the surface where knowledge workers live alongside AI. Block’s answer is deliberately contrarian on two axes: it is a locally installed native application rather than a browser-based workspace, and it is local-first by design, storing conversation history on the user’s own device rather than in a vendor’s cloud.

What Berd actually is

According to the repository and Block’s product documentation, Berd is a general-purpose desktop app for “getting work done with any model.” It packages the agent experience into a single interface that spans:

• Projects and sessions — persistent workspaces with reviewable session history, so users can resume work without rebuilding mental state
• Skills and extensions — users can manage reusable agent capabilities and connect external tools
• Automations — recurring agent workflows that run without losing workspace context
• Model providers — the app is model-agnostic; users configure which providers and models their agents run on
• Context control — precise selection of which files and folders an agent can see, described in the product docs as making “context legible”

The design philosophy, spelled out in the repo’s PRODUCT.md, is explicit about what Berd should not be: “Do not make Berd feel like a generic chatbot wrapper, a dark terminal skin, a dashboard stuffed with metrics, or a marketing site wearing product chrome.” The brand personality is “focused, capable, companionable” — Block describes the project as “AI with character,” and each agent gets its own visual identity inside the app.

Under the hood: Tauri, React, and the Goose sidecar

Technically, Berd is a modern desktop stack. It is built with Tauri 2 (the Rust-based framework that compiles to small native binaries) and React 19 on the frontend, with a Rust core in src-tauri and crates. The primary language registered on GitHub is TypeScript.

The more interesting architectural decision is how Berd relates to Goose, Block’s open-source agent framework launched in January 2025 and later donated to the Agentic AI Foundation (AAIF), where it has grown a community of tens of thousands of GitHub stars. Berd does not reimplement an agent runtime. Instead, it talks to the upstream Goose backend through the Agent Client Protocol (ACP) over a WebSocket served by a goose serve sidecar process, which Tauri bundles as an external binary.

The backend is pinned deterministically: a goose-backend.lock.json file locks Berd to a specific Goose commit, and the build fails if the cached binary no longer matches the lockfile. A vendored @aaif/goose-sdk provides the TypeScript integration layer. This means Berd is effectively a reference client for a protocol-based agent architecture — the UI and the agent runtime are decoupled, and ACP is an emerging standard that also lets Goose agents interoperate with editors like Zed, JetBrains, and VS Code.

Local-first, with an enterprise seam

VentureBeat’s coverage highlights what may be the most consequential design choice: Berd follows a local-first data model, with conversation history stored on the user’s device in the local Goose session store rather than synced to Block’s servers. For a company that processes payments at scale and operates under strict financial-industry compliance regimes, that is not a casual decision — it reflects a bet that the next phase of enterprise AI adoption will demand data locality.

The repository also ships what the README calls “distribution seams”: the public build is self-contained and requires no private registries, but organizations can build enterprise distributions that overlay managed provider settings, private agents and resources, update channels, and signing infrastructure — without polluting the public source tree. It is an acknowledgement that most large companies will not run the vanilla build, structured so their forks stay buildable against upstream.

Open source, but not open contribution

One detail in the README is drawing attention: while anyone can read, build, and fork Berd freely, Block does not accept pull requests from outside collaborators, and outside PRs are closed automatically. “The way to participate is to open a well-formed issue,” the README states, arguing that a reproducible bug report is worth more than a patch because “it’s the part we can’t do ourselves.”

This “open source but closed contribution” model is increasingly common for corporate projects that need to ship fast while maintaining legal and security review over every line, but it will inevitably spark debate about whether “built in the open” with no external commits truly qualifies as community-driven development. Block frames Berd as “built by a small team at Block, in the open” — transparency of process, rather than governance by outsiders. (Notably, Goose itself took the opposite path: it was donated to a foundation precisely to enable external governance.)

Why it matters

Three currents make this release more significant than a single company tooling drop.

First, the agent desktop is becoming the new browser. As coding and general-purpose agents consume an ever-larger share of professional work, whoever owns the workspace UI owns the relationship with the user — and the model routing decisions that come with it. Berd’s model-agnostic, protocol-based approach is a bid to keep that layer open and interoperable rather than locked to a single vendor’s models.

Second, local-first is moving from ideology to requirement. Enterprises in finance, healthcare, and defense keep discovering that cloud-hosted agent histories are a compliance liability. A payments company shipping a workspace whose session data stays on-device is a strong signal of where procurement requirements are heading.

Third, it extends Block’s unusual open-source AI strategy. Block was among the first large enterprises to bet on agentic AI internally at scale, then release the tooling — first Goose, now Berd. Whether the no-outside-PRs policy limits adoption or the Tauri-plus-ACP architecture attracts a builder community, Berd is now one of the most complete open-source reference implementations of a production agent workspace, warts, experiments system, and all.

As of this writing, the freshly published repository has already accumulated several hundred stars within its first day public. The code, the pinned Goose backend, and the enterprise distribution seams are all available now under Apache 2.0 — no credentials, no waitlist, no cloud account required. That, in itself, is the pitch.