Skip to content
pmLet’s talk
All projects

Cortex

One private place for the moving parts of a day.

Cortex brings coursework, habits, focus sessions, contacts, calendar, and money into a desktop app. I built it for my own daily work, with a local API that lets agents use the same records.

Cortex daily dashboard on a laptop resting on a green chair
Role
Product design and engineering
Year
2026
Platform
macOS app
Status
shipped

The problem

My courses, planning, finances, and contacts lived in separate tools. I wanted to see them together and let agents help with the work while keeping the underlying records private and stored locally.

What I built

A shipped macOS app with encrypted local records and agent access through MCP. It also brings opportunity research and cloud billing history into the dashboard.

The choices behind it.

I designed and built the macOS app, encrypted storage, local API, MCP server, and background integrations. The same dashboard can also open on my phone through a private Tailscale connection.

Keep the records local and encrypted

Data files use AES-256-GCM encryption. Electron safeStorage protects the master key through macOS Keychain, and the app migrates older plaintext records into encrypted storage.

Let the app and agents use the same API

The MCP server forwards study, habit, calendar, contact, and finance actions to the local API. Agents work with the same records the interface presents.

Run background work outside the window

Opportunity collection and monitoring run independently of Electron. Cloud billing data is collected into a local ledger with source health, credits, and budgets visible together.

Cortex student workspace on a laptop beside its mobile finance view
Study on desktop, finances on mobile

From start to finish.

  1. Desktop and phone

    The React interface runs in Electron and through the private web server.

  2. Local API and MCP

    The interface and agents read and update the same application records.

  3. Encrypted storage

    Authenticated encryption protects data files; macOS Keychain protects the key.

authenticated encryption
256-bit
of cloud cost history
13 months
MCP transports
2

Under the surface.

Desktop app

Daily planning, coursework, finances, contacts, and focus sessions.

Local server

The private API and phone dashboard, available over Tailscale.

MCP server

Study and planning actions over stdio or HTTP.

Background integrations

Opportunity collection, billing data, and source health checks.

Build details Stack, scope, and implementation

Built with

  • React 19
  • TypeScript 5.9
  • Electron 41
  • Vite 8
  • Tailwind CSS v4
  • shadcn/ui
  • Recharts
  • React Router 7
  • Framer Motion
  • Model Context Protocol SDK
  • Node.js
  • launchd
  • Supabase

Areas

  • desktop app
  • MCP
  • local-first
  • personal dashboard
  • encryption
  • automation

Problem context

Founders and students juggle habits, revenue, deploys, coursework, contacts, and a firehose of opportunities across a dozen disconnected tools, with no single private place to see and audit it all. Cortex is a local-first, encrypted desktop dashboard that unifies those signals and exposes them to an AI agent.

More about the project

I built Cortex to keep my days, coursework, money, and contacts in one private place. The macOS app brings habits, focus sprints, reading, CRM, calendar, finances, and founder metrics into the same dashboard. Data is encrypted locally with AES-256-GCM; Electron safeStorage protects the master key through the macOS Keychain. The local server on port 3456 also serves the dashboard to my phone over Tailscale.

The MCP server gives agents access to the same local API. They can read study material, log a sprint, update a calendar event, or work with the dashboard's other records. Opportunity Radar collects and scores opportunities against an editable profile. Cloud Spend reads AWS and Google billing data into a local ledger, so I can check usage alongside the rest of my finances.

Implementation notes

  • Encrypts every data file at rest with AES-256-GCM in a custom binary container (4-byte magic, 2-byte version, per-write 12-byte IV, 16-byte GCM auth tag). The 32-byte master key is sealed with Electron safeStorage (Keychain-backed on macOS), and a one-time migration rewrites any plaintext JSON to ciphertext behind a sentinel guard.
  • The MCP server in mcp-server/src/index.ts proxies the localhost:3456 API for habits, books, CRM, calendar, finance, coursework, and founder metrics. It supports stdio and an optional HTTP transport.
  • Three-tier persistence hook: Electron IPC to encrypted JSON, then the HTTP web API, then localStorage, with size-adaptive debounce (150/500/1000ms) and batched queueMicrotask writes. The web server socket is IP-gated to localhost and the Tailscale CGNAT range (100.64.0.0/10).
  • Opportunity Radar runs from scripts/ on a launchd schedule. Native feed collectors supply candidates to a classifier with no tool access; hunt orders steer the search, and normalized application URLs, titles, and hosts prevent duplicate records.
  • A KeepAlive watcher daemon turns a 'Run radar' button press into a full pipeline run by polling a runStatus flag over the HTTP API every 5 seconds. It is decoupled from Electron and self-heals stale runs after 45 minutes, so it needs zero app-code changes.
  • Cloud Spend keeps 13 months of AWS Cost Explorer and Google BigQuery billing data in an encrypted local ledger. Usage, credits, budgets, service totals, and source health stay visible together.

Build figures

  • 3 persistence paths

Parts of the project

cortex app
The Electron 41 and React 19 macOS app for daily planning, study, projects, finance, cloud spend, and automations. The graphite and teal interface has light and dark themes and persists through Electron IPC, the HTTP API, or localStorage.
cortex-mcp-server mcp
MCP access to the app's local API for study, habits, journal, contacts, calendar, GTM, and founder metrics over stdio or HTTP.
opportunity-radar worker
Native feed collectors, a classifier with no tool access, an editable profile, and deduplication before opportunities enter the app.
electron main (:3456 web server) service
The Electron main process owns the encrypted data directory, the tray, and context-isolated preload IPC, and runs a Tailscale-gated HTTP server on port 3456 that serves the same dashboard as a PWA to the phone.
crypto container (electron/crypto.ts) library
Encrypts every data file with AES-256-GCM in a custom binary format (CTX1 magic, version byte, 12-byte per-write IV, 16-byte auth tag), keyed by a 32-byte master key held behind Electron safeStorage and the macOS Keychain.
integrations (electron/integrations) library
Founder-metric clients for GitHub, Lemon Squeezy (MRR), Vercel, Supabase, the Mars Obsidian journal vault, and Paperclip, feeding the weekly-audit rollup shown in the UI and over MCP.

Try the product.

Interactive demo · Open full screen