Building a Distributed macOS App Ecosystem in 48 Hours with Google Antigravity

Executive Summary

Over the past two days, I set out to solve a persistent productivity bottleneck in my multi-Mac workflow. Working across a MacBook Pro 16 (M4 Pro), an always-on Mac mini server, and a MacBook Air, I was constantly battling configuration drift, disconnected network diagnostics, manual rsync runs, and fragmented remote desktop configurations across sandboxed macOS containers.

Instead of spending weeks piecing together ad-hoc shell scripts and third-party utilities, I partnered with Google Antigravity—Google DeepMind's advanced agentic AI coding assistant.

In less than 48 hours, we designed, implemented, compiled, codesigned, and deployed three production-grade native macOS applications across the entire fleet:

1. NetPulse Diagnostics (NetPulse.app): A real-time, native network telemetry and Wi-Fi/Internet troubleshooting studio.
2. Antigravity Sync (Antigravity Sync.app): An autonomous mesh synchronization daemon and native GUI that keeps local workspaces, scratch code, and agent brains harmonized with Google Cloud Storage (GCS).
3. Antigravity Launcher (Antigravity Launcher.app): A central command hub and menu bar utility featuring live process freshness detection (v1.2.0), extensible application management, and automated bidirectional synchronization of Windows App (Microsoft Remote Desktop) connections across all Macs.

1. The Architecture: Multi-Mac Fleet + Google Cloud Vault

Before diving into each app, it is helpful to understand how the fleet communicates. Our architecture uses a hybrid peer-to-peer mesh paired with an authoritative Google Cloud Storage vault:

2. The Applications Built

App 1: NetPulse Diagnostics (NetPulse.app)

What it does: Real-time network and internet connection health monitor and diagnostic suite.

• Stack: Python 3, PyObjC, Apple WebKit runtime, macOS CoreWLAN framework, asyncio, PyInstaller standalone bundler.
• Interactive Telemetry Gauges: Live measurement of gateway round-trip time (RTT), DNS resolution latency, packet jitter, and internet packet loss.
• Wi-Fi PHY Analysis: Native access to CoreWLAN for current SSID, BSSID, RSSI (dBm), Noise floor, Signal-to-Noise Ratio (SNR), transmit rates (Tx Rate), channel width, and band frequency.
• Automated Root Cause Diagnostics: Performs multi-hop latency triage (Local Loopback → Default Gateway → Public DNS → Cloudflare / Google Backbone). If Wi-Fi drops or the router introduces bufferbloat, NetPulse pinpoints the exact failure point immediately.
• Dark Glass Modern UI: Fully embedded macOS dark-mode dashboard rendered using hardware-accelerated WebKit with zero external browser dependencies.

App 2: Antigravity Sync (Antigravity Sync.app)

What it does: Autonomous multi-Mac and Google Cloud workspace synchronization.

• Stack: Native Swift (Cocoa / AppKit), bash, rsync -avzu, gcloud storage, macOS launchd.
• Bidirectional Fleet Mesh: Discovers active Macs on the local private subnet using short SSH connection probes. When a machine wakes up or joins the network, diffs are automatically synchronized.
• Database-Safe Syncing: Intelligently detects and skips in-flight SQLite WAL files (.sqlite-wal) and temporary lock journals, avoiding the database corruption common with naive file syncing.
• Autonomous Background Operation: Deployed as a LaunchAgent (com.antigravity.autosync) that triggers every 30 minutes, keeping tools, shell scripts, and launcher configs aligned with zero user intervention.
• Status Bar Controller: Native menu bar tray item displaying live synchronization status, peer machine availability, and 1-click manual trigger.

App 3: Antigravity Launcher (Antigravity Launcher.app)

What it does: Central command hub, RDP synchronization center, and live application freshness monitor.

• Stack: Native Swift 5, Cocoa / AppKit, CoreGraphics, ad-hoc codesigning.
• Extensible App Management: Supports both built-in core fleet applications and custom user additions (.app, .command, .sh). Apps can be added through an NSOpenPanel picker and tagged with custom launch arguments.
• Live Process Freshness Engine (v1.2.0): Checks not only whether an app is running, but whether the currently running process was compiled before or after the on-disk binary. If an update was synced from another Mac, the launcher flags the card with an OUTDATED badge and offers a 1-click Update action.
• 1-Click “Ensure Apps Running”: A dedicated header button and Cmd+E menu shortcut that scans Antigravity Sync, NetPulse, and Antigravity Launcher, launching stopped apps or gracefully restarting outdated ones to guarantee the entire workstation is on the latest code.
• Automatic Startup Health Check: On launch, the launcher quietly checks all core apps after 0.8 seconds and boots any missing services.

3. Reverse-Engineering Windows App RDP Sync: The Big Engineering Hurdle

One of the most complex challenges we tackled was synchronizing Windows App (formerly Microsoft Remote Desktop) configurations across Macs.

The Problem

Windows App (com.microsoft.rdc.macos) stores all user bookmarks, credentials, gateway configurations, and custom PC hostnames inside a sandboxed SQLite database:

~/Library/Containers/com.microsoft.rdc.macos/Data/Library/Application Support/com.microsoft.rdc.macos/com.microsoft.rdc.application-data.sqlite

This presented two massive obstacles:

1. macOS Transparency, Consent, and Control (TCC) Lockdown: Direct access to ~/Library/Containers/com.microsoft.rdc.macos/Data/ from terminal scripts or non-notarized applications is strictly blocked by macOS security protections.
2. SQLite Write-Ahead Logging (WAL): Windows App holds active bookmarks in a com.microsoft.rdc.application-data.sqlite-wal journal. Copying just the main SQLite file resulted in missing bookmarks or corrupted state.

How Antigravity Solved It

1. The Loopback SSH FDA Bridge: macOS sshd has system-level Full Disk Access granted in Privacy & Security. Antigravity wrote a bridge that executes internal file queries via ssh 127.0.0.1. By authenticating securely via localhost SSH keys, we bypass sandbox restrictions cleanly without requiring fragile OS-level security modifications.
2. CoreData WAL Checkpointing: Antigravity authored rdp-engine.py, which connects to the database and forces a full database checkpoint:
   SQL Checkpoint Copy

   PRAGMA wal_checkpoint(FULL);

3. Bidirectional Profile Harmonization:
   • Reads ZBOOKMARKENTITY and ZCREDENTIALENTITY from CoreData.
   • Automatically exports standalone, portable .rdp profile files into a centralized vault (~/.gemini/antigravity/rdp/connections/).
   • Watches for new .rdp files added on any Mac, parses them, and injects them into CoreData so they appear inside Windows App natively.
   • Distributes the synchronized vault across all Macs and back into the Google Cloud Storage bucket.

All 6 of my production remote desktop environments (including remote Windows application servers, lab workstations, MacBook Pro, and Mac mini) now stay synchronized across my laptops and desktops in real time.

4. The Google Cloud Infrastructure

Google Cloud forms the resilient backbone for this distributed multi-Mac ecosystem:

1. Authoritative Cloud Storage Vault

Instead of relying strictly on peer-to-peer connectivity (which fails if machines are asleep or on separate networks), Google Cloud Storage provides an authoritative, highly durable cloud vault:

• custom_apps/: Stores packaged, compressed tarballs of all compiled .app bundles (Antigravity_Launcher.tar.gz, Antigravity_Sync.tar.gz, NetPulse.tar.gz).
• sources/: Automatically bundles and archives the complete source code repositories (antigravity_launcher_src.tar.gz, etc.) with every build, ensuring complete reproducibility.
• releases/: Immutable, timestamped archives (*_YYYYMMDD_HHMMSS.tar.gz) for zero-risk rollbacks.
• manifest.json: Tracks build timestamps, target machine architecture (arm64), git commit hashes, and file checksums.

2. Single-Command Disaster Recovery

With our custom CLI tool restore-apps-gcs, setting up a brand-new Mac takes literally one command:

~/.gemini/antigravity/bin/restore-apps-gcs

In under 30 seconds, it streams the latest compiled bundles from GCS, unpacks them into /Applications/, validates ad-hoc codesignatures, recreates Desktop shortcuts, and restores all configured RDP connections.

5. How Antigravity Made This Possible: The Paradigm Shift

As folks that aren't dedicated software engineers, we can't write this code very easily on our own. Building native Swift Cocoa user interfaces, reverse-engineering sandboxed Apple CoreData SQLite databases, integrating macOS WebKit runtimes with Python asyncio, and writing low-level CoreWLAN Wi-Fi telemetry bindings is normally far beyond what non-specialists can tackle quickly.

Working with Antigravity was a completely different paradigm. It acted as a senior systems architect and full-lifecycle software engineer pairing with me at every phase—translating high-level operational intent into robust, production-grade applications that simply work.

What Made Antigravity Unique:

1. Full Lifecycle Autonomy: Antigravity did not just suggest a function; it created project directories, wrote build scripts (swiftc commands, PyInstaller specs), managed dependencies, codesigned binaries, distributed them via SSH/rsync, launched the applications, monitored process tables, and took screenshots to verify UI rendering.
2. Cross-Language & Cross-System Fluency: Within a single cohesive workflow, Antigravity moved effortlessly between:
   • Swift / AppKit: Building native macOS windows, NSVisualEffectView frosted glass, NSSearchField filtering, and NSStatusBar menu items.
   • Python / PyObjC / WebKit: Writing CoreWLAN bindings, asynchronous network socket probes, and embedding hardware-accelerated HTML5 dashboards.
   • macOS System Internals: Navigating launchd plists, TCC containers, Apple CoreData SQLite schemas, and process management APIs (NSRunningApplication).
   • Cloud Engineering: Automating Google Cloud Storage APIs, bucket lifecycle management, and disaster recovery pipelines.
3. Autonomous Root Cause Debugging: When we encountered the macOS container sandbox block on Windows App, Antigravity did not give up or ask me to manually copy files. It diagnosed the TCC restriction, recognized that sshd held Full Disk Access, generated local SSH keypairs, and constructed a transparent loopback bridge in minutes.
4. Iterative Polish & Version Governance: When I requested: “update the application so it shows version numbers and ensures my latest custom applications are running”, Antigravity didn't just hardcode text. It unified the version metadata across three separate codebases (v1.2.0), engineered a timestamp delta algorithm between disk modification dates and running process launch dates, built interactive badges and menu bar hotkeys (Cmd+E), and implemented a self-relaunch sequence for the launcher itself.

6. Takeaways for Incident Commanders: Building Software Without Coding Experience

As Incident Commanders, our expertise is in incident management, cross-team triage, operational reliability, and steering high-pressure system recoveries. Most of us are not software developers, and writing low-level code in Swift, Python, or shell scripts is not our day job. Historically, if we needed custom operational tools or diagnostic monitors, we either had to cobble together brittle scripts or wait weeks for an engineering team to prioritize our tooling backlog.

Working with Antigravity fundamentally changes what non-programmers can accomplish:

1. You Describe the Operational Need; Antigravity Engineers the Solution: You don't need to know how to write Swift Cocoa UI code, configure PyInstaller specs, or manage POSIX signal handling. You describe the operational outcome in plain language—just as you would in an incident bridge. For example:
   • “I need a live telemetry gauge that tests our gateway and DNS hops so I know immediately whether an outage is local Wi-Fi, the router, or our ISP.” → Antigravity built NetPulse.
   • “I need all my triage machines to automatically share the exact same RDP connection profiles and credentials without manually copying config files.” → Antigravity built the RDP Sync Engine.
   • “I need a central dashboard that monitors our tools and makes sure they are running the latest compiled versions.” → Antigravity built the Antigravity Launcher.
2. Autonomous Problem-Solving Removes Technical Blockers: Non-programmers usually get stuck when systems throw cryptic permission errors, compiler flags fail, or database files lock up. During this build, when macOS sandbox security blocked access to Microsoft Remote Desktop's container, Antigravity didn't ask me to debug it—it diagnosed the TCC restrictions on its own, identified that sshd held Full Disk Access, and built a transparent loopback SSH bridge in minutes.
3. Bespoke Tooling Built at Operational Speed: Incident response requires rapid adaptation. With Antigravity, any Incident Commander can build tailored, native operational utilities, fleet monitors, and automated sync systems in hours instead of waiting months for external dev cycles.
4. Zero-Fear Software Ownership: Because Antigravity manages versioning, testing, codesigning, and deployment pipelines, you get production-grade desktop software that installs cleanly, stays updated across machines, and backs up safely to Google Cloud Storage.

If anyone on the team wants to see a live demo of how to use Antigravity to build your own operational utilities, triage tools, or automated workflows—or if you want to install NetPulse or the Launcher on your Mac—reach out!

Written by Tom Huseby

Incident Commander and Systems Technologist based in Austin, Texas. Passionate about incident management, resilient system architectures, and turning agentic AI into practical operational leverage.