Macro Inc. Development Roadmap: AI-Native Workspace Architecture and Microservices

Macro Inc. is building a unified, AI-powered productivity platform that combines email, chat, documents, and real-time collaboration into a single workspace powered by a Rust-based microservices architecture with over 80 crates.

The Macro Inc. development roadmap centers on creating a seamless, AI-native workspace that eliminates context switching between communication and creation tools. According to the macro-inc/macro source code, the platform is engineered as a large Rust Cargo workspace comprising more than 80 specialized crates, complemented by SolidJS frontends and TypeScript SDKs. The architecture emphasizes real-time collaboration, AI-enhanced document editing, and cloud-native microservices that communicate through event-driven patterns.

Core Architecture of the Macro Platform

The repository follows a layered architecture separating presentation, business logic, and data persistence. Each layer utilizes specific technologies optimized for performance and type safety.

Frontend and Client SDK

The Application Front-end lives in apps/web and apps/docs, implemented in SolidJS with Tauri for cross-platform desktop support. These applications render Macro blocks, @mentions, and AI-powered pop-ups. Developers interact with the platform through the TypeScript SDK (@macro/sdk) located in packages/sdk/README.md, which exposes typed APIs for creating blocks and invoking AI agents.

import { Macro } from '@macro/sdk';

const macro = new Macro({});
await macro.storage.createBlock({
  type: 'document',
  title: 'Welcome to Macro!',
  content: '# Macro Overview\nMacro unifies email, chat, docs, and tasks.',

});

Microservices Backend

The backend consists of over 30 independent services in the services/ directory, each handling distinct domains like document storage, search, and email synchronization. Services communicate via HTTP, Amazon SQS, Lambda functions, and Redis, enabling event-driven scalability. The services/document_storage_service/README.md defines the CRUD API for rich-text documents, while services/email_service syncs Gmail/Google Workspace mail into the Macro ecosystem.

Data Persistence and Search

PostgreSQL serves as the primary datastore (MacroDB), accessed through the crates/macro_db_client crate using SQLx for compile-time query validation. The following Rust example demonstrates inserting entity mentions with type-safe database access:

use macro_db_client::entity_mentions::CreateMention;
let mention = CreateMention {
    source_entity_type: "document".into(),
    source_entity_id: doc_id,
    target_entity_type: "user".into(),
    target_entity_id: user_id,
};
db.insert_mention(&mention).await?;

Full-text search capabilities rely on an OpenSearch cluster configured in infra/stacks/opensearch/README.md, while real-time updates flow through the Soup realtime event bus (crates/soup_realtime/README.md) built on Kafka, guaranteeing at-least-once delivery semantics for document patches.

AI-Enhanced Services and Automation

The roadmap emphasizes deep AI integration through specialized Lambda workers and prompt engineering.

Intelligent Document Processing

The services/document_cognition_service extracts text from PDFs and DOCX files, running OCR and generating searchable embeddings. For content generation, the services/ai-editing-worker executes prompts defined in services/ai-editing-worker/src/ai-editing/prompts/SUPERVISOR.md and CODER.md against Anthropic, OpenAI, or internal models. These short-lived Lambda workers integrate directly with the document storage layer to provide inline AI assistance, as detailed in services/ai-editing-worker/AI_EDITING.md.

Workflow Orchestration

Long-running batch operations are managed by services/worker_trigger, which orchestrates ECS task runs triggered by SQS events. The source file services/worker_trigger/src/service/ecs/run_task.rs handles the scheduling logic, ensuring AI processing and data migrations execute reliably without blocking user-facing APIs.

Local Development and Deployment

The repository provides comprehensive tooling for local testing and cloud deployment.

Running the Stack Locally

Developers can bootstrap the entire environment using Docker Compose and Nix. The configuration in docker/docker-compose.yml initializes PostgreSQL, Redis, LocalStack, OpenSearch, and FusionAuth containers. To launch the development stack without external secrets managers:

# Start infrastructure dependencies

docker compose -f docker/docker-compose.yml up -d

# Configure environment files

just setup_test_envs

# Build and run services

nix develop --command just stack up --no-doppler

These commands are documented in docs/RUNNING_LOCALLY.md.

Infrastructure as Code

Deployment relies on Pulumi scripts located in infra/stacks/. The infra/stacks/web-app/README.md provisions S3 static sites and CloudFront distributions, while infra/stacks/fusion-auth/README.md manages JWT-based authentication infrastructure. Deployment requires only:

cd infra/stacks/web-app
pulumi up

Summary

• Macro Inc. is developing an AI-native workspace combining email, chat, documents, and tasks using a Rust-based architecture with over 80 crates.
• The platform uses SolidJS/Tauri for the frontend (apps/web), TypeScript SDK for client integration (packages/sdk), and 30+ microservices for backend logic (services/*).
• PostgreSQL with SQLx (crates/macro_db_client) provides type-safe data access, while OpenSearch and Kafka-based Soup realtime (crates/soup_realtime) enable search and live collaboration.
• AI editing workers (services/ai-editing-worker) execute prompts against Anthropic and OpenAI models to provide intelligent document assistance.
• Infrastructure is managed via Pulumi (infra/stacks/*) with local development supported by Docker Compose and Nix.

Frequently Asked Questions

What programming languages does Macro Inc. use for development?

Macro Inc. primarily uses Rust for the backend microservices and core libraries, organized as a Cargo workspace with over 80 crates. The frontend is built with TypeScript using SolidJS and Tauri, while infrastructure is defined in TypeScript using Pulumi.

How does the Macro platform handle real-time collaboration?

The platform uses a custom Soup realtime event bus implemented in crates/soup_realtime, which leverages Kafka to deliver document patches to clients with at-least-once semantics. This ensures all users see consistent updates across email, chat, and document editing interfaces.

Can developers self-host the Macro platform?

Yes, the repository includes comprehensive local development instructions in docs/RUNNING_LOCALLY.md. Developers can use the provided docker-compose.yml to spin up PostgreSQL, Redis, OpenSearch, and FusionAuth locally, then run the Rust services using Nix and Just commands without requiring external cloud dependencies.

How is AI integrated into the Macro workspace?

AI functionality is delivered through Lambda workers such as services/ai-editing-worker, which executes prompts defined in files like SUPERVISOR.md and CODER.md against LLM providers including Anthropic and OpenAI. The document_cognition_service also uses AI for OCR and embedding generation to power semantic search across uploaded documents.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}