Macro open source: a practical guide to agent collaboration
A source-backed guide to Macro's open-source repository, shared memory, agent collaboration model, MCP support, architecture, and practical tradeoffs.
The short version Macro combines documents, email, tasks, calls, channels, CRM, memory, and agents in one workspace that the company describes as fully open source. The useful systems question is not how many agents can run. It is whether context, permissions, handoffs, concurrent work, and verification survive between them. Macro exposes serious collaboration primitives, but architecture and screenshots are not proof of production reliability. Test one bounded workflow and measure correction cost. This guide was reviewed on August 19, 2026 against upstream and fork revision 02c218308c462046ee54e6f275b8c0a371ee3f5a.
Most AI agent demos are built around a single intelligent worker. Real work is rarely that clean.
A project brief lives in a document. Customer context sits in email and CRM. Decisions happen in calls and channels. Tasks move between people. Permissions differ. Two collaborators can edit the same artifact at the same time. Someone still has to decide what is true, what changed, and what happens next.
That is why the next important layer in agentic software is not simply a more capable agent. It is collaboration.
Macro is interesting in this context because it brings documents, email, tasks, calls, channels, CRM, memory, and agents into one system that the company describes as fully open source. Its public repository is built with Rust and SolidJS, has an AGPLv3 license at the root, and connects to a product that treats shared memory as a core capability.
I have forked Macro's repository, and I am using Macro. I want to be precise about the evidence behind those statements. The public fork proves that the fork exists; its main branch was identical to upstream main, 0 ahead and 0 behind, at the reviewed revision on August 19, 2026. It does not prove a local modification, self-hosted deployment, or specific outcome. I will not invent a case study where one does not yet exist.
A public fork is not a benchmark. This guide analyzes Macro's published code, website, and documentation. It does not claim a modified fork, a self-hosted deployment, or a measured business result.
What is Macro?
Macro is a collaborative workspace for documents, email, tasks, calls, messages, CRM, and agents. The company describes it as fully open source and publishes the repository at macro-inc/macro. The license-scope caveat below is important when evaluating reuse.
The basic product idea is straightforward: agents are more useful when they can work with the same organizational context as the people directing them.
According to Macro's agent documentation, an agent can access email, tasks, documents, calls, and channels under the user's permissions. Agents can search and read information, write documents, create or update tasks and CRM records, draft email, post to channels, read calls, and run automations. Macro's MCP overview documents setup for Codex CLI and Claude Code, with generic IDE configuration; its Agents documentation also names Cursor.
That is broader than attaching a chatbot to a folder. Macro is trying to make the workspace itself the context and action layer for agents. A model may be capable of reasoning, but it cannot reliably help a team if it lacks the right context, cannot act where work lives, or has no safe way to hand work back to a person or another agent.
What exactly is open source?
Macro's official repository is public, and its root license is the GNU Affero General Public License v3.0. The codebase includes Rust and SolidJS, and the repository contains application code, documentation, release history, issues, pull requests, and official product screenshots.
The reviewed tree contains a conflicting nested license. At the reviewed revision, apps/web/LICENSE says: Copyright 2023 CoParse, Inc. All rights reserved. That file entered the repository after the root switched to AGPLv3. I am not assuming which license controls the affected files. Maintainer clarification is needed.
AGPLv3 is a strong copyleft license designed to keep modified versions available to users, including when software is operated over a network. Anyone evaluating a commercial deployment should read the license and get appropriate legal advice for their distribution and hosting model.
Open source does not mean every claim has been independently proven. It also does not mean every file, logo, asset, or trademark can be reused without checking its applicable terms. The public repository does provide inspectability: builders can read the implementation, follow changes, open issues, propose pull requests, and fork the project.
That changes the quality of the conversation. We do not have to evaluate Macro only through product copy. We can compare its stated model with a real source tree and a visible development process.
The five layers of useful agent collaboration
The phrase multi-agent system can make a product sound more complete than it is. Running several agents is not the same as making them collaborate.
A practical scorecard for evaluating collaborative agent systems Shared context Can agents use the same relevant information? Unified memory plus pinned context Permission boundaries Can each agent act only where the user is authorized? Actions operate under the user's permissions Explicit handoffs Can responsibility and context survive between actors? Mentions, linked artifacts, and task handoffs Concurrent work Can participants edit without silently losing state? CRDT documents with Durable Objects Verification Can a human reconstruct actions and judge the result? Must be tested in the target workflow
Macro describes a unified memory that refreshes nightly from team activity. That memory draws from work surfaces connected to the product, including documents, messages, tasks, calls, email, and CRM.
The appeal is clear. Instead of copying context into each prompt, teams can give agents access to an organized memory of ongoing work.
What information enters memory, and what is excluded? How are conflicting facts resolved? How quickly does a critical update become available? Can a user inspect why an agent retrieved a particular item? How do retention and deletion propagate?
A nightly refresh can be useful for briefs, recaps, and status summaries. It may be too slow for a decision made five minutes ago. Builders should test freshness against the workflow, not treat memory as one universal capability.
Macro's documentation says agents operate under the user's permissions. This is the right starting point because an agent should not become a shortcut around access control.
The documented action surface is meaningful. Agents can read and search, write documents, update tasks or CRM, draft email, post to channels, read calls, and automate work.
But a capability list is not a security evaluation. Teams still need to understand how permissions are inherited, whether sensitive actions require confirmation, what audit records exist, and how revocation works. Drafting an email and sending an email are materially different actions. Reading a task and changing its owner are materially different actions.
The product judgment is not: Can an agent act? It is: Can an agent act with the smallest necessary authority, and can a person reconstruct what it did? Harshith Vaddiparthy
Macro documents @mentions as a way to pin context for an agent. This is a small interaction with a large systems implication. Shared memory can be broad. A mention is specific. It tells the agent that this artifact matters to the work being requested now.
That reduces a common failure mode in agent systems: retrieving something relevant in topic but wrong in circumstance. Explicitly pinned context does not guarantee a correct result, but it gives users a direct mechanism to narrow the working set.
The repository also shows an agent task-handoff interface. Handoffs matter because collaboration requires state transitions. A useful handoff should preserve the goal, relevant artifacts, completed work, open questions, and the next responsible actor. The screenshot is evidence that Macro treats handoff as a product surface. It is not evidence that every handoff preserves those elements reliably.
Macro says its document layer uses conflict-free replicated data types, commonly called CRDTs, with Cloudflare Durable Objects. The repository README describes swarms of agents acting as peers in CRDT collaboration.
A CRDT is a data structure designed so concurrent changes can converge instead of one participant's edit simply overwriting another's. That makes it relevant when humans and agents work on the same document.
This is one of the more technically interesting parts of Macro's approach. The agents are not described only as external automation workers. They can participate as peers in a shared collaboration model.
Still, data convergence is not the same as semantic agreement. Two edits can merge successfully and produce a bad document. One agent can add a correct paragraph while another changes the premise beneath it. CRDTs help solve concurrent state. They do not remove the need for ownership, review, or judgment.
Infrastructure can prevent lost updates. It cannot decide whether the combined result is coherent. Safe shared state is necessary for collaboration, but editorial ownership and human judgment remain part of the product.
The repository and documentation show a serious collaboration direction. They do not, by themselves, answer the questions that determine production trust:
Does an agent cite the context behind an important action? Can a user see a complete action history? Are destructive actions separated from reversible drafts? Can one agent verify another agent's output without repeating the same failure? How does the system handle stale memory or contradictory instructions? What happens when several agents update related records at once?
These are not objections to Macro. They are the tests that any collaborative agent system should expect.
The recipes reveal the product thesis
Macro's official agent recipes include a daily brief, project status, weekly recap, call-to-tasks, draft email, channel summary, and MCP-driven task updates from a coding agent.
Daily brief. Compresses recent activity into an operating view. Project status. Turns scattered updates into a shared summary. Call to tasks. Converts conversation into accountable work. Draft email. Uses context to prepare communication without necessarily sending it. Channel summary. Reduces the cost of catching up. Coding-agent updates. Return implementation progress to the team's shared workspace through MCP.
The common pattern is not autonomous spectacle. It is continuity. Agents read from the work graph, make a bounded contribution, and return state to the place where the team already coordinates. That is the collaboration model worth studying.
Why MCP support matters
Macro documents an MCP endpoint for Codex CLI and Claude Code, plus a generic IDE configuration path. Macro's Agents documentation also names Cursor. MCP, or Model Context Protocol, gives an AI client a standard way to connect to external tools and context.
The practical value is not the acronym. It is the loop it can enable. A coding agent can work in a repository, then use the shared workspace to read the relevant task and update its status. A product agent can see that update when preparing a recap. A human can review the shared task instead of reconstructing progress from several disconnected chats.
This is the difference between connecting more tools and closing a workflow. The integration becomes valuable when state returns to the team in a form other people and agents can use.
What the public activity tells us, and what it does not
At the August 19, 2026 review checkpoint, the official repository showed 3,696 stars, 362 forks, 5,066 commits in main-branch history, 19 open issues, 51 open pull requests, 213 tags, and a latest visible release of v2026.8.18.2.
The official star-history visual used above is an older embedded snapshot showing 3,608 stars. The live repository count observed for this guide was 3,696.
Macro said on August 13 that the repository had trended on GitHub and briefly reached number one. It said on August 12 that it had seen an influx of users, pull requests, and feature requests.
Those are useful momentum signals. They are not proof of long-term adoption, reliability, or community health. Stars are attention. Pull requests are proposed work. Releases are shipped artifacts. Stronger questions are whether maintainers keep responding, documentation stays accurate, contributors can get changes reviewed, issues lead to improvements, and users return after the initial attention wave.
I would not be surprised to see Macro's repository continue growing if the team sustains useful releases, clear documentation, and a credible contributor path. That is a prediction, not a fact.
How I would evaluate Macro in practice
If you are considering Macro, do not begin with a grand autonomous workflow. Begin with one recurring coordination problem.
Choose a bounded workflow. Pick something observable and reversible, such as a weekly project recap or converting a call into draft tasks. Avoid external communication or critical-record changes in the first test. Define the source of truth. List the documents, calls, channels, tasks, or emails the agent should use. Confirm that the user's permissions match the intended scope. Pin critical context. Use the documented @mention pattern where relevant. Do not rely only on broad retrieval when one source must govern the result. Separate drafting from execution. Ask the agent to prepare a recap, draft tasks, or draft an email before allowing it to publish or send anything. Review what it used and what it omitted. Inspect the handoff. Check whether the output preserves the goal, decisions, owners, due dates, open questions, and links back to evidence. A polished paragraph that loses ownership is not a useful handoff. Introduce a conflict. Change a relevant document or task while the workflow is in progress. Observe how the system handles fresh, stale, and contradictory state. Measure correction cost. Measure the human work required to detect and correct mistakes. A fast automation with expensive review is not necessarily a win.
Who should pay attention?
Product and engineering teams with work spread across documents, tasks, calls, and channels. Agent workflows that need shared context rather than isolated prompts. Collaborative documents where humans and agents may edit concurrently. Coding-agent loops that should report progress into a team workspace. Self-hosted or source-inspectable systems where the clarified license scope fits the intended use.
Macro may be less compelling if your need is a single narrow automation with one data source and no collaborative state. Multi-agent infrastructure adds moving parts. Use it when the coordination problem is real.
The bigger lesson: agents need an operating environment
The current agent conversation often focuses on model intelligence. Which model reasons better? Which one calls tools more accurately? How many agents can we run? Those questions matter, but they are incomplete.
An agent working inside a team needs an operating environment. It needs current context, permission boundaries, shared artifacts, explicit handoffs, concurrent-state handling, action history, and human review. Without those pieces, a swarm is only several isolated workers producing more output for someone else to reconcile.
Macro's open-source repository makes that systems problem visible. Shared memory addresses context. Permission-bound access addresses scope. Mentions address focus. CRDT collaboration addresses concurrent state. MCP extends the workspace to external agents. Recipes connect those primitives to repeatable work.
The result should not be treated as proven merely because the architecture is interesting. It should be tested precisely because the architecture is interesting.
Credit to Jacob Beckerman and the Macro team for building in public. This is independent analysis and does not imply their endorsement.
I still do not know how the team landed macro.com. It is an unusually strong domain.
I publish practical field notes on building and operating AI systems, with the implementation details and limitations left in. Join the newsletter.
Harshith Vaddiparthy works with founders, operators, and teams on practical AI products, workflows, advisory, training, and mentorship. This no-JavaScript version preserves the page's core information and navigation.