Macro: The Open-Source Unified Workspace With 2,400+ GitHub Stars That Replaces Slack, Linear, Notion, and HubSpot for AI-Powered Teams

If you've ever felt like your team's work is scattered across five different tools, you're not alone. Most startups and small teams end up using Slack for chat, Linear for tasks, Notion for docs, HubSpot for CRM, and Superhuman for email. These are all great products individually, but they don't work together as one system. That's where Macro comes in.

Macro is an open-source unified workspace that treats your entire company as a single computable system. Instead of stitching together tools with MCP connectors and Zapier automations, Macro builds everything from the ground up with shared team-level memory, bidirectional @links, and first-class AI agent support. With over 2,400 GitHub stars and 1,180 new stars just today, it's quickly becoming the go-to operating system for AI-powered teams.

What Is Macro and Why Does It Matter?

Macro is a complete redesign of work software built as a single unified system. It combines email, messages, docs, tasks, agents, calls, CRM, and file storage into one fast interface designed for technical teams who want their company to be "computable" rather than chaotic.

The project was born from frustration. The Macro team built their last venture to around 20 people using the usual suspects: Slack, Linear, Notion, HubSpot, and Superhuman. But as they scaled, things started to break. Every team got their own tools, and the company was held together by MCP integrations and Zapier workflows. The company wasn't computable—it was chaotic.

Macro fixes this by treating your workspace like an operating system. Everything is @linked and searchable. When you mention a task in a chat message, it's bidirectionally linked. When you @mention a company record in a message, your team can click to see the latest status without navigating to a separate CRM. And when your AI agents need context, they can search across emails, docs, tasks, and messages as one unified graph.

Key Features That Make Macro Stand Out

1. Unified Inbox with Multi-Account Support

Macro Mail is inspired by Superhuman's keyboard-first interface but adds crucial capabilities for teams working with AI agents:

• Multi-account inbox: Triage all your Google accounts in a single inbox with shared tagging and permissions
• Unified inbox: Emails, messages, @mentions, and tasks to complete all in the same list—navigate with j, k, and e
• Better AI integration: Exposes a unified search tool that allows agents to search all file attachment PDFs directly, rather than pulling email threads then attachments
• Agent-native email: Draft, edit, and send emails right from AI chats without opening your email client
• Built-in window manager: Create 3+ splits so you can draft emails while reviewing prior threads

The key innovation is that Macro's email system is designed for agents from day one. Instead of bolting on AI as an afterthought, Macro exposes MCP tools that let agents search, draft, and send emails with full context of your team's communication history.

2. Focused Chat Designed for Technical Conversations

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. But the real power is in how everything is stored:

• Bidirectional graph: Tasks @link to messages that created them, customer support emails tie into support channels, CRM records get updated when they're discussed in messages
• Thread permissions: Share threads across channels by copying links—each thread is permissioned severally
• Agent-first citizens: Agents are first-class participants like human users, with the same permissions and @link capabilities

The core idea is that messaging should be the centerpiece around which tasks, mail, docs, and content management are built. And in 2026, that means agents need to be native participants, not bolted-on integrations.

3. Tasks That Actually Stay Up to Date

Linear recently published a report that issue tracking is dead. The Macro team agrees—but the stronger form is that issue tracking never really worked. The core problem with traditional issue trackers is that they get out of date because they're a separate system from where the conversation really happens.

Macro's solution is lightweight issues tightly coupled to your channels and DMs, so that issue tracking naturally occurs where the conversation itself happens. Creating tasks is easy:

• Create a task from an email with one click
• From anywhere via Cmd+T
• From a markdown doc with /task
• From any checkbox bullet by highlighting and clicking "Task"
• @Macro create tasks in any channel or DM
• In any agent chat
• Via external MCP, API, or SDK

Where possible, tasks created are bidirectionally linked to the creating context—so the full chain is auditable from "why are we doing this" → task → agent → pull request, all in one system.

4. Real-Time Docs with Agent-Native Editing

Macro Docs is a markdown-native editor built on CRDTs (Conflict-free Replicated Data Types) and Cloudflare durable objects:

• Native markdown: Full markdown compatibility with bulk import/export following the "file over app" paradigm
• Live collaboration: Edits come in ~instantly instead of ka-chunking like Google Docs
• Version control: History and forking with a neat UI for scrubbing history
• Offline editing: Work offline and reconcile when you reconnect
• @linked to everything: Email, docs, tasks, messages, channels, companies, contacts—like Notion but multi-modal
• Agent-native editing: Agents operate as peers in the CRDT collaboration system like human collaborators

One interesting use case is maintaining team-context documents. For example, the Macro team has an automation that runs daily to update their in-office Pool Games markdown doc. It scans through all channels to see if anyone has won, then updates the doc. If somebody has already edited it, the agent knows and can forgo the update. Conflicts are handled natively by the CRDT system.

5. CRM That Doesn't Get Out of 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 the latest status on a deal, you still have to message the AE/SDR and ask for context.

Macro fixes this by colocating your CRM with your team chat and email:

• @mention company records: When you @mention a company record in a message, your team can click to see the latest status—much faster than navigating to your CRM
• Bidirectional links: @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
• Email aggregation: All emails and files between everyone on your team and everyone at that company, e.g. @acme.com

This fixes the core issue with Attio, HubSpot, and 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.

Real-World Example: How Macro Replaces Your Tool Stack

Let's say you're a 15-person startup currently using:

• Slack for team chat
• Linear for task tracking
• Notion for documentation
• HubSpot for CRM
• Superhuman for email

With Macro, you'd have:

1. Email: Multi-account unified inbox with keyboard shortcuts and shared inboxes (replaces Superhuman)
2. Messages: Channels and DMs designed for focused technical discussions (replaces Slack)
3. Tasks: Linear-inspired tasks tightly integrated with channels, email, and agents (replaces Linear)
4. Docs: Real-time collaborative markdown-native docs with @mentions (replaces Notion)
5. CRM: Customer and contact objects with email sync and enrichment (replaces HubSpot)
6. Agents: Unified team-level memory that can take action on your behalf
7. Calls: Recorded, transcribed, and logged to team memory for agents
8. File storage: Auto-imported from email and channels, fully searchable
9. Pull requests: Linked to tasks, embeddable in channels, available to agents (GitHub integration)

The key difference isn't just that you have all these features in one place—it's that they're all @linked and share 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. Your AI agents can search across all of it with full context.

Key Benefits of Using Macro

• Single source of truth: Everything in your workspace is @linked and searchable—no more context switching between tools
• Agent-native design: AI agents are first-class citizens with the same permissions and @link capabilities as human users
• Built for speed: Built in SolidJS and Rust for performance and reliability
• Modular architecture: Composed of 'blocks' designed to be modular, extensible, and work together like Lego
• Team-level memory: Shared memory that your agents can access to assist with CRM queries, task creation, and context retrieval
• Open source: Fully open-source with active community development
• Mobile-friendly: iOS app available, Android coming soon
• Keyboard-first: Designed for power users who want to navigate without a mouse

FAQ

Is Macro really a replacement for Slack, Linear, Notion, and HubSpot?

Yes, Macro is designed to replace all of these tools with a single unified system. However, it's not about feature parity—it's about integration. Macro's chat is more focused than Slack's, its tasks are lighter than Linear's, its docs are more markdown-native than Notion's, and its CRM is simpler than HubSpot's. The value is that they all share the same backend and bidirectional graph, so your team and agents never have to switch tools.

How does Macro handle AI agents differently from other tools?

Most tools bolt on AI as an afterthought with limited integrations. Macro treats agents as first-class citizens from day one. Agents have the same permissions as human users, can @link to any object in the workspace, and can participate in CRDT-based document editing as peers. Macro also exposes MCP tools that allow agents to search across emails, docs, tasks, and messages as one unified graph, giving them full context of your team's work.

Can I use Macro if I'm not a technical team?

Macro is designed for technical teams and startups, but it's accessible to any small company or team at a larger company that wants a single "operating system" for their work. The keyboard-first interface and markdown-native docs may appeal more to developers, but the core value—unified workspace with shared memory—applies to any team struggling with tool fragmentation.

Is Macro open source and self-hostable?

Yes, Macro is fully open source and available on GitHub. You can self-host it if you want full control over your data. The project is built in SolidJS and Rust, and the team has been dogfooding it for two years with their own ~15 person team, so it's production-ready.

How does Macro's CRM compare to HubSpot or Attio?

Macro's CRM is simpler and more integrated than HubSpot or Attio. The key innovation is that CRM records are colocated with your team chat and email, so when you @mention a company record in a message, your team can click to see the latest status without navigating to a separate CRM. Email aggregation by Company/Contact/Deal is built-in, and bidirectional links let you trace conversations from the CRM record. It's not as feature-rich as HubSpot for enterprise sales workflows, but it's more up-to-date because it's integrated with where the actual conversations happen.

What's the learning curve for switching to Macro?

If you're comfortable with keyboard shortcuts and markdown, the learning curve is minimal. Macro's interface is inspired by Superhuman's keyboard-first design, so if you've used that, you'll feel at home. The main adjustment is getting used to @linking everything together instead of copy-pasting between tools. The Macro team provides comprehensive documentation and the community is active on GitHub for support.

Does Macro integrate with GitHub?

Yes, Macro has native GitHub integration for pull requests. PRs are linked to tasks, embeddable in channels, and available to agents. This means you can create a task from a customer email, assign it to an engineer, and when they open a PR, it's automatically linked back to the original email—all within Macro without switching to GitHub's web interface.

Conclusion

Macro represents a fundamental shift in how we think about work software. Instead of stitching together best-in-class tools with integrations and automations, Macro builds everything from the ground up as a single system. With over 2,400 GitHub stars and rapid adoption by technical teams, it's proving that there's real demand for a unified workspace designed for the AI era.

If you're tired of context switching between Slack, Linear, Notion, HubSpot, and email—and you want your AI agents to have full visibility into your team's work—Macro is worth a serious look. It's open source, it's fast, and it's built by a team that lived the problem they're solving.

Ready to try Macro? Check out the GitHub repository to get started, or visit macro.com for the hosted version. And if you're building AI-powered tools and want to level up your development skills, check out CoddyKit's courses on modern web development and AI integration.