Block Berd: An Open-Source Desktop Home for Goose, Claude Code, and Codex

Block — the company behind Square, Cash App, and Tidal, founded by Jack Dorsey — open-sourced Berd on August 18, 2026: a locally installed desktop app it built internally so its own employees could stop juggling separate interfaces for Goose, Claude Code, and Codex. It's free, Apache 2.0, and available now for macOS, Windows, and Linux, as first reported by Carl Franzen at VentureBeat.

If you're already running Claude Code, OpenAI's Codex, or Goose day to day, the pitch is obvious on paper: one desktop app, not three fragmented config files and three separate terminal habits. The harder question — the one a README rewrite won't answer — is whether Berd is a genuinely different piece of software or a UI shell Block built for its own internal politics that happens to be public now. It's also worth asking upfront: Block has another open-source agent product, Buzz, and Block's own roadmap statement says its future focus is shifting there. That's not a footnote — it changes how much you should invest in Berd today.

TL;DR — questions people ask first

Why Berd exists: three tools, three fragmented configs

Block's own framing, per its GitHub documentation, is that employees had access to increasingly capable agents through Goose, Claude Code, and Codex — but working with them meant navigating separate interfaces, separate configuration files, and no shared sense of what project or file an agent was actually looking at. Berd is Block's answer: one desktop "work surface" where you start chats, attach files or folders, choose an agent and a model, work inside persistent projects, configure providers, manage skills and extensions, review session history, and build automations, all without leaving one window.

The design goal that shows up repeatedly in Block's spec is state legibility: you should always be able to see which project, which files, which agent, which model, which provider, and which session state is currently active. Berd is built to expose failures, loading states, and streaming output plainly, rather than smoothing them over with a friendlier but vaguer UI — a deliberate contrast to chat interfaces that hide what's actually happening mid-request.

Architecture: Berd is a client, not a new agent runtime

The most important technical fact about Berd is also the easiest one to miss in a quick skim: Berd does not run its own agent loop. It's a client application that talks to a separate agent runtime over the Agent Client Protocol (ACP) — a standard for how a front-end talks to an agent process running alongside it. By default, that runtime is Goose, Block's open-source agent framework, which Block has also contributed to the Agentic AI Foundation alongside Anthropic and OpenAI.

Goose runs bundled inside Berd as a sidecar process — a separate binary launched and supervised by the desktop app, not code compiled into it. Goose owns the actual agent loop: planning, tool calls, and model requests. Berd owns everything on top of that: projects, sessions, context, configuration, and the UI you actually look at. This split matters practically — Berd's build process pins a specific Goose backend version through a lockfile and verifies the cached binary matches before packaging it, which creates a defined version boundary between the app and the agent engine underneath it. Developers can override that pinned binary with their own local Goose build for testing, but the default install ships a known-good, version-locked pairing.

Because the connection between Berd and the agent runtime is a protocol rather than a hard dependency, Berd is also built to work with Claude Code and Codex as alternate harnesses — you configure whichever one you want per project, alongside whichever model provider you're already paying for. That's the actual differentiation from, say, wrapping Goose in a nicer GUI: Berd is explicitly harness-agnostic by design, even though Goose is the bundled default.

The Gloopies: agent personas with an explicit purpose

Berd gives each configured agent a persona and avatar — Block calls these Gloopies. Named examples include Berdy, Pushback, Choosey, Copycat, Tinker, and Wildcard, each mapped to a distinct role rather than a cosmetic skin: Pushback plays devil's advocate on drafts, Choosey narrows down decisions when there are too many reasonable options, and Copycat learns and mirrors your own writing style.

Block's own framing draws a hard line against decorative UI: "The avatars make the agent recognizable. Its role, skills, and tools make it useful." The spec explicitly rejects toy-like or purely decorative interface elements — a Gloopy is meant to be a visual shorthand for "which configured agent, with which tools, is currently doing this work," not a mascot layered on top of a generic chatbot.

What people are asking

Is this actually different from Claude Code, Codex, or Cursor — or just a wrapper?

Berd is a genuinely different layer than any single harness, because it isn't trying to be a better Claude Code or a better Codex — it's trying to be the thing that sits above all of them. Claude Code and Codex are each a specific harness tied to a specific company's models. Berd is a desktop shell that can point at either of those, or at Goose, and switch per project. Whether that's worth adopting depends on whether your actual pain point is "I want a better single harness" (in which case Berd doesn't replace that choice) or "I'm tired of context-switching between three separate tools' interfaces and configs" (which is the problem Berd was built to solve).

Is my data safe? Does anything leave my machine?

Mostly stays local, with one important caveat readers should not gloss over. Conversation history lives in Goose's local session database on your device, and credentials default to the OS keychain rather than a cloud account. But Block is explicit in its own documentation that "local-first does not mean no data ever leaves the device" — whatever you send to a configured model provider (Anthropic's API, OpenAI's API, or a local model) is still transmitted to and processed by that provider under its own terms. Local-first describes where your history and secrets are stored, not what happens to your prompts once they're sent for inference.

On telemetry specifically: it's off by default. If you opt in, Berd collects only a randomly generated install ID and a limited set of predefined usage events — the payload explicitly excludes prompts, messages, files, source code, credentials, names, and emails. IP addresses are still processed as part of normal request transport, security, and rate-limiting, even though they're excluded from the event payload itself. One caveat Block itself calls out: because Berd is open source, forks can modify or strip telemetry behavior entirely, so enterprises evaluating a customized internal build should verify what that fork actually does rather than assuming upstream's privacy defaults carry over.

Should I bother installing this now, given Block says its future focus is Buzz?

This is the most legitimate reason to hesitate, and it's worth stating plainly rather than burying it. Block has a second open-source product, Buzz — a multiplayer, Nostr-protocol-based collaboration workspace where humans and AI agents share rooms with their own cryptographic identities and scoped permissions, self-hostable or Block-hosted. Block's stated roadmap is that its focus is shifting toward Buzz going forward, and it plans to bring Berd's single-player capabilities into Buzz over time. Read plainly, that's Block signaling Berd may not remain a permanent standalone product. That doesn't make Berd useless today — it's free, functional, and Apache 2.0, so your projects and session history aren't locked into a vendor that could shut off access. But it's a real reason not to build deep team automations or multi-month workflows around Berd specifically, versus treating it as a solid daily driver you could migrate away from later.

Can I use my own Claude or OpenAI API keys?

Yes — that's the whole model. Berd has no subscription price, and none is planned; you configure your own AI providers and pay them directly for usage. Block's stated pitch for why this matters: "some tasks need the big brain, most don't" — the value of routing through one interface across Goose, Claude Code, and Codex is being able to match a cheap or fast model to a small task and reserve an expensive one for something that actually needs it, instead of defaulting to whatever tool happens to be open.

Can enterprises manage this centrally?

Not yet, and Block doesn't pretend otherwise. There's no documented SSO, centrally enforced admin policy, org-wide permission controls, data-retention rules, or audit logs in the public release — Berd today is endpoint software you install per machine, not a SaaS admin plane. What the public repo does provide is distribution seams: because the build is self-contained and needs no private registries, an organization can overlay its own managed provider settings, private agents, runtime configuration, and update channel without adding private material to the public tree. Block's own internal deployment reportedly uses exactly this — approved devices, approved model providers, managed configuration, and governed tool connections layered on top of the open build. That's a real capability, but it's a build-your-own-management-layer capability, not an out-of-the-box one.

How Berd compares to what else is out there

The differentiation Block is selling is the combination — free, open source, multi-harness, local-first, and explicitly designed to be usable by people who aren't developers, not just engineers comfortable in a terminal. Where it loses to the single-vendor apps is exactly where you'd expect: no bundled subscription, no centralized admin tooling, and (per the FAQ above) an open question about how long Berd stays a standalone product versus folding into Buzz.

The honest limitations

• No outside pull requests. Block's repository explicitly states it doesn't accept PRs from outside authorized collaborators — they're closed automatically. You can file issues and bug reports, and the project is maintained "by a small team at Block, in the open," but this isn't a community-governed Apache project in the way some are.
• No enterprise admin plane yet. SSO, org-wide policy enforcement, retention rules, and audit logs aren't in the public build — see the enterprise question above.
• Fork-level telemetry risk. Because the code is open, a modified fork can change or remove telemetry behavior, and Block itself flags this as something enterprises should check rather than assume.
• Roadmap uncertainty. Block's stated plan to shift focus to Buzz and fold Berd's capabilities into it means Berd's standalone lifespan is an open question, not a settled one.
• It still requires you to bring your own model access. Berd doesn't include any model usage — you're responsible for configuring and paying for Anthropic, OpenAI, or whatever provider you use underneath it.

Why this matters if you're already running agent harnesses

The pattern worth watching isn't Berd specifically — it's that the harness and the coordination layer above it are increasingly being built as separate products, the same trend explainx.ai flagged when covering Block's Buzz launch in July. Anthropic ships Claude Code; OpenAI ships Codex; Block now ships two different things sitting above and beside its own Goose framework — a single-player desktop app (Berd) and a multiplayer team workspace (Buzz). If you're evaluating agent harnesses or wiring up MCP servers for your own workflows, Berd is worth trying specifically because it's free and because the ACP-based sidecar architecture is a clean reference for how to decouple a UI from an agent runtime — regardless of whether Berd itself is the tool you settle on long-term.

Summary

Block open-sourced Berd on August 18, 2026 — a free, Apache 2.0, locally installed desktop app that unifies Goose, Claude Code, and Codex behind one interface, communicating with Goose over the Agent Client Protocol as a version-pinned sidecar process. It's local-first for storage but not for network traffic — your prompts still reach whatever model provider you configure. It has no subscription, no outside contributions, and no enterprise admin plane yet. And Block's own stated roadmap says focus is shifting to its other open-source product, Buzz, with plans to fold Berd's capabilities in over time — a legitimate reason to try it today without betting your team's workflows on it staying a standalone product.

Related reading

• Jack Dorsey's Buzz: team chat, AI agents, and Git hosting
• Block Buzz: self-hosted Nostr workspace for humans and agents
• Top 10 closed-source and open-source agent harnesses (2026)
• What is an agent harness? Complete guide
• What is MCP? Model Context Protocol guide
• OpenAI Codex plugin for Claude Code: guide
• Claude Code commands: complete reference guide
• Agent Client Protocol — AI dictionary

Official links: github.com/block/berd · VentureBeat coverage by Carl Franzen

Details accurate as of August 20, 2026, based on Block's public GitHub repository and VentureBeat's reporting. Berd is an actively changing open-source project — verify current version, telemetry defaults, and license terms on the GitHub repository before adopting it for team or production use.