Macro's Unified Workspace Experiment: When a Company Welds All Tools Into One OS

Forum topic · ✨步子哥 · 2026-10-28

Summary

Macro is a Rust + SolidJS open-source project (106 stars on GitHub) that rebuilds email, chat, docs, tasks, canvas, AI agents, CRM, and calls as native modules of a single system. Unlike integration-first products that connect separate tools via APIs, Macro was designed from scratch around one shared backend data model. Everything cross-references everything through bidirectional, searchable @-links — an email can link a task, a doc can link a chat message, and relationships exist at the data layer rather than through middleware like Zapier or MCP. The backend uses Rust for speed and reliability under real-time sync load; the frontend uses SolidJS fine-grained reactivity to avoid React virtual-DOM bottlenecks in chat and collaborative editing. The Agents block features team-level shared memory: agents act as team members whose context is visible across the workspace, not private per-user assistants. The project has been dogfooded for two years and recently trended on GitHub. This post analyzes Macro's block architecture, its bet that native unity beats integration, the performance rationale of its tech stack, and the broader question of whether small teams should choose unified systems over best-of-breed tool stacks.

When a Company Decides to Weld All Its Tools Together: Macro's Unified Workspace Experiment

> Source: macro-inc/macro — https://github.com/macro-inc/macro > Language: Rust + SolidJS | Stars today: 106 | License: TBD > In one line: Email, chat, docs, tasks, agents, CRM welded into a single interface where everything @-links to everything else — not integration, native unity.

---

A Scenario

A 20-person startup. Slack for chat, Linear for tasks, Notion for docs, HubSpot for CRM, Superhuman for email. Every tool is great. But they don't work together.

A customer email arrives. You discuss it in Slack, create a task in Linear, write a proposal in Notion, update the customer in HubSpot. Five tools, five switches, five records. Who said what in which tool? Nobody remembers. You've connected some things with Zapier, others with MCP. The company is held together by glue.

Macro's founder describes this scenario and then says: "Companies are not computable. They are messy."

Macro is their answer to that mess.

Not Integration — Native Unity

The market already has countless "unified workspace" products. What makes Macro different: it doesn't integrate separate tools — it was designed from scratch as one system.

Integration means tool A and tool B talk through APIs. Each has its own data model, its own UI, its own update cycle. An integration layer (Zapier, MCP) does the translating.

Native unity means email, chat, docs, tasks, and CRM share one backend data model. The relationship between an email and a task isn't established via API — it exists at the data layer. A doc @-mentioning a chat message isn't a cross-tool jump; it's a native link.

Macro calls this relationship an @-link. Everything can @-link everything: emails @-link tasks, tasks @-link docs, docs @-link chat messages, chat messages @-link CRM records. These links are bidirectional, native, and searchable.

Block Architecture: Lego-Style Work Software

Macro's features are built from "blocks." Each block is a modular, extensible unit:

| Block | Function | Comparable to | |-------|----------|---------------| | Email | Multi-account unified inbox, shared inbox | Gmail / Superhuman | | Messages | Channels and DMs, designed for technical discussion | Slack | | Tasks | Linear-style task management | Linear | | Docs | Real-time collaboration, markdown-native, CRDT | Notion | | Canvas | 2D canvas | Miro | | Agents | AI agents | — | | CRM | Customer relationship management | HubSpot | | Calls | Calls | — |

Each block isn't a composition of generic primitives — it's purpose-built for a specific work scenario. But all blocks share one backend, and cross-references are a bidirectional graph stored natively.

The implication of this design: Macro doesn't try to beat every comparable product block-by-block. It aims for connections between blocks that beat any integration scheme.

A task can @-link an email, a doc, a chat message, a CRM record. In Linear you can only link a GitHub issue. In Macro you can link anything, because everything lives in the same system.

Why Rust + SolidJS

Macro's tech stack reveals its design philosophy.

Rust backend: speed and reliability. A unified workspace handles email, chat, docs, and tasks simultaneously while staying in real-time sync. Rust's memory safety and zero-cost abstractions keep the system stable under heavy load.

SolidJS frontend: fine-grained reactivity. React's virtual DOM hits performance bottlenecks with frequent updates — chat messages, live collaboration, task status changes. SolidJS's fine-grained reactivity updates only what actually changed, without diffing the whole tree.

This combination signals that Macro treats performance as a core feature, not an optimization target. A unified workspace slower than Slack + Linear + Notion separately is one nobody will use.

Shared AI Memory

Macro's Agents block has a distinctive design: team-level shared memory.

Agents aren't private assistants per user — they're shared across the team. If an agent helps A handle a customer email, and B asks about that customer in chat, the agent knows the context. Its memory is team-level, not personal-level.

This contrasts with products like OpenBot (each agent gets its own desktop, its own browser). Macro's stance: an agent is a team member, not a personal tool.

The implicit assumption: in a unified workspace, information should flow freely — including agent memory. Privately-held agent memory would become just another information silo, no different from a Slack bot.

A Sober Look at 106 Stars

Honestly, 106 stars is the lowest among today's trending projects. But trending at all says something.

Macro isn't a new open-source project — it's been in development for two years and dogfooded by its own team the whole time. It likely surfaced on trending due to a recent release or community discussion.

For a project this size, 106 stars means it hasn't been widely discovered yet — but its ambition and polish far exceed what that number suggests.

It may also mean: the market is fatigued by the "unified workspace" category. Over the past decade, from Notion to Coda to ClickUp, countless products claimed to "unify all tools." Users tried them, found each had weak spots, and returned to stacks of specialist tools.

Macro's bet: this time is different, because native unity ≠ integration. Past unified workspaces were "one tool that does everything." Macro is "many tools inside one system, natively interlinked."

Whether that bet pays off depends on whether the @-link experience is genuinely good enough to make people give up specialist tools. 106 stars says the market is still watching.

A Deeper Question

Macro's existence poses a question about software design: should tools be specialized or unified?

The last 20 years answered "specialized." Each tool does one thing well, connected via APIs and integration layers. The limit of that thinking is today's SaaS hell: a 20-person company running 50 tools at $10–50/month each, with Zapier at $100/month gluing it together — thousands per month.

Macro answers "unified." One system, one backend, one data model, one subscription. The limit there: if Macro dies, you don't lose one tool — you lose all of them.

Both approaches are defensible. The likely answer: small teams unify, large teams specialize. Small teams lack the resources to manage integrations across 50 tools; large teams need each tool to be best-in-class.

Macro targets "small companies, or small teams inside large companies." That market is big enough — and needs this badly enough.

---

GitHub: https://github.com/macro-inc/macro Website: https://macro.com Docs: https://docs.macro.com