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

> Explore the Macro Inc. development roadmap detailing its AI-native workspace architecture and Rust microservices. Discover the future of unified productivity.

- Repository: [Macro/macro](https://github.com/macro-inc/macro)
- Tags: architecture
- Published: 2026-08-20

---

**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`](https://github.com/macro-inc/macro/blob/main/packages/sdk/README.md), which exposes typed APIs for creating blocks and invoking AI agents.

```typescript
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`](https://github.com/macro-inc/macro/blob/main/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:

```rust
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`](https://github.com/macro-inc/macro/blob/main/infra/stacks/opensearch/README.md), while real-time updates flow through the **Soup realtime** event bus ([`crates/soup_realtime/README.md`](https://github.com/macro-inc/macro/blob/main/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`](https://github.com/macro-inc/macro/blob/main/services/ai-editing-worker/src/ai-editing/prompts/SUPERVISOR.md) and [`CODER.md`](https://github.com/macro-inc/macro/blob/main/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`](https://github.com/macro-inc/macro/blob/main/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`](https://github.com/macro-inc/macro/blob/main/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`](https://github.com/macro-inc/macro/blob/main/docker/docker-compose.yml) initializes PostgreSQL, Redis, LocalStack, OpenSearch, and FusionAuth containers. To launch the development stack without external secrets managers:

```bash

# 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`](https://github.com/macro-inc/macro/blob/main/docs/RUNNING_LOCALLY.md).

### Infrastructure as Code

Deployment relies on **Pulumi** scripts located in `infra/stacks/`. The [`infra/stacks/web-app/README.md`](https://github.com/macro-inc/macro/blob/main/infra/stacks/web-app/README.md) provisions S3 static sites and CloudFront distributions, while [`infra/stacks/fusion-auth/README.md`](https://github.com/macro-inc/macro/blob/main/infra/stacks/fusion-auth/README.md) manages JWT-based authentication infrastructure. Deployment requires only:

```bash
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`](https://github.com/macro-inc/macro/blob/main/docs/RUNNING_LOCALLY.md). Developers can use the provided [`docker-compose.yml`](https://github.com/macro-inc/macro/blob/main/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`](https://github.com/macro-inc/macro/blob/main/SUPERVISOR.md) and [`CODER.md`](https://github.com/macro-inc/macro/blob/main/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.