What Is an Agent-Native Workspace? Why Coordination over Intelligence Became the Bottleneck in AI Work

By the end of 2027, Gartner expects more than 40% of agentic AI projects to be canceled. The reasons it names are escalating costs, unclear business value, and weak risk controls. Those three share a root: nobody could get the people, the agents, and the work into the same place at the same time.

That is a coordination problem, not an intelligence problem. It is also the quiet story behind Buzz, the open-source workspace Block released in July 2026 for humans and AI agents to work in the same room. The models can already do the work. What most teams lack is somewhere to do it together.

What is an agent-native workspace?

An agent-native workspace is a shared environment where people and AI agents work as first-class participants. Each agent has its own identity and permissions, and everyone sees the same conversation, code, and history. It replaces the pattern of humans running private agent sessions and pasting results between tools.

How is it different from a chat app with a bot in it?

A bot answers when spoken to and forgets when the thread scrolls away. An agent-native workspace treats the agent as a member with a persistent identity: it posts without being prompted, reviews code, and reads the same channel history a new engineer would on day one. A bolted-on assistant borrows the room; a native agent lives in it.

What makes an agent “first-class”?

Three properties separate a member from an assistant:

• Its own identity. A name and key that belong to the agent, not borrowed from a human.
• Scoped permissions. A defined limit on what it may and may not do.
• Shared context. The same view of the work everyone else can see.

Take away any one and it degrades into a private assistant a human has to babysit and translate for.

Where did the idea take shape?

Buzz is the clearest working example. Block built it on Nostr, an open protocol for signed messages and portable identities, and released it under Apache-2.0 in July 2026. Chat, search, automation, and Git hosting sit in one place, and agents built on Claude, Codex, goose, or anything speaking the Agent Client Protocol keep the same project identity even when the model changes.

Why did coordination, not intelligence, become the bottleneck?

Because model capability stopped being the scarce resource. Frontier models research, write, test, and review at a level that clears most day-to-day bars. The constraint moved to everything around the model: keeping context, decisions, and identity in one place so work can pass between people and agents without a human retyping it.

What the adoption numbers show

Adoption is real but shallow:

• Scaling is rare. In McKinsey’s 2025 State of AI survey, no more than 10% of respondents were scaling AI agents in any given business function.
• Most are still testing. 23% had begun scaling in at least one function; 39% were only experimenting.
• Usage trails adoption. A PwC survey in May 2025 found 79% of companies reported adopting AI agents, yet 68% said half or fewer employees used them daily.

The headline says everyone has agents. The detail says most are stuck in pilots.

Why the pilots stall

They stall at the handoff. When each person works alone with an agent in a private window, every handoff needs a human to carry context to the next tool and restart elsewhere. Block described its own pre-Buzz workflow as people copying an agent’s output into Slack and pasting replies back, acting as middleware. That labor never shows up in a demo. It shows up months later as the cost and ambiguity Gartner blames for cancellations.

The tax nobody prices in

Context reconstruction. Every private session begins by rebuilding what the team already knew: which fix was tried, why it was rejected, what the constraints were. A shared workspace pays that cost once. Search a term like “auth refresh” six months later and the whole thread is there: the report, the rejected fix, the review, and the reason the obvious fix was wrong. A conventional record keeps the diff and a green check. A shared workspace also keeps the why.

The two ways of working, side by side:

How do multiple agents work together in one workspace?

Usually through one orchestrator agent directing a group of cheaper, faster agents. The lead holds the big picture; the workers research, build, test, and review in parallel, talking through ordinary messages in the shared room while humans redirect the work as it moves.

The orchestrator-and-swarm pattern

One capable model coordinates; several smaller ones execute. A frontier model is expensive and slow to parallelize; a swarm of lighter agents fans out and reports back. Gartner projects 33% of enterprise software will include agentic AI by 2028, up from less than 1% in 2024, with 15% of routine work decisions made autonomously. At that scale, coordinating many agents becomes an operating requirement.

Why a shared room beats parallel private sessions

Because the history is visible and humans stay in the loop. When agents coordinate in the open, a person can catch a wrong turn before a well-formatted wrong answer finishes rendering, and the failed paths stay on the record. None of that survives when agents run in separate windows only their operators can see.

The honest complication: more agents is not better

Scale cuts both ways. Gartner estimates that of the thousands of vendors selling “agentic AI,” only about 130 are real. The same looseness shows up inside teams that throw a crowd of agents at a problem that never needed one and pay for it anyway. Coordination infrastructure earns its keep only with governance attached:

• Clear ownership. Someone accountable for every agent that runs.
• Permission limits. Scoped authority, not blanket account access.
• Visibility. A way to see what each agent is doing and why.

Without that, an agent-native workspace is just a faster way to produce confusion.

What do machine-speed writers do to version control?

They break the assumption it was built on. Git quietly relied on humans as a rate limiter: we sleep, meet, and think before pushing. A room full of agents removes that brake, producing what Block calls human-months of commits and CI runs in an afternoon, with many writers pushing at once.

A conventional forge assumes writes arrive at human speed, so throughput, storage cost, and concurrent-write conflicts stay rare. Point a swarm of agents at it and all three become the common case. Version control has to be rebuilt around machine-scale writers, or it becomes the bottleneck the workspace was meant to remove.

Buzz’s answer is deliberately boring, which is the point:

• Objects first. A push writes immutable, content-addressed packfiles to cheap, effectively unbounded object storage.
• Pointer last. A conditional compare-and-swap advances one mutable manifest pointer, and that swap, not the announcement message, is the commit.
• Proven, not assumed. Block specified the storage protocol in TLA+ and model-checked durability, reconstruction, and concurrent pushes; every backend must pass a conformance suite.

The lesson generalizes past Git: when agents write at machine speed, the systems beneath them need real coordination guarantees, not human-paced assumptions.

How does an agent get its own identity, and why does it matter?

Instead of borrowing a human’s login, each agent gets its own cryptographic key. The owner signs a narrowly scoped authorization for what the agent may do, and the agent signs its own work. Authorization does not erase authorship: the record shows the agent as author and proves who authorized it, under what conditions.

The credential-sharing problem

The usual way to authorize an agent is to hand it a human’s credentials and hope. CyberArk’s 2025 Identity Security Landscape report counted 82 machine identities for every human, found 42% of them carry privileged or sensitive access, and reported that 68% of organizations lacked identity security controls for AI. Every bot wearing a human badge widens the biggest gap most companies already have.

How cryptographic delegation works

An identity is a keypair. The owner issues a signed grant that scopes the agent’s authority, and the agent signs each action itself, so any observer can verify both who acted and who stood behind it. When something goes wrong, the response is graded:

• Revoke the agent. Kill its key without touching the human identity behind it.
• Remove the owner. Cut the authorization and the agent cannot reconnect.
• End active sessions. Stop work in flight if the risk is immediate.

The deliberate choice is semantic: keep authorization and authorship separate rather than collapse the agent into the person.

Why portability is the real payoff

Identity the platform does not own survives the platform. When an agent’s identity is a keypair rather than a vendor account, it moves between tools and still verifies if the tool disappears. Because identity travels with a signature rather than an address, an agent can run on a laptop, a cloud VM, or an edge box, and the workspace verifies the signature instead of trusting where it connected from. The same trust model lets a team route model requests to a member’s spare GPU without exposing its prompts to the server. For a team, the audit trail of who authorized which agent is yours, not a feature you rent. That is why the pattern matters more than the protocol: identity, history, and authorship must outlive the tool that hosted them.

What this means for teams building with agents

The next phase of AI at work will not be won by whoever has the smartest model. Capability is becoming a commodity. The advantage moves to teams whose people and agents share a room, an identity system, and a memory of why past decisions went the way they did. Making that choice deliberately is what separates a faster team from a more confused one.

An agent-native workspace is not a bigger model. It is a better place to put the ones you already have.

FAQs

What is an agent-native workspace in simple terms? +

It is a shared digital workspace where humans and AI agents work together as equal participants, each with its own identity and permissions, all seeing the same conversations, code, and history. Instead of each person using a private AI assistant and copying results around, the people, the agents, and the work sit in one place.

What is Buzz by Block? +

Buzz is an open-source, self-hostable workspace that Block released in July 2026 under the Apache-2.0 license. Built on the Nostr protocol, it combines team chat, search, automation, and Git hosting, and lets AI agents from different vendors work alongside humans, each with its own cryptographic identity.

Is coordination really the bottleneck, or is it still model quality? +

For a growing share of tasks, model quality is no longer the limit. Frontier models can already research, write, and review competently. The recurring failure point is coordination: moving context, decisions, and permissions between people and agents. Gartner’s forecast that more than 40% of agentic AI projects will be canceled by the end of 2027 blames cost, unclear value, and weak controls, which are coordination and governance failures more than intelligence failures.

What is multi-agent orchestration? +

Multi-agent orchestration is the practice of coordinating several AI agents to work on one problem together. A common pattern uses one capable orchestrator agent to hold the overall plan while several cheaper, faster agents carry out research, building, testing, and review in parallel, communicating through a shared workspace.

How does version control keep up with AI agents? +

When many agents commit at once, they can produce in an afternoon what used to take human-months, overwhelming forges that assumed a human pace. Systems like Buzz handle it by storing repositories as immutable, content-addressed packfiles on object storage and advancing a single pointer with a conditional compare-and-swap, so concurrent machine-scale pushes stay consistent.

Why should each AI agent have its own identity? +

Because sharing human credentials with agents is both risky and untraceable. Giving each agent its own cryptographic key lets its owner grant a narrow, revocable authorization while the agent signs its own work. If a key leaks, you revoke that one agent without disturbing the human behind it, and the record still shows who did what and who authorized it. With CyberArk reporting 82 machine identities per human and 68% of organizations lacking identity controls for AI, distinct agent identity is a security requirement, not a nicety.

Do you need blockchain or Nostr to build an agent-native workspace? +

No. Nostr is one way to give agents portable, signed identities, and Block chose it for Buzz, but the important properties are the pattern, not the protocol: a distinct identity per agent, scoped and revocable authorization, shared context, and a history that outlives any single tool. Those can be built on several underlying technologies.