Multi-agent demos often hide the most difficult engineering problem.
Disclosure: I used AI tools to assist with research organization and drafting. I reviewed, edited, fact-checked, and source-checked this article before publication.
Spawning workers is not collaboration. A collaborative system must manage context, permissions, handoffs, concurrent state, and verification across humans and agents.
Macro is a workspace that describes its open-source decision publicly and is useful to examine through this lens. Its official repository is published at macro-inc/macro. The root license presents AGPLv3, but a nested web-app license says all rights reserved. That conflict matters and is covered below. The published stack includes Rust and SolidJS. Macro connects documents, email, tasks, calls, channels, CRM, memory, and agents.
I am using Macro and forked the repository. On August 19, 2026, GitHub compare showed the fork's main
identical to upstream main
, 0 commits ahead and 0 behind, at 02c218308c462046ee54e6f275b8c0a371ee3f5a
.
Important scope note: no local clone, modified branch, self-hosted deployment, or benchmark is claimed in this article. The walkthrough maps verified repository and documentation claims to a reproducible evaluation plan. It does not pretend I ran tests for which I have no artifact.
At review time, the official repository showed:
| Item | Snapshot on 2026-08-19 |
|---|---|
| Stars | 3,696 |
| Forks | 362 |
Commits in main history |
|
| 5,066 | |
| Open issues | 19 |
| Open pull requests | 51 |
| Tags | 213 |
| Latest visible release | v2026.8.18.2 |
| Reviewed commit | 02c218308c462046ee54e6f275b8c0a371ee3f5a |
These are activity signals, not performance results. The latest values will change.
The cover uses Macro's older embedded star-history snapshot, which shows 3,608 stars. The live count at this review checkpoint was 3,696.
Macro said on August 13 that the repository briefly reached number one on GitHub Trending. The company said on August 12 that it had received an influx of users, pull requests, and feature requests. Both are attributed company statements.
If you want to inspect the same fork, begin by recording the exact source state. The commands below verify Git identity only. They do not install or run Macro.
git clone https://github.com/harshith-vaddiparthy/macro.git
cd macro
git remote add upstream https://github.com/macro-inc/macro.git
git fetch upstream main
git remote -v
git status --short
git rev-parse HEAD
git rev-parse upstream/main
git rev-list --left-right --count upstream/main...HEAD
git log -1 --oneline
Before building, compare the full SHA with the current upstream default branch and read the repository's current README. Do not assume dependencies or setup commands from this dated article are still correct.
The root LICENSE.txt presents AGPLv3. The same reviewed tree contains
apps/web/LICENSE
Copyright 2023 CoParse, Inc. All rights reserved.
Those terms conflict with a repository-wide assumption that every file is AGPLv3. The affected scope needs clarification from Macro's maintainers. Until then, do not assume every web-app file, screenshot, or asset can be reused under the root license.
This article does not decide which terms control. Before modifying, distributing, hosting, or reusing repository material, inspect the applicable path, request maintainer clarification, and obtain appropriate legal advice.
The documented system can be understood as six connected layers:
Work surfaces
email | tasks | documents | calls | channels | CRM
|
v
Shared memory refreshed nightly from team activity
|
explicit context via @mentions
|
v
Agents operating under the user's permissions
|
read | draft | write | update | post | automate
|
v
Shared document state using CRDT collaboration
|
v
External coding agents through an MCP endpoint
This is an editorial model based on Macro's website, documentation, and README. It is not a literal internal service diagram.
Macro's Agents documentation says agents can access email, tasks, documents, calls, and channels under the user's permissions. Documented actions include search and read, document writing, task and CRM updates, email drafting, channel posts, call reading, and automation.
The engineering advantage is context locality. The agent does not need a separate integration for every step if the workspace already exposes the relevant object and action.
The risk is authority aggregation. A workspace that unifies several tools can give one agent a broad action surface. The permission model, confirmation boundaries, audit trail, and revocation behavior therefore matter as much as tool coverage.
Macro's Unified Memory documentation says memory refreshes nightly from team activity.
A shared memory layer can reduce repeated context assembly. It can also create subtle failure modes:
Test memory against the latency of the workflow. A nightly refresh may fit a weekly recap. It may not fit an incident response or a decision made minutes ago.
Macro's Agents documentation presents @mentions
as a way to pin context for an agent.
This gives the system two retrieval modes:
That distinction is useful because retrieval relevance is not the same as authority. The closest semantic match may not be the document that governs the current decision. Pinning context creates a direct signal about which source matters now.
The official repository includes an agent task-handoff screenshot. A handoff is the state boundary between actors, so evaluate it as structured data rather than a friendly message.
A robust handoff should preserve at least:
goal: "What outcome are we trying to produce?"
source_artifacts:
- "Which documents, calls, tasks, or messages govern the work?"
completed_work:
- "What has already changed?"
open_questions:
- "What remains unresolved?"
next_action: "What should happen next?"
owner: "Which person or agent is responsible now?"
verification: "How can the next actor check the claims?"
This YAML is an evaluation template, not Macro configuration.
Macro's Documents documentation says its documents use CRDTs with Cloudflare Durable Objects. The README describes swarms of agents acting as peers in CRDT collaboration.
A conflict-free replicated data type allows concurrent updates to converge without using a simple last-write-wins overwrite. This is relevant when humans and several agents edit a shared document.
CRDTs solve a state problem. They do not solve a meaning problem.
Two changes can merge correctly and contradict each other. One agent can add a decision while another rewrites the assumption behind it. A production workflow still needs editorial ownership, review boundaries, and a way to identify which claims require verification.
Useful CRDT tests include:
Measure both state convergence and semantic coherence.
Macro's MCP overview names Claude Code and Codex CLI. Its Agents documentation separately names Cursor. MCP gives an AI client a standard interface to external context and tools.
The valuable pattern is a closed state loop:
shared task -> coding agent -> repository work -> task update -> team recap
An integration is incomplete if it only sends context to the agent. The agent should return a structured status, evidence, and unresolved questions to the workspace where the team coordinates.
Macro's published Agent Recipes include MCP-driven coding-agent task updates, along with daily briefs, project status, weekly recap, call-to-tasks, draft email, and channel summary.
A weekly project recap is a good first workflow because it is recurring, reviewable, and reversible.
Define the test before connecting broad authority:
| Test dimension | Question | Evidence to capture |
|---|---|---|
| Context | Did the agent use the governing sources? | Source links and retrieval trace |
| Freshness | Did it include a recent change? | Source timestamp versus output timestamp |
| Permission | Could it access only allowed objects? | Account role and denied-access test |
| Handoff | Did it preserve owners and open questions? | Structured comparison with source tasks |
| Action boundary | Did it draft or mutate shared state? | Before and after object state |
| Concurrency | What happened during a conflicting edit? | Revision history and final document |
| Verification | Can a human reconstruct the output? | Action log, citations, and correction record |
Run the workflow in three rounds:
The primary metric should be correction cost. Record how long a person spends finding missing context, checking claims, fixing ownership, and restoring state. Fast generation does not help if review becomes expensive.
Macro's direction connects several primitives that are often separated:
The combination is the important part. An agent becomes more useful when it can read current work, make a bounded contribution, and return state that another person or agent can continue.
This review does not establish:
02c218308c462046ee54e6f275b8c0a371ee3f5a
.Those are test targets, not conclusions to smuggle into a launch post.
The hard part of multi-agent software is not multiplying workers. It is coordinating context, authority, shared state, handoffs, and verification.
Macro is worth studying because its public architecture addresses those concerns directly. Shared memory gives agents organizational context. @mentions
narrow attention. Permission-bound actions connect context to work. CRDTs support concurrent collaboration. MCP can return coding-agent state to the team's workspace. Studying public code is different from assuming every path has uniform reuse terms, so the nested-license conflict remains a real diligence item.
None of these features eliminates the need for verification. Together, they provide a concrete public system against which developers can test collaboration claims.
Credit to Jacob Beckerman, whose profile identifies him as Macro's founder and CEO, and the Macro team for publishing the work. This is an independent technical analysis and does not imply endorsement.
For the broader product argument, FAQ, sources, and dated updates, read the canonical guide.