IntentCore
Intent-based data architecture desktop app. Scans Documents/Desktop/Code, AI-analyzes intent states (research/active/paused/shelved/completed), stores as Markdown.
The Filesystem Has No Concept of Intent
A MacBook accumulates thousands of files across Documents, Desktop, and Code directories — each tied to a project or "intent." Some are active (current sprint), some paused (waiting for review), some shelved (completed or abandoned). The filesystem offers no way to organise by intent — only by folder and file type.
The workspace is a flat namespace of directories and extensions. A designer's mockup for an active sprint sits next to a finished proposal from six months ago. A critical patch lives beside an abandoned experiment. The signal-to-noise ratio degrades daily, and the cost of context-switching compounds with every new project.
The goal: an app that scans your entire workspace, uses a local LLM to classify each file's intent state, and presents an intent-oriented view of your digital workspace — without uploading anything to the cloud.
Local-First, Intent-Aware Desktop Architecture
IntentCore is a Tauri 2 desktop app (Rust backend + React/TypeScript frontend). The Rust backend watches filesystem changes via notify, runs on-device ML inference via MLX (Apple Silicon) with Qwen2.5-3B, and persists intent state as Markdown files alongside the originals. The Tauri shell provides native macOS window controls, file dialogs, and system tray integration.
The data pipeline flows unidirectionally: filesystem events trigger the watcher, which enqueues files for classification. The MLX inference engine runs Qwen2.5-3B locally on the M-series Neural Engine, classifying each file into one of five intent states. The classified state is written as an adjacent .md sidecar file (Obsidian-compatible frontmatter), and the React frontend re-renders the intent dashboard in real time.
// Rust → Tauri command (invoked from React frontend)
#[tauri::command]
async fn classify_intent(path: String) -> Result<IntentState, String> {
let text = std::fs::read_to_string(&path).map_err(|e| e.to_string())?;
let result = mlx::infer("Qwen2.5-3B", &text, intent_prompt()).await?;
Ok(IntentState::from_label(&result))
}File Change → MLX Classify → UI Update
macOS Desktop Deployment Architecture
Local AI Stack Optimised for Apple Silicon
Key Engineering Decisions
Rust backend for native filesystem access and MLX bindings; significantly smaller binary (~5MB vs ~120MB); lower memory footprint (~40MB idle vs ~200MB). The webview approach also enables direct system tray and native file dialog integration without bridging.
Files remain accessible and editable outside the app — no proprietary format lock-in. The sidecar *.md files are Obsidian-compatible, enabling note-taking workflows on top of the intent graph. Markdown renders natively on GitHub, VS Code, and every text editor.
Runs on Apple Silicon at usable speed (~15 tokens/sec on M1 Max); 3B parameters are sufficient for intent classification without the memory overhead of 7B+ models. Fits in ~6GB RAM alongside other applications, making it practical for an always-on desktop assistant.
Intent state files are plain Markdown with YAML frontmatter rather than rows in a proprietary SQLite schema. This means every intent file is directly readable by Obsidian, VS Code, grep, and git — the user's data is never trapped in a binary format or opaque database. Sidecar .md files live adjacent to the original documents, so the intent graph survives even if the Tauri app is uninstalled. The tradeoff is that cross-file queries (e.g., "all active intents from last week") require filesystem scanning rather than a SQL WHERE clause, but for a desktop-scale intent graph (hundreds, not millions of files) the simplicity and portability win decisively.
Three Sessions from Concept to Blueprint
Blueprint for Local-First Intent Management
Industry alignment: Intent-based data architecture mirrors approaches used by Plaid and Datadog for organising heterogeneous data by semantic intent rather than storage topology. Edge AI inference on Apple Silicon follows the trajectory of Apple Intelligence — running capable models on-device for privacy and low latency. The complete design mockup and architecture blueprint serve as the foundation for a production implementation.