Rubin — Private Intelligence for Everyday Life

Rubin is a private, on-device life copilot that turns tasks, money, calendar, health, self-care, wardrobe and notes into safe next steps—so you can focus, feel supported, and move with confidence.

Comment 3

Inspiration

Modern life is managed across disconnected systems: tasks in one app, meetings in another, expenses and accounts elsewhere, health data in a separate dashboard, notes scattered across devices, and purchase receipts buried in screenshots or email.

The problem is not a lack of information. It is the effort required to connect that information, decide what matters now, and take the next step.

At the same time, many AI assistants require users to send deeply personal context to cloud services or trust opaque automation. I wanted to explore a different model: an assistant that can understand the realities of a person’s day, support both productivity and personal care, and still keep the user firmly in control.

That idea became Rubin.

Rubin is built around a simple question:

What if a personal AI could reduce cognitive load, improve everyday decisions, and provide thoughtful support—without taking ownership of the user’s life or private data?

What Rubin does

Rubin is a private, local-first personal life assistant for iPhone and iPad. It brings together tasks, calendar, money, receipts, wardrobe, notes, weather, and optional health context inside an encrypted personal vault.

Rubin is not designed as another generic chatbot or a collection of unrelated trackers. Its purpose is to understand the user’s current situation, identify what matters, explain why, and turn that understanding into safe, reviewable next steps.

Its core interaction loop is:

Understand → Prioritize → Explain → Propose → Confirm → Act → Learn

Home and productivity

Rubin’s Home screen is a daily decision surface. It combines priorities, calendar commitments, available time, weather, financial context, and optional health signals into a calm plan for the day.

Rubin can:

  • Rank tasks according to urgency, importance, available time, and energy requirements.
  • Identify realistic focus windows around calendar events.
  • Run a focused task session with pause, resume, completion, and “continue later” controls.
  • Replan the day when circumstances change.
  • Surface one important decision instead of overwhelming the user with every available signal.
  • Help recover delayed work without treating an overdue task as a personal failure.
  • Separate information that requires attention from information that can remain in the background.

The goal is sustainable productivity: helping users make meaningful progress without encouraging an impossible schedule.

Calendar intelligence

With permission, Rubin reasons over Apple Calendar data on the device. It can identify conflicts, open blocks, overloaded days, preparation needs, and realistic opportunities for focused work.

Calendar context can also improve other areas of Rubin. An upcoming event can influence task planning, travel preparation, outfit recommendations, weather warnings, and personal-care suggestions.

Calendar changes are never made silently. Rubin presents the exact proposed change and asks the user to confirm it.

Money and the financial Vault

Rubin Money is designed to answer four distinct questions:

  1. What did I spend?
  2. How much money is actually available?
  3. What do I owe and when?
  4. What can I safely choose next?

The Money module includes spending activity, budgets, accounts, cards, wallets, liabilities, holdings, financial goals, purchase decisions, and protected access through the authenticated Vault.

Its financial foundation uses exact minor-unit arithmetic and balanced ledger entries rather than asking a language model to calculate balances. Purchases, transfers, refunds, card payments, income, wallet top-ups, liabilities, investments, and net worth are treated as different financial events.

Rubin is also designed with India-relevant financial concepts such as INR, UPI, UPI Lite, wallets, EMI, BNPL, FASTag, cards, and gold, while remaining globally extensible.

The “Should I buy this?” experience can consider budget impact, recent spending, upcoming obligations, payment options, financial goals, and—when relevant—whether the user already owns something similar.

Rubin tracks and explains money; it does not move funds or present itself as a financial adviser.

Receipt and screenshot intelligence

Rubin can analyze receipts and shopping screenshots locally using Apple Vision.

Instead of treating OCR text as unquestionable truth, Rubin preserves evidence and confidence, extracts editable fields, and asks the user to review uncertain information.

A single clothing receipt can propose multiple connected workflows:

  • Record the purchase in Money.
  • Create a linked Wardrobe item.
  • Create a delivery or warranty task where relevant.
  • Save selected information as a private note.

Nothing is saved until the user reviews the extracted fields, selects the workflows, and confirms the action. This reduces repeated data entry while preserving accuracy and control.

Wardrobe intelligence

Rubin Wardrobe is a private closet and decision system rather than a shopping feed.

It can organize owned clothing, track availability and wear history, create looks, plan outfits, prepare packing lists, and recommend what to wear using relevant calendar and weather context.

For example, Rubin can combine an evening event, the expected formality, rain conditions, and the user’s available clothing to propose several different outfit options.

For a possible clothing purchase, Rubin can consider duplicates, wardrobe compatibility, expected outfit contribution, clothing budget, recent spending, and projected cost per wear. The objective is to help the user make better use of what they already own and avoid unnecessary purchases.

Health and personal care

Health and care are optional, supportive contexts—not medical services.

With explicit HealthKit permission, Rubin can use signals such as sleep, steps, and active energy to make planning more humane. If the user has slept poorly or has a demanding schedule, Rubin can suggest a gentler plan, a smaller next task, hydration, movement, a meal check-in, or a wind-down routine.

Personal-care reminders support simple responses such as Done, Not Yet, or Skip, with user-configurable schedules, follow-ups, quiet hours, and notification controls.

Rubin does not diagnose, prescribe, shame, or claim medical authority. Health context is used to reduce pressure and support better choices while leaving every decision with the user.

Notes, memory, and drafts

Rubin’s Notes module provides durable, user-owned context.

Explicitly created notes can support future tasks or decisions when relevant. Sensitive information inferred from conversation is treated as a memory candidate and is not permanently stored until the user reviews and approves it.

Users can inspect why a memory was used, remove it from future reasoning, or delete it without affecting unrelated information.

Rubin can also prepare drafts from approved context and place them in a secure, expiring clipboard.

Weather and private notifications

Weather is used as a supporting signal rather than another dashboard. It can improve outfit choices, travel buffers, hydration suggestions, storm preparation, and reminders.

Rubin’s notifications are designed as a private attention inbox. Users can choose how much detail appears outside the unlocked app. Sensitive financial, health, relationship, task, or calendar information can be replaced with generic notification text.

Interactive notification actions stage a protected proposal; they do not silently open the vault or change private data in the background.

What makes Rubin different

Rubin is built around three principles.

Connected context

Rubin’s modules are not isolated databases. Relevant information can work together without requiring the user to enter the same fact repeatedly.

A receipt can connect Money and Wardrobe. A calendar event can influence tasks and outfit planning. Poor sleep can reduce the pressure of a task plan. A saved preference can improve a recommendation without exposing unrelated notes.

Private by default

Personal data is stored in a local encrypted vault. Rubin uses AES-GCM encryption, device-protected Keychain keys, biometric or passcode authentication, complete file protection where supported, and an app-switcher privacy shield.

Private information is redacted when Rubin is locked, backgrounded, or manually shielded. Rubin deliberately avoids storing full card numbers, CVVs, PINs, OTPs, banking passwords, or raw account credentials.

Confirmation before consequence

Rubin separates understanding from authority.

The language model may interpret a request or explain a recommendation, but it cannot directly change the user’s vault. Consequential actions follow a structured path:

Request → Proposal → Exact preview → Confirmation → Authentication when required → Atomic execution → Receipt

If the underlying data changes, the confirmation expires, or the proposal no longer matches what the user reviewed, Rubin rejects the action and prepares a fresh proposal.

This makes user control part of the architecture rather than a promise added to the interface.

How I built it

Rubin is a native SwiftUI application for iOS and iPadOS.

The product uses a hybrid intelligence architecture:

  • A bundled on-device language model interprets natural language and produces structured candidates.
  • Typed capability services retrieve only the context relevant to the request.
  • Deterministic engines own financial calculations, task planning, calendar conflicts, OCR validation, ranking, persistence, and state-changing operations.
  • Guarded fallbacks handle model failure, low confidence, timeouts, or invalid output.
  • Apple frameworks provide local capabilities such as Vision OCR, LocalAuthentication, CryptoKit, Keychain, EventKit, HealthKit, WeatherKit, and on-device speech recognition where available.

OpenAI Codex served as an engineering collaborator throughout development. I used it to inspect and improve the architecture, implement and refactor Swift systems, generate and run tests, investigate regressions, review privacy and action boundaries, and produce the simulator-based product demonstration.

A deliberate design choice was to use OpenAI’s coding intelligence to accelerate development while keeping Rubin’s end-user personal reasoning and sensitive data local-first.

Challenges I faced

The hardest challenge was not adding features—it was allowing different areas of life to work together without creating privacy overreach.

Rubin needs enough context to be useful, but it should never load unrelated memories, health information, or financial records “just in case.” I addressed this through typed capabilities, bounded context retrieval, evidence provenance, consent states, and domain-specific privacy rules.

Another major challenge was making local AI reliable. A small on-device model has limited memory and may produce invalid or uncertain output. Rubin therefore uses the model for interpretation and communication while deterministic systems remain responsible for facts, calculations, and mutations.

Financial correctness was particularly demanding. A card purchase, transfer, wallet top-up, refund, investment, and card payment may all move money, but they should not all count as spending. Rubin’s ledger and calculation engine were designed to preserve those distinctions.

Receipt intelligence introduced a different problem: OCR is evidence, not truth. Receipts contain several amounts, inconsistent layouts, merchant metadata, and ambiguous products. Rubin’s staged pipeline keeps confidence and source evidence visible and requires review before creating records.

Finally, designing a product this broad without making it feel like seven apps placed behind one navigation bar required repeated simplification. Rubin’s Home surface, global chat, connected workflows, and proposal system became the unifying product language.

Accomplishments I am proud of

  • Built a functioning native iPhone and iPad product rather than a static prototype.
  • Created an encrypted, authenticated personal-data vault with background redaction.
  • Connected productivity, money, wardrobe, receipts, notes, weather, calendar, and optional health context.
  • Implemented a confirmation-bound action architecture that prevents the language model from directly mutating user data.
  • Built deterministic financial calculations and account-aware ledger foundations.
  • Created a local receipt-understanding pipeline with editable evidence and cross-module workflow proposals.
  • Added behavioral boundaries for privacy, autonomy, uncertainty, financial risk, and non-diagnostic health support.
  • Built broad automated regression coverage for routing, evidence, claims, confirmation state, and state changes.

At the latest engineering gate, all 405 executed Rubin tests passed, with three additional environment-gated tests intentionally skipped. Rubin’s fixed 2,500-case Phase 1 regression suite also passed in full. I treat these results as regression evidence—not as proof that every real-world conversation has been solved.

What I learned

The most important lesson was that intelligence is not the same as autonomy.

A valuable assistant does not need permission to take over a person’s life. It needs the ability to understand context, explain its reasoning, recognize uncertainty, and make the next decision easier.

I also learned that privacy must influence the system’s architecture, interface, notifications, memory, and failure behavior. Encryption alone is not enough if an assistant loads irrelevant information or acts on an assumption.

Finally, I learned that local AI works best as part of a system. The language model contributes interpretation and natural communication, while deterministic services provide correctness, evidence, and enforceable boundaries.

What is next

Rubin is currently a deep internal alpha moving toward a controlled beta. The next steps are:

  • Complete physical-device performance, memory, battery, and thermal validation.
  • Finish unifying all Money surfaces around Ledger V2.
  • Expand real-world receipt benchmarking with anonymized documents.
  • Improve Wardrobe ranking and local visual intelligence.
  • Complete accessibility and end-to-end UI release gates.
  • Run new held-out behavioral evaluations with independent human review.
  • Conduct external privacy and security review.
  • Prepare a controlled TestFlight release with rollback and data-migration testing.
  • Add secure Account Aggregator support—with explicit, revocable consent—to import financial accounts and transactions automatically, reduce manual data entry, and improve reconciliation and financial insights.

Why Rubin matters

Rubin’s ambition is not to automate a person.

It is to reduce the invisible work of remembering, connecting, planning, checking, and deciding—while respecting the fact that the user’s time, money, health, relationships, and personal history belong to the user.

Rubin provides intelligence without surrendering agency: private context, thoughtful care, clearer decisions, and safe next steps—all in one place.

Built With

  • activitykit
  • app-intents
  • apple-foundation-models
  • codex
  • core-location
  • cryptokit
  • eventkit
  • gguf
  • gpt-5.6
  • healthkit
  • ios
  • ipados
  • keychain
  • llama-cpp
  • local-authentication
  • openai
  • qwen3
  • speech
  • swift
  • swiftui
  • vision
  • weatherkit
  • widgetkit
  • xcode
  • xctest
Share this project:

Updates