TL;DR

Berd is the desktop app Block built for its own employees to work with AI agents, now open-sourced under Apache 2.0. It is not a model and not an agent runtime — it’s the workspace around one. Projects, chats, files, agents, skills, provider config and session history in a single native window, sitting on top of harnesses like Goose, Claude Code and Codex.

It is also, as of this week, a slightly strange thing to recommend. Block’s own Head of AI Capabilities says the company’s forward focus is a different product.

Key facts, verified August 29, 2026:

  • 820 GitHub stars, 101 forks, 87 open issues — repo made public August 11, 2026, still pushing daily (last commit Aug 28)
  • Apache 2.0, TypeScript, Tauri 2 + React 19; builds for macOS, Windows, Linux
  • v0.6.2 is current (released Aug 18, 2026); v0.6.0 was the first open-source release
  • Talks to a bundled Goose backend over the Agent Client Protocol (ACP) via a goose serve sidecar
  • Conversation history stays local; credentials use the OS keychain; telemetry is off by default
  • Outside pull requests are automatically closed — issues only
  • Block’s stated roadmap: fold Berd’s best parts into Buzz, its multiplayer agent workspace

The honest summary: architecturally interesting, genuinely local-first, and shipped with a roadmap statement that should make you think twice before building a team workflow on it.

The problem Berd is solving

If you use more than one coding agent, you already know the tax. Goose has its config. Claude Code has CLAUDE.md and its own MCP setup. Codex has another. Each keeps session history somewhere else, each defines “project” differently, and moving context between them means re-explaining your repo for the third time today.

This is precisely the itch Block scratched internally. From the VentureBeat launch coverage:

“We had capable agents through goose, Claude Code, and Codex, but working across them meant navigating different interfaces, configuration systems, and ways of managing context.” — Lucinda Bell, Technology Communications at Block

Berd’s answer is a persistent desktop surface. You create a project once — folders, Git repos, instructions, agent configs — and return to it instead of rebuilding context per task.

The design spec has one principle worth calling out, because it’s the opposite of how most AI products behave: you should always be able to tell which project, files, agent, model, provider and session state are shaping the current conversation. Failures, unavailable providers and streaming states are shown plainly rather than smoothed over with assistant-flavored friendliness. That’s a real product opinion, and it’s the strongest thing about Berd.

Architecture: a shell over a harness, not a new harness

This is the part that determines whether Berd is useful to you.

Berd does not implement an agent loop. It bundles Goose — Block’s model-agnostic agent runtime, contributed to the Linux Foundation’s Agentic AI Foundation in December 2025 — as an external sidecar process and speaks to it over the Agent Client Protocol on a WebSocket. Goose runs the loop between the model, its context and its tools. Berd owns projects, sessions, agents, skills and configuration on top.

The build pinning is the detail worth stealing even if you never install this:

just setup   # installs pnpm deps, builds the vendored @aaif/goose-sdk,
             # and prepares the Goose backend pinned by goose-backend.lock.json
just dev     # reuses the stamped pinned binary; FAILS if the lockfile
             # commit no longer matches the cached build

Berd does not pull whatever Goose build happens to be current. It pins a specific backend commit in goose-backend.lock.json, verifies the cached binary matches, and packages that. Bumping it is a deliberate PR:

scripts/update-goose-backend-lock.sh main   # or a tag/branch/sha
just goose-sync                             # fetch and build the pinned commit

For local testing you can bypass the managed checkout entirely:

GOOSE_BIN=/path/to/goose just dev

And bundling stages the sidecar into the Tauri app as binaries/goosed-<rust-host-triple>, matching the "externalBin": ["binaries/goosed"] entry in src-tauri/tauri.conf.json:

just bundle                                    # pinned managed binary + pnpm tauri build
GOOSE_BIN=/path/to/goose just stage-sidecar    # or stage an explicit local binary

A defined version boundary between the app and its default agent backend, enforced by a check that fails the dev command. Most desktop AI apps let their runtime drift silently. This one doesn’t.

The standard checks are equally unfussy:

just check        # Biome, design-system, i18n, contract, and type checks
just test         # unit and component tests
just tauri-check  # Rust type check with sidecars disabled
just clippy       # Rust lint, warnings denied

Agents with faces

Berd’s most divisive choice: configured agents get visual identities. Block built animated character sets — the flagship designs are called Gloopies — and ships personas built around styles of work rather than blank chat windows. Pushback plays devil’s advocate on drafts. Choosey narrows decisions. Copycat learns your writing style. v0.6.1 expanded the bundled set to seven, adding Tinker, Wildcard and Agt Builder.

Block’s own framing is defensible: “The avatars make the agent recognizable. Its role, skills, and tools make it useful.” The spec explicitly rejects toy-like presentation and interfaces that hide operational state behind friendliness. The argument is that when you’re juggling six specialized agents, a recognizable identity is shorthand for an invisible bundle of instructions, tools and permissions.

Agent sharing is file-based and portable — you can export an agent card as a ZIP so instructions and settings survive a trip through Slack, with PNG and Markdown exports from the same menu.

What the community actually said

Here the reception gets rough, and it’s worth being straight about it: most of the public criticism landed on the marketing site, not the software.

The main Hacker News thread (item 49357967) reached 30 points and 15 comments, and the tone was closer to a roast:

“It’s actively unhelpful even for the most ‘non-technical’ of users to further anthropomorphize LLMs and ‘agentic’ workflows that boil down to moving plaintext around. The design is cute but this is an abstraction that simply has no reason to exist.” — nylonstrung

“Keeping aside the functionality of the app, the vibe of the web page and those mascots is NOT IT. They are unsettling and creepy.” — omeysalvi

“This website is not very user friendly. Huge amount of assets to load, an unclear product, and a visually distracting experience.” — grugdev42

Several commenters reported the site tanking their browser — “I get between 1 and 10 FPS,” one wrote; another said an Easter-egg page paused their music. One reply nailed the split verdict: “Cool design if cringe product.” Another was less kind: “I will forget about it by Friday.”

There was a genuine dissent defending it as deliberate satire of chirpy assistant personas, and rw2 offered the marketer’s read: “You can love it or hate it but it’s unforgettable.”

The more useful critique came from the separate submission (item 49352040), which barely registered at 3 points but asked the right question:

“I’m struggling to understand the use case. How is this better than an Agents.md file in each repo and switching in skills as required? Are people really switching between many different harnesses? I have used two and I rarely switch and if I do the cost is super low.” — kb01

That is the real objection. Berd’s entire value proposition assumes multi-harness pain is a problem you actually have. If you live in one agent, this is a heavy Tauri app solving a bill you aren’t paying.

Local-first data and telemetry

Credit where it’s due — this part is unusually clean for a corporate release:

  • Conversation history stays on your machine by default
  • Credentials use the OS keychain
  • Telemetry is disabled by default in official distributions. If you opt in, Block says it collects a random installation identifier and predefined usage events, explicitly excluding prompts, messages, files, source code, credentials, names, email addresses and IP addresses from the payload (Block and its providers still process IPs for transmission, security and rate limiting)
  • Block warns that forks can modify or redirect telemetry — evaluate the build you actually run, not Block’s defaults

The obvious asterisk: context you send to a model still leaves the machine on whatever terms your configured provider offers. Local-first storage is not local inference. If you want the fully-offline story, that’s Goose plus a local model via Ollama — Berd is the shell, not the privacy boundary.

One packaging caveat straight from the release notes: the Windows NSIS installer and Linux packages lack platform-native code signatures. Their updater archives are minisign-authenticated, but that will matter to some security teams.

Enterprise distributions — and what they aren’t

Berd ships “distribution seams”: defined points where an organization can overlay managed provider settings, private agents, runtime configuration, optional companion tools, its own update channels, and its own signing and publishing infrastructure — all without putting private material in the public source tree. The public repo builds a fully self-contained distribution that needs no private registries or Block credentials, so you can evaluate it cold.

But “enterprise distribution” is not an enterprise management plane. The README does not describe SSO, centrally enforced admin policies, org-wide permission controls, data-retention rules or audit logs. It establishes that you can customize and ship Berd. It does not explain how those installs are governed afterward. Treat it as endpoint software, not SaaS.

The two things that should give you pause

1. You cannot contribute code. The source is public; the project is not collaborative. From the README: Berd is built by “a small team at Block, in the open. You can read the source, build it, and fork it freely — but we don’t accept pull requests from outside authorized repository collaborators, and outside PRs are closed automatically.” The sanctioned path is a well-formed, reproducible issue. That’s a coherent position — a bug report they can reproduce genuinely is worth more than a drive-by patch — but it means Apache 2.0 here buys you inspection and forking, not influence.

2. Block’s focus is moving to Buzz. This is the load-bearing caveat. Buzz is Block’s other Apache 2.0 project: a Nostr-based multiplayer workspace where humans and agents share channels, threads and DMs, and agents carry their own cryptographic identities and scoped permissions. Berd is the single-player, privileged-local-access surface; Buzz is the shared-room, relay-scoped one.

Block does not intend to keep both. Brad Axen, Head of AI Capabilities, told VentureBeat: “Going forward, our focus is Buzz, and we plan to bring the best parts of Berd’s single-player experience into it.” Berd remains available, but Buzz is what Block is telling people to download.

Berd even ships the bridge already: its first published portable Agent Skill is buzz-handoff, which pulls Buzz channel or thread context into a private agent conversation and can send an explicitly approved reply back through the Buzz CLI.

Berd vs. the alternatives

ProductMakerCostModel supportThe distinction
BerdBlockFree, Apache 2.0 (you pay your own provider)Any provider you configure, across harnessesDesktop workspace over harnesses; local-first storage; visual agent identities; persistent projects; aimed beyond engineers
GooseBlock / AAIFFree, Apache 2.0Any provider, or fully local via OllamaThe runtime underneath Berd; CLI + desktop; can run entirely offline
Codex appOpenAIIncluded with paid ChatGPT plansOpenAI models only”Command center” for coding agents; parallel agents across project threads
Claude CodeAnthropicIncluded with paid Claude plans; also API usageAnthropic models onlyDeep autonomous coding across terminal, IDEs, desktop and web
CursorAnysphereSubscriptionMultiple frontier modelsAI-native editor; Cursor 3 adds local-to-cloud agent handoffs

Berd’s differentiation isn’t inventing the agent workspace — it’s being the open-source, multi-harness, not-only-for-developers one. Every other row is tied to a single vendor’s models, priced as a subscription, or aimed squarely at engineers, and usually all three.

Who should use it

Good fit if you: genuinely rotate between Goose, Claude Code and Codex; want conversation history that never leaves your disk; are evaluating how to package a governed internal agent distribution (the seams pattern is worth reading regardless); or work with non-engineers who need agent access without a terminal.

Skip it if you: live in one harness — AGENTS.md plus skills already covers you; need SSO, audit logs or central policy today; want to contribute upstream; or need a stable multi-year platform, given the stated migration to Buzz.

FAQ

Is Berd free? Yes — free and Apache 2.0 licensed, with builds for macOS, Windows and Linux. There is no subscription and no announced plan for one. You still pay whatever your model provider charges.

Does Berd work with Claude Code and Codex, or only Goose? Both, but at different layers. Berd bundles Goose as its default agent backend over ACP. Harness support is broader at the configuration level — v0.6.1 groups connections into company-managed services and local MCPs configured for Goose, Claude Code or Codex. You configure the providers and harnesses you want rather than inheriting a Block-chosen stack.

Where does Berd store my data? Locally. Conversation history stays on your machine, credentials go in the OS keychain, and skills and instructions are plain files. Prompts and project context still travel to whichever model provider you configure.

Can I contribute to Berd? Not with code. Outside pull requests are automatically closed. Block accepts issues — and the README asks for reproducible bug reports specifically. You can fork freely under Apache 2.0.

Is Berd still being developed? It’s active — the repo pushed commits as recently as August 28, 2026, with three releases in the two weeks after going public. But Block has said its forward focus is Buzz, with Berd’s best single-player parts migrating there. Plan accordingly.

How is Berd different from Goose’s own desktop app? Goose is the runtime and ships its own CLI and desktop client for technically comfortable users. Berd is a workspace layer above it that adds persistent projects, agent identities, skills management, provider configuration and session organization — and is explicitly designed for people who aren’t going to open a terminal.

Sources