Macro is an open source workspace that pulls email, chat, docs, tasks, calls, CRM, and AI agents into a single interface, all tied together with shared team-level memory. Instead of stitching Slack, Linear, Notion, HubSpot, and Superhuman together with integrations, the team behind Macro rebuilt work software as one system, written in Rust and SolidJS and released under the AGPL-3.0 licence. The repository, macro-inc/macro, is the full codebase: Rust crates, deployable services, the web app, and an SDK package are all in the tree.
Why a unified workspace matters now
The README tells a story most small companies will recognise. The Macro team used the standard stack: Slack for chat, Linear for tasks, Notion for docs, HubSpot for CRM, Superhuman for email. Each product is good on its own. However, as their previous venture grew to roughly 20 people, the company was, in their words, held together by MCP and Zapier. Every team picked its own tools, and the company stopped being computable.
πΉ Video: Macro Setup Links GitHub PR Merges to Automatic Task Closure in One Workspace
Video credit: Alex Hitt
That phrase is the interesting part. When your work lives in five disconnected SaaS products, no single system can answer a simple question like “what is happening with this customer?” because the answer is scattered across an email thread, a chat channel, a ticket, and a CRM record that nobody updated. As a result, AI agents built on top of that mess inherit the mess. Macro’s bet is that the fix is not better integrations but a single system where email, messages, docs, tasks, and CRM records are natively linked.
The public repository is young; the product is not. The repo was created in November 2025, but as the team explains in Why Macro Is Open Source (7 August 2026), it went out as source-available first and was relicensed AGPL-3.0 later, because starting closed “was always a short term strategy as we figured out how to be even more open”. Meanwhile the README says the app has been dogfooded by their team of ~15 for two years. So November 2025 marks when the code went public, not when Macro was built, and it was not AGPL from day one. The latest release at the time of writing is v2026.8.11.0, published on 2026-08-11, with the last push to the repository on 2026-08-12. It has attracted 1,565 stars and 211 forks on GitHub, which is a measure of attention rather than a verdict on quality, but it does show the idea resonates. According to Macro’s homepage, the company has raised $30M+ and positions the product as replacing seven or more apps with one workspace.
How Macro works: blocks on one bidirectional graph
Macro is composed of what it calls blocks: modular surfaces for email, messages, tasks, docs, canvas, agents, calls, file storage, pull requests, and CRM. Each block is purpose-built for its job rather than assembled from a generic primitive, but every block shares the same backend. Cross-references between a doc and a task, or a channel message and an email, are stored natively as a bidirectional graph, so when you @mention a document in a channel message, both sides know about the link.
A keyboard-driven productivity app with unified search and command menu
Macro is keyboard-first throughout. According to the getting started guide, five keys cover most of the workflow:
copens the create launcher, thendfor a doc,tfor a task,efor an email,mfor a message,afor an AI chatcmd + kopens the command menu to jump to anything by name/runs unified search across email, docs, tasks, messages, calls, and filesj/kmove down and up in any listemarks an item done, archiving an email or clearing an inbox item
In addition, Macro has its own window manager. Pressing cmd + creates a split, and shift + enter opens any list item or @mention in a new split, so you can draft an email on the left while reviewing a prior thread on the right. The README says the layout scales to three or more splits depending on monitor size.
One inbox, split into Signal and Noise
Emails, channel messages, task assignments, @mentions, and agent responses all land in a single unified inbox, divided into Signal (needs your attention) and Noise (everything else). Because Macro is an email client rather than an email server, it syncs with your existing Gmail or Google Workspace account, and your mail stays in Gmail. Multiple accounts flow into the same view, and when you compose you choose which address to send from. Outlook and custom IMAP/SMTP support are listed as planned, not shipped.
Markdown-native docs on CRDTs
The docs block is a markdown-native document app tied to the team workspace, with real-time collaboration built on CRDTs and @mentions. According to Macro’s homepage, each document is a CRDT backed by its own Durable Object in the cloud: edits apply locally first, reconcile in the background, and offline changes replay automatically when you reconnect. Meanwhile, the README’s feature table describes the same block as real-time collaborative and markdown-native, so the two accounts line up.
Shared team-level memory: the piece most tools cannot copy
The feature Macro leans on hardest is shared AI memory at the team level. The homepage describes it as shared, team-level memory built nightly from your unified workspace, and the getting started guide explains what that buys you: agents remember what your whole team is doing across email, messages, tasks, docs, and calls, not just your own chats. In practice, that means you can ask “what’s the latest on the launch?” and the agent answers from your team’s recent emails, messages, tasks, docs, and call transcripts.
There are two ways to put that memory to work. First, pressing c a starts a chat with an agent that has access to your entire workspace, and mentioning @Macro in any channel pulls an agent into the conversation. Second, you can set up automations: scheduled agent runs, like a daily to-do summary, delivered to your inbox. The README adds that the agents’ tool and MCP surface is designed to work across inboxes; for example, a unified search tool lets agents search the text of file attachment PDFs parsed out of email directly, rather than pulling threads and then attachments.
βΉοΈ Note: Your coding agents can connect too. The getting started guide says you can point Claude Code, Codex, or any MCP client at your Macro workspace, and connect tools like Notion and Slack under Settings β Connectors so agents can reach them. The README gives the Claude Code command outright:
claude mcp add --transport http macro https://mcp-server.macro.com/mcpFrom there, Macro’s MCP setup and agent recipes pages cover what agents can do once connected. The README also notes there are no rate limits on MCP, and that the tool surface aims for near-complete coverage of what you can do in the UI.
Real workflows: how the blocks reinforce each other
Email that feeds tasks and CRM
From any email you can hit “task” to create a linked task, for example turning a customer support email into an engineering ticket. You can also @mention an email inside a document, like dropping @Re: Contract Signature.eml into Todos.md. Because Macro has native CRM objects, pressing cmd + k on a contact such as tim@acme.com shows every email between you and that person, and a company view like @acme.com aggregates all emails and files between your team and everyone at that company. That aggregation is also available to agents, so they can answer CRM-type questions directly, without you opening a heavyweight CRM like HubSpot or Salesforce.
Tasks that live where the conversation happens
Macro’s tasks are Linear-inspired and tightly integrated with channels, email, and agents. Consequently, creation happens where the work already is: from an email, from anywhere with c t, by mentioning @Macro in a channel or DM, or inside an agent chat. With the GitHub integration linked in Settings, tasks then move through “In Progress”, “In Review”, and “Done” as you branch, open PRs, and merge, so the ticket state tracks the code instead of waiting for someone to update it.
Permissions without the sharing dance
Anything you @mention in a channel is automatically shared with that channel’s members. Join a channel and you gain access; leave and you lose it. Similarly, teams get auto-sharing by default: tasks are visible to the whole team, and calls are recorded, transcribed, and shared, then logged to team memory for agents. You can also add anyone to a channel by email, even if they don’t have a Macro account yet.
Under the hood and what the licence means
The repository is a large Rust and TypeScript monorepo. The README’s layout section counts 167 Rust libraries under crates/ (domain logic, models, db clients) and 42 deployable services, workers, and Lambda handlers under services/, with the SolidJS client β browser, Tauri desktop, and mobile β under apps/web/ and shared TypeScript under packages/. Services follow a hexagonal layout: inbound adapters, a domain core with ports, outbound adapters. The primary language is Rust, and the README credits SolidJS and Rust for the speed.
On licensing, the repository is published under the GNU Affero General Public License v3.0 (AGPL-3.0) β “fully open source,” as the README puts it, “not ‘open core’.” You can self-host under the AGPLv3 terms, and the README points at the FAQ for what that involves; a different licence for building on top, or managed hosting, means emailing the company.
Running it yourself
Self-hosting is documented, and the repo ships the tooling: a flake.nix dev shell, a justfile, a Docker Compose stack under docker/, and Pulumi definitions under infra/. Per Running locally, the prerequisites are Nix and Docker with the Compose v2 plugin, and then:
git clone https://github.com/macro-inc/macro.git
cd macro
nix develop
just run_local --no-dopplerThe Nix shell supplies just, Cargo, the Rust toolchain, Bun, sqlx, and zig, so nothing else needs installing. just run_local then builds the Rust services, starts Postgres, Redis, LocalStack, OpenSearch, Kafka, and FusionAuth in Docker, brings up the proxy and frontend, and prints the URLs. Auth, documents, email, and search are fully functional on the stubbed config; the third-party integrations (Google, GitHub, Stripe, CloudFront) run on dummy values until you pass real keys with --env-file. Doppler is only for people on the team who want real cloud secrets β --no-doppler is documented as the common contributor path. It is a real self-host story rather than a gesture, but note what you are signing up to operate: six pieces of backing infrastructure, 42 services, and 167 Rust crates.
Where Macro still has gaps
A few limitations are stated plainly in the material. Email support is Gmail and Google Workspace only, with Outlook and custom IMAP/SMTP still planned. The public repository is less than a year old and was only relicensed AGPL-3.0 after an initial source-available period, so the API surface and the packaging around self-hosting should be expected to move. That is a different risk from an immature product, though: the app behind the repo has been in daily internal use by a team of ~15 for about two years, so the churn to expect is in how the code is shipped and licensed, not in whether the thing works. On the other hand, the pace is visible: the latest release, v2026.8.11.0, shipped on 2026-08-11, and the repository saw a push the following day.
People Also Ask
What is Macro used for?
Macro is used as a single workspace that replaces a stack of separate tools: email, team chat, documents, task management, calls, file storage, and CRM. Everything is @linked and searchable in one system, so teams and AI agents can work from the same context instead of switching between apps.
Is Macro open source?
Yes. The GitHub repository macro-inc/macro is licensed AGPL-3.0, and Macro’s homepage explicitly invites you to contribute, fork, extend, and self-host. The full monorepo, including the Rust backend crates, services, and web app, is public.
What features does Macro combine in one workspace?
The core blocks are Email (multi-account unified inbox for Gmail), Messages (channels and DMs), Tasks, Docs (markdown-native, CRDT-based), Canvas (a 2D board), Agents, Calls (recorded and transcribed), File storage, Pull requests, and CRM. All blocks share one backend and a bidirectional link graph.
How does shared team-level memory work in Macro?
Macro builds a shared, team-level memory nightly from the unified workspace, covering email, messages, tasks, docs, and calls. Agents can then answer questions from that whole context, and you can also reach it from external tools: the getting started guide says Claude Code, Codex, or any MCP client can be pointed at your workspace.
Does Macro support email, chat, docs, and tasks?
Yes, all four are first-party blocks in the same interface. Email syncs with Gmail or Google Workspace, chat is organised into channels and direct messages, docs are real-time collaborative markdown on CRDTs, and tasks can be created from emails, channels, or agent chats with links back to their source.
Who should try Macro, and who should wait
Macro makes the most sense for small companies, or teams inside larger ones, that already feel the pain of a fragmented stack and want their agents to see the whole business, not one slice of it. The keyboard-first design and Gmail-only email support mean it skews toward technical teams on Google Workspace. Self-hosting is genuinely on the table, with documented commands, but it means running the stack yourself; organisations that want a turnkey supported deployment will be talking to the company instead. Teams on Outlook, meanwhile, should treat Macro as a project to watch rather than a drop-in replacement this quarter.
The sharpest idea here is not any single block. It is the claim that a company should be computable: one system, one permission model, one memory, with humans and agents reading the same graph. Whether Macro executes that vision at scale is still an open question, but the codebase is public, the licence is genuinely open, and the design argument is worth reading even if you never switch.
π― What you now know about Macro
Macro is an open source (AGPL-3.0) workspace combining email, chat, docs, tasks, calls, CRM, and AI agents in one Rust and SolidJS system.
Every block shares one backend, and cross-references are stored as a bidirectional graph, so context is traceable in both directions.
Team-level memory is built nightly from real work activity and is reachable by in-app agents and external MCP clients like Claude Code or Codex.
It is keyboard-first, with a unified inbox split into Signal and Noise, a command menu, and a built-in window manager.
Self-hosting is documented: Nix plus Docker, then
git cloneβnix developβjust run_local --no-dopplerbrings up the whole stack locally.Current limits: Gmail and Google Workspace only, and a public repo opened in November 2025 as source-available before the AGPL-3.0 relicence β though the app itself has been dogfooded internally for about two years.