Macro 是为你和你的团队打造的一体化工作空间。它将邮件 + 消息 + 文档 + 任务 + Agent + CRM 整合到一个快速的界面中，并提供团队级共享记忆。工作空间中的所有内容均可通过 @链接关联和搜索，因此你的团队（以及 Agent）无需再在多个工具之间切换。

我们构建 Macro，是因为希望为我们的创业公司打造一个统一的操作系统。市面上有许多优秀的软件产品，我们也都使用过——Slack、Linear、Notion、HubSpot 和 Superhuman——但它们无法作为一个系统协同工作。当我们将上一家公司扩展到约 20 人时，问题开始显现：每个团队都有自己的工具，公司只能靠 MCP 和 Zapier 勉强连接起来。公司无法被计算。它一片混乱。

Macro 从底层出发，将工作软件彻底重新设计为一个单一系统。

产品由我们在纽约和多伦多设计，并由约 15 人的团队内部使用两年。它采用 SolidJS 和 Rust 构建，以实现速度和可靠性。我们的重点是构建一种产品，让任何小型公司或大型公司中的团队都能将其用作自己的“操作系统”。

Macro 由“模块（blocks）”构成，设计目标是模块化、可扩展，并像乐高一样协同工作。对于每个模块，我们研究了现有最佳实践，并努力做得更好。

每个界面都针对其具体工作进行了专门设计，而非由通用模块原语拼装而成——但它们全部共享同一个后端；文档与任务之间、频道消息与邮件之间的交叉引用，都会以原生的双向图谱形式存储。

模块	文档	功能
邮件	文档 →	多账户统一收件箱、键盘快捷键和共享收件箱。支持 Gmail。
消息	文档 →	为专注的技术讨论而设计的频道和私信。
任务	文档 →	受 Linear 启发的任务系统，与频道、邮件和 Agent 深度集成。
文档	文档 →	基于 CRDT 构建、支持实时协作且原生支持 Markdown 的文档，并支持 @提及。
画布	文档 →	可嵌入任务、文件和邮件 @链接的二维画板。
Agent	文档 →	统一的团队级记忆，可代表你采取行动。
通话	文档 →	录制、转录并写入团队记忆，供 Agent 使用。
文件存储	文档 →	自动从邮件和频道导入，支持完整搜索。
拉取请求	文档 →	可关联任务、嵌入频道，并供 Agent 使用。
CRM	文档 →	客户和联系人对象、自定义属性、邮件同步与数据补全。

多个邮件收件箱，配备优秀的 AI 工具和集成式 CRM

Macro Mail 的设计灵感来自 Superhuman 以键盘操作为核心的界面，并增加了几项关键能力：

1. 多账户。可在一个收件箱中分拣所有 Google 账户邮件，并使用相同的标签和共享系统；也可以分别分拣。
2. 统一收件箱：邮件、消息、@提及和待完成任务全部显示在同一列表中。可使用 j、k 和 e 浏览所有内容。
3. 更好的 AI，配备面向跨收件箱使用而设计的工具/MCP 界面，帮助 Agent 更准确地检索信息。例如，我们提供统一搜索工具，允许 Agent 直接搜索所有文件附件 PDF（从邮件中解析而来），而不必先获取邮件线程再获取附件。你也可以直接在 AI 对话中起草、编辑和发送邮件，无需打开邮件界面。

4. 多任务处理能力——Macro 内置窗口管理器，允许你创建 3 个以上分屏（可随显示器尺寸扩展），因此你可以一边起草邮件，一边查看此前的邮件线程。
5. 公司/联系人对象。Macro 提供原生 CRM 功能，因此你可以通过 cmd+k 跳转至联系人，例如 tim@acme.com，查看你与该联系人之间的全部邮件；也可以跳转至公司，查看团队所有成员与该公司所有人员之间的全部邮件和文件，例如 @acme.com。这一切都可以直接在邮件界面中完成，无需打开 HubSpot 或 Salesforce 这样的重型 CRM。Agent 同样可以按联系人或公司聚合邮件，从而更好地协助处理 CRM 类型的查询与操作。

Macro Mail 与频道、文档、任务和代码位于同一界面中。你可以在任意邮件中点击“task”创建关联任务，例如根据客户支持邮件为工程师创建工单。在文档中 @提及邮件，例如在 Todos.md 中引用 @Re: Contract Signature.eml。在 Macro 中，邮件被纳入你的全部工具和团队所使用的同一权限系统：只需点击 Share，即可将邮件分享至任意私信或频道——无需截图。

邮件文档 →

面向专注技术讨论的团队聊天

Macro Chat 的设计比 Slack 更专注。前几条回复以内联方式展示，其余内容折叠为线程，因此繁忙的频道仍能保持可读性。线程可被分别授予权限，因此你可以通过复制链接在不同频道间分享线程。所有内容都存储在双向图谱中：任务会 @链接至创建它们的消息，客户支持邮件会关联至支持频道，CRM 记录会在讨论它们的消息出现时更新，等等。其核心理念是：(i) 消息应成为任务、邮件、文档和内容管理围绕其构建的中心，并且应保持轻量化；Agent 应像人类用户一样成为一等公民；(ii) 消息系统需要更适合技术对话、更聚焦且更易读，而不应演变成上下文丢失、进展淹没在噪声中的混战。

消息文档 →

围绕聊天构建的任务管理

Linear 最近发布了一份报告，称问题追踪已死。我们同意这一点，但更准确地说，问题追踪从未真正发挥作用，至少对我们来说是这样。我们确实认真尝试过，也曾责怪自己；但在与其他公司交流后发现，没有人会“正确地”使用自己的问题追踪器。如果是这样，问题就在于工具设计，而不在于使用它的公司。

传统问题追踪器或项目管理工具的核心问题在于：它们会过时。之所以会过时，是因为：(i) 它们与团队聊天中真正发生讨论的地方是两个独立系统，例如 Slack、Macro、Discord 等；(ii) 除了跟踪工作之外，它们没有提供太多额外价值。它们是一项短期成本明确、只承诺长期收益的苦差事。与二维画布相比，它们过于僵化、预设过多，也不符合项目实际的运作方式。

解决方案并不是完全放弃追踪。我们试过，那只是另一种形式的混乱。我们发现的解决方案，是将轻量级事项与频道和私信紧密耦合，让事项追踪自然发生在对话本身发生的地方。

在 Macro 中创建任务很简单。只要条件允许，创建的任务都会与其创建上下文（例如一封客户邮件）双向关联，因此从“我们为什么要做这件事”→ 任务 → Agent → 拉取请求的完整链路都可以在一个系统内审计。

• 从邮件创建任务
• 在任何位置通过 c t 创建
• 在 Markdown 文档中使用 /task 创建
• 高亮任意 - [ ] 项目符号并点击“Task”创建
• 在任意频道或私信中使用 @Macro 创建任务
• 在任何 Agent 对话中创建
• 通过外部 MCP、API 或 SDK 创建

任务文档 →

由 CRDT 驱动的 @链接 Markdown 文档

我们希望所有内容都能在一个 Markdown 编辑器中完成，无需切换工具。

• 原生 Markdown 兼容性，以及批量导入/导出（参见“文件优先于应用”范式）
• 基于 CRDT 和 Cloudflare Durable Objects 的实时协作，让人感觉就像大家在同一台电脑上编辑。编辑几乎会立即同步，而不是像 Google Docs 那样一卡一顿地更新
• 版本控制：支持历史记录和分叉，并提供简洁的历史回溯 UI。这目前仍处于 v1 阶段；要达到更接近 git 的能力还有很多工作要做，或者我们未来可能会增加 git 兼容性。
• 离线编辑与同步协调。
• 与工作空间内所有内容 @链接：邮件、文档、任务、消息、频道、公司、联系人等。类似 Notion，但支持多模态。
• 支持移动设备，可使用我们的 iOS app 或网页版（Android app 即将推出）
• Agent 原生编辑：由 Agent 群体驱动，它们在 CRDT 协作系统中以与人类协作者对等的方式工作。参见 Wolf 关于此功能的技术博客。可通过 MCP 或内部 Agent 使用。

Agent 可以编辑处于打开或关闭状态的文档。Agent 编辑的一个有趣用例是维护团队上下文。例如，我们有一个每天运行的 Macro 自动化任务，用于更新办公室 Pool Games Markdown 文档。它会扫描所有频道，查看是否有人赢了，然后更新文档。如果已经有人编辑过该文档，它可以识别这一点并放弃更新。冲突由 CRDT 协作系统原生处理。

文档 →

能够自我保持更新的 CRM

独立 CRM 的问题与任务追踪器相同：它不会保持最新。CRM 只部分反映现实，因此如果你想了解某笔交易的最新状态，仍然必须联系 AE/SDR 并询问上下文。CRM 也过于僵化且闭源；而 Airtable/Notion 中自建的 CRM，又无法提供按公司/联系人/交易聚合邮件这一 CRM 的核心功能。我们尝试过所有 CRM，包括新一代 AI 原生产品；尽管它们设计精良，但其结构性设计注定会随着时间推移而失效。

**Macro 的解决方法，是将 CRM 与团队聊天和邮件共置，而不是让它成为独立系统。**当你在消息中 @提及一条公司记录时，团队成员可以点击该记录查看最新信息——这比前往 CRM 查找记录、返回 Slack 再粘贴链接快得多，而这种速度差异至关重要。其次，@提及公司/联系人会在该消息与记录之间建立双向链接，因此之后你可以从记录追溯曾发生过的对话。这解决了我们在 Attio/HubSpot/Salesforce 中遇到的核心问题：关于交易的真正重要对话并不发生在 CRM 中，而是在消息里。Macro 将其转变为功能，而不是让你因此觉得自己管理混乱。这不是你的错，是 CRM 的错！

除上述段落所述内容外，我们并未对 CRM 的核心理念进行创新。以下内容本不该多么引人关注：

• 看板和可自定义交易阶段、列表视图、保存视图、可分享视图、个人与团队视图等。
• 公司“备注”实际使用与频道/私信相同的系统，因此你可以 @提及并使用频道中应有的所有功能。基本上，每笔交易都会自动拥有自己的频道，并直接固定在交易记录上。
• 可从任意备注、消息、任务、拉取请求等中 @提及公司或联系人，在记录与该内容之间建立双向链接。例如，可从工程任务中 @提及某家公司，以记录其请求。一切内容都会关联起来。

CRM 文档 →

Agent 与统一的团队级记忆

由于 Macro 在单一数据库中拥有团队上下文，因此它具备独特优势，能够提供涵盖企业全部运营信息的团队级记忆。我们每天通过 cron job 完成这一工作。你的记忆会根据团队对话、私信、已发送和已接收的邮件、已创建和已完成的任务等内容更新。所有这些内容会一次性综合处理，而非彼此分开处理，并与此前的记忆结合，形成新的记忆输出。最终结果是：

• 与仅根据过往对话构建记忆的聊天机器人相比，Macro 最了解你正在推进的工作和你关心的事项
• 这一记忆可通过 MCP 供外部 Agent 使用，也可通过模型选择器供任意 AI 模型（OpenAI、Google、Anthropic 等）使用，以实现最大的可移植性
• 记忆以 Markdown 明文存储，因此你可以按需导出。如需手动更新，只需让 AI 记住某件事或更新你的记忆

团队记忆非常实用。例如，我曾拍下一张纸质记事本中写下的功能截图，并要求 Agent 创建工单、分配给合适的工程师；它在没有任何运行时工具调用的情况下完美完成了任务。

[](/macro-inc/macro/blob/main/.git

Macro is the all-in-one workspace for you and your team. It unifies email + messages + docs + tasks + agents + CRM into a single fast interface with shared team-level memory. Everything in your workspace is @linked and searchable so your team (and your agents) never have to switch tools.

We built Macro because we wanted a single operating system for our startup. There are many good software products, and we used them all — Slack, Linear, Notion, HubSpot, and Superhuman — but they don't work together as one system. As we scaled our last venture to ~20 people things started to break: every team got their own tools and the company was held together by MCP and Zapier. The company was not computable. It was chaotic.

Macro is a complete redesign of work software from the ground up as a single system.

Designed by us in NYC and Toronto, dogfooded by our team of ~15 for two years. Built in SolidJS and Rust for speed and reliability. We're focused on building something that any small company or team at a larger company can use as their "operating system".

Macro is composed of 'blocks' designed to be modular, extensible, and work together like Lego. For each block, we studied the best prior art and tried to make it even better.

Each surface is purpose-built for its job rather than composed from a generic block primitive — but every one of them shares the same backend; cross-references between a doc and a task, or a channel message and an email, are natively stored as a bidirectional graph.

Block	Docs	What it does
Email	Docs →	Multi-account unified inbox, keyboard shortcuts, and shared inboxes. Gmail.
Messages	Docs →	Channels and direct messages designed for focused technical discussions.
Tasks	Docs →	Linear-inspired tasks, tightly integrated with channels, email, and agents.
Docs	Docs →	Real-time collaborative, markdown-native docs built on CRDTs, with @mentions.
Canvas	Docs →	2D board with embedded @links to tasks, files, and emails.
Agents	Docs →	Unified, team-level memory. Can take action on your behalf.
Calls	Docs →	Recorded, transcribed, and logged to team memory for agents.
File storage	Docs →	Auto-imported from email and channels, fully searchable.
Pull requests	Docs →	Linked to tasks, embeddable in channels, available to agents.
CRM	Docs →	Customer and contact objects, custom properties, email sync, enrichment.

Multiple email inboxes w/ good AI tools, integrated CRM

Macro Mail is inspired by Superhuman's keyboard-first interface with a few key additions:

1. Multi-account. Triage all your Google accounts in a single inbox, with the same tagging and sharing system. Or triage individually.
2. Unified inbox: emails, messages, @mentions, and tasks to complete, all in the same list. Use j k and e to navigate everything.
3. Better AI, with a tools/MCP surface designed to work across inboxes and to help your agents more accurately retrieve information. For example, we expose a unified search tool that allows agents to search all file attachment PDFs (parsed out of email) directly, rather than pulling email threads then attachments. You can also draft, edit and send emails right from AI chats, without opening your email.

4. Multitasking ability — Macro has a built-in window manager that lets you create 3+ splits (scales with monitor size) so you can draft emails while reviewing prior threads.
5. Company/Contact objects. Macro has native CRM capability so you can cmd+k to a contact, like tim@acme.com to see all emails between you and that person, or companies, to see all emails and files between everyone on your team and everyone at that company, e.g. @acme.com. All of this right from your email without having to open a heavyweight CRM like HubSpot or Salesforce. Email aggregation by contact or company is also available to your agents so they can better assist with CRM-type queries and actions.

Macro Mail lives in the same interface as channels, docs, tasks, and code. From any email, hit "task" to create a linked task, e.g. a ticket for an engineer from a customer support email. @mention emails in documents, e.g. @Re: Contract Signature.eml inside of Todos.md. In Macro, your email is brought into the fold with all of your tools, and your team, in the same permissions system: just hit Share to share an email to any DM or channel — no need to screenshot.

Email docs →

Team chat for focused technical discussions

Macro Chat is designed to be more focused than Slack. The first couple of replies show inline and the rest collapse into a thread, so a busy channel stays readable. Threads are permissioned severally so you can share threads across channels by copying links. Everything is stored in a bidirectional graph, so tasks @link to messages that created them, customer support emails tie into support channels, CRM records get updated when they're discussed in messages, etc. The core idea is that (i) messaging should be the centerpiece around which tasks, mail, docs, and content management are built, all in a lightweight way, and agents should be first-class citizens like human users and (ii) messaging needs to be more focused and readable for technical conversations, and not turn into battles where context is lost and progress is indistinguishable from noise.

Messages docs →

Task management built around chat

Linear recently published a report that issue tracking is dead. We agree with that, but the stronger form is that issue tracking never really worked, at least for us. We really tried and we blamed ourselves, but as we talked to other companies, it turns out that nobody was using their issue tracker "correctly". And if that's the case, the problem is the design of the tool, not the companies that use it.

The core problem with traditional issue trackers or project management tools is that they get out of date. The reason they get out of date is that (i) they're a separate system from where the conversation really happens in team chat (e.g. Slack, Macro, Discord, etc.) and (ii) they don't add much benefit beyond tracking the work. They're a chore with near-term costs and only the promise of long-term benefit. They're too rigid compared to a 2D canvas, too opinionated, and don't match how your project actually functions.

The solution isn't to forgo tracking entirely. We tried that and it was a different form of chaos. The solution we've found is lightweight issues tightly coupled to your channels and DMs, so that issue tracking naturally occurs where the conversation itself happens.

Creating tasks in Macro is easy. Where possible, tasks created are bidirectionally linked to the creating context (e.g. a customer email) so the full chain is auditable from "why are we doing this" → task → agent → pull request, all in one system.

• Create a task from an email
• From anywhere via c t
• From a markdown doc with /task
• From any - [ ] bullet by highlighting and clicking "Task"
• @Macro create tasks in any channel or DM
• In any agent chat
• Via external MCP, API or SDK

Tasks docs →

@linked markdown docs powered by CRDTs

We wanted everything in a single markdown editor without switching tools.

• Native markdown compatibility and bulk/import export (see "file over app" paradigm)
• Live collaboration with CRDTs and Cloudflare durable objects make it feel like you're editing on the same computer. Edits come in ~instantly instead of ka-chunking like Google Docs
• Version control: history and forking, with a neat UI for scrubbing history. This is still in v1, there's a lot to do to get it closer to git, or we may eventually add git compatibility.
• Offline editing and reconciliation.
• @-linked to everything in your workspace: email, docs, tasks, messages, channels, companies, contacts, etc. Like Notion but multi-modal
• Mobile-friendly, in our iOS app or on the web (Android app coming soon)
• Agent native editing, powered by swarms of agents operating as peers in the CRDT collaboration system like human collaborators. See Wolf's tech blog on this. Use via MCP or internal agent.

Agents can edit documents that are open or closed. One interesting use case for agentic editing is to maintain team-context. For example we have a Macro Automation that runs daily to update our in-office Pool Games markdown doc. It scans through all of the channels to see if anyone has one and then updates the doc. If somebody has already edited the doc, it can know that and forgo the update. Conflicts are handled natively by the CRDT collaboration system.

Docs →

CRM that keeps itself up to date

The problem with standalone CRM is the same as with task trackers: it's not up to date. The CRM only partially reflects reality, so if you want to know what the latest status on a deal is you still have to message the AE/SDR and ask for context. CRMs are also too rigid and closed-source, while DIY CRMs in Airtable/Notion don't provide email aggregation by Company/Contact/Deal that is the core feature of CRM. We went through all the CRMs, including the new AI-native ones, and while they're well-designed they're just structurally set up to fail over time.

Macro fixes this by colocating your CRM with your team chat and email, instead of having a separate system. When you @mention a company record in a message, your team can click that record to see the latest — it's much faster than navigating to your CRM to find the record, going back to Slack and pasting it in, and this speed difference makes all the difference. Secondly, @mentioning a Company/Contact creates a bidirectional link between that message and the record, so from the record later you can trace the conversations that happened. This fixes the core issue we had with Attio/HubSpot/Salesforce: the actual important conversation about a deal happens not in the CRM but over messages. Macro makes this a feature rather than making you feel disorganized about it. It's not your fault, it was the CRM's fault!

We haven't innovated on the core idea of CRM other than what you read in the above paragraph. None of this should be that interesting:

• Kanban board and customizable deal stages, list view, saved views, shareable views, personal and team views, etc.
• "Notes" on the company actually use the same system as channels/DMs, so you can @mention and do all of the things you expect in a channel. Basically, every deal gets its own channel, automatically, that's pinned right to the deal record
• @mention the company or contact from any note, message, task, pull request, etc., to create a bidirectional link between the record and that thing. For example, @mention a company from an engineering task to note their request. It all ties together.

CRM docs →

Agents and unified team-level memory

Since Macro has the team context in a single database, it is uniquely positioned to offer team-level memory with full context of all of the operations of the business. We do this every day via a cron job. Your memory is updated from team conversations, your DMs, your sent and received emails, tasks created and completed, etc. All of this is synthesized together in one pass, rather than severally, and combined with your previous memory to form the new memory output. The net result:

• Macro has the best memory on what you're working on and what you care about vs. chatbots that only build memory from prior chats
• This memory is available to external agents via MCP, or any AI model (OpenAI, Google, Anthropic, etc.) through the model picker for maximum portability
• The memory is plainly stored in markdown so you can export it as you please. To manually update it, just ask the AI to remember something/update your memory

Team memory comes in quite handy. For example, I took a screenshot of some features I'd written in a paper notepad and asked the agent to create tickets and assign to the appropriate engineer which it did perfectly without any runtime tool use.

Memory isn't supposed to encompass everything. Macro also has a tool/MCP surface with near 100% coverage of the things you can do in Macro's UI, so that your agents aren't limited in what they can do like they are in most SaaS. There are also no rate limits on MCP.

Agents docs →

Your coding agents can use Macro too. Point Claude Code, Codex, or any MCP client at your workspace:

claude mcp add --transport http macro https://mcp-server.macro.com/mcp

See MCP setup and agent recipes for what they can do once connected.

How it all works together

As we've discussed above, each of the blocks is designed to be best-in-class. We have thoughtfully designed each of Chat, Docs, Email, Agents, etc., to improve on your status quo individually. But where it all comes together is how it's more than the sum of its modules; it's how they work together.

Bidirectional @linking. @mention a doc in a message and both know about each other. Your workspace becomes a web of context you can navigate in either direction.

Channel-based permissions. Anything you @mention in a channel is automatically shared with its members. Join a channel, gain access; leave, lose it. No permission-request dance.

Unified memory. Agents remember what your whole team is doing across email, messages, tasks, docs, and calls, not just your own chat history. Refreshed nightly.

One inbox. Emails, channel messages, task assignments, @mentions, and agent responses all land in one place, split into Signal and Noise. Keyboard-first throughout.

Deeper reading: key concepts covers blocks, mentions, properties, and permissions; the FAQ covers comparisons, licensing, and self-hosting.

Sign up and connect your Gmail or Google Workspace account. Macro runs in any modern browser, with an iOS app for your phone. The getting started guide takes you from a fresh account to a working setup in about 15 minutes. Coming from Notion, Slack, Superhuman, or Linear? See Switch to Macro.

git clone https://github.com/macro-inc/macro.git
cd macro
nix develop          # Rust toolchain, Bun, sqlx, zig, cargo-zigbuild
just run_local       # local infra + backend services + proxy + frontend

Tauri's large platform dependencies live in focused shells: use nix develop .#tauri-linux for Linux desktop development or nix develop .#tauri-android for Android development on x86_64 Linux.

run_local prints the frontend URL once the stack is up; r rebuilds changed Rust services, q tears it down. See Running locally for Doppler setup and named instances.

just check                    # type check the workspace
just clippy                   # lints
just setup_test_envs          # write the .env files tests need
cargo test                    # full test suite
cargo test -p email_service   # a single service





macro/
├── apps/
│   ├── web/       SolidJS client — browser, Tauri desktop, mobile
│   └── docs/      docs.macro.com
├── services/      42 deployable services, workers, and Lambda handlers
├── crates/        167 Rust libraries — domain logic, models, db clients
├── packages/      shared TypeScript — collaboration, lexical-core, loro-mirror
├── infra/         Pulumi definitions
├── docker/        local Compose stack
├── nix/           pinned dev shell and build inputs
└── tooling/       repo scripts and code generators

Services follow a hexagonal layout: inbound adapters, a domain core with ports, outbound adapters. docs/STYLE_GUIDE.md has the conventions and CONTRIBUTING.md covers the PR process.

Enterprise-grade security. Zero data retention with model providers, including no training on customer data. SOC 2 Type II certified. We welcome responsible security reports and pay bounties in accordance with severity and impact. Send reports to security@macro.com.

Macro is fully open source — not "open core" — under the GNU Affero General Public License v3.0. See LICENSE.txt for details.

You can self-host Macro under the terms of the AGPLv3; the FAQ covers what that involves. If you want to build on top of Macro under a different license, contact licensing@macro.com. For managed hosting or commercial arrangements, contact self-host@macro.com.

Community

Have an idea, want to contribute, or want to work on Macro?

If Macro is interesting/useful to you, please scroll up and give the repo a star (scroll to the top of this page -> click Star in top right). Stars are how most users hear about Macro because they move us up GitHub's search and trending pages.