Tome: The Secret Tool Obsidian Power Users Are Switching To

Tome: The Secret Tool Obsidian Power Users Are Switching To

What if I told you that every meeting you've had this week is sitting in someone else's cloud? That your client conversations, your strategic pivots, your unguarded moments — they're all being processed, stored, and potentially analyzed by companies you've never met?

Here's the painful truth: Otter.ai knows more about your business than your cofounder does. Fireflies has heard things you wouldn't tell your therapist. And Granola? It's not even giving you your data back in a format you can use.

But what if you could flip the script entirely? What if your meeting capture ran on your Mac, spat out clean markdown^{↗ Smart Converter} with YAML frontmatter, and dropped it straight into your Obsidian vault where your AI agent could actually do something with it?

Enter Tome — the local-first meeting transcription tool that the Obsidian elite are quietly adopting. Built by a consultant who fell down the same second-brain rabbit hole you're probably in, Tome doesn't just solve the capture problem. It solves the workflow problem. And it does it without a single API key, subscription, or network request.

If you're running Obsidian with any kind of agent pipeline — Claude, custom scripts, whatever — you have a gaping hole in your system. This is how you plug it. Permanently.

What is Tome?

Tome is a macOS application that captures meetings and voice memos, transcribes them entirely on-device using Parakeet-TDT v3, and writes structured .md files directly into your Obsidian vault. No cloud. No API keys. Your data, your machine, your workflow.

The project was created by a consultant — let's call him the founder of Gremble — who found himself in a familiar trap. He'd built out a sophisticated Obsidian vault as a second brain: structured notes with YAML frontmatter, backlinks, tags, and a Claude agent layer that processed everything automatically. Client files, meeting notes, action items, daily briefs — all flowing through the vault.

The bottleneck? Capture. He was on calls all day and didn't take notes. He needed something that would listen, transcribe, and drop structured markdown into the vault where his agent could pick it up — pull out action items, update client files, connect the dots.

He looked at the usual suspects. Otter, Granola, Fireflies. They all failed the same tests:

• They lock your data in their cloud
• They use proprietary formats you can't escape
• None of them output plain markdown
• None of them are built to feed into an agent workflow

So he started from OpenGranola, learned Swift along the way, and rebuilt it with a fundamentally different philosophy. Different audio pipeline. Local ASR. Speaker diarization. Vault-native output. The result is Tome — and if you're running Obsidian with any kind of AI agent setup, you probably have the exact same gap he did.

Tome is trending now because it hits a perfect storm: the explosion of Obsidian as a knowledge operating system, the rise of local AI models that don't need cloud APIs, and growing developer paranoia about where their data ends up. This isn't just a tool. It's a statement about how knowledge work should function.

Key Features That Separate Tome from the Herd

Tome isn't a feature-light MVP. It's a deliberately scoped tool that does its core job with surgical precision. Here's what makes it technically compelling:

Multilingual On-Device Transcription via Parakeet-TDT v3

Tome uses Parakeet-TDT v3 from FluidAudio, running on Apple Silicon's Metal and Apple Neural Engine. It handles 25 European languages with auto-detection. The critical detail: nothing hits the network. Your audio never leaves your Mac. The model downloads once (~600MB) and lives locally forever.

Call Capture with Per-App Audio Filtering

This is where Tome gets clever. Using ScreenCaptureKit, it grabs both microphone and system audio — but it detects which conferencing app you're running (Teams, Zoom, Slack, etc.) and filters audio to just that application. Your Spotify playlist? Your notification dings? They stay out of your transcript. This isn't generic system audio capture; it's context-aware audio routing.

Voice Memo Mode for Fleeting Capture

Mic-only capture for quick thoughts, verbal notes, stream of consciousness. Saves to a separate folder so your random 2 AM ideas don't pollute your meeting transcripts. Uses type: fleeting in frontmatter instead of type: meeting.

Post-Session Speaker Diarization

After your call ends, Tome runs pyannote to split the remote audio stream into Speaker 2, Speaker 3, Speaker 4. It's not perfect — the README is admirably honest about this — but it's "way better than one wall of unattributed text." The limitation: diarization runs after the session, not live. During the call, remote audio shows as a single stream.

Vault-Native Markdown Output with YAML Frontmatter

This is the killer feature for Obsidian users. Tome writes .md files with structured frontmatter:

• type: meeting or fleeting
• created: ISO date
• time, duration: temporal metadata
• source_app: which conferencing tool was detected
• attendees: array including "You" plus identified speakers
• tags: pre-configured taxonomy (log/meeting, status/inbox, source/tome)

Your vault already knows what to do with this. Your Dataview queries work immediately. Your Templater scripts trigger automatically. Your agent pipeline has structured input to parse.

Privacy-First Design

The app window is hidden from screen sharing by default. No audio is saved to disk — only text transcripts. No network calls, no analytics, no telemetry, no accounts, no subscriptions.

Silence Auto-Stop

120 seconds of dead air and Tome stops itself. No more discovering you've recorded four hours of fan noise.

Real-World Use Cases Where Tome Dominates

The Consultant's Client Pipeline

You're juggling six clients, each with weekly syncs, quarterly reviews, and ad-hoc fire drills. Before Tome: you paid for Otter, manually exported transcripts, copy-pasted into Obsidian, reformatted everything, and still missed action items. With Tome: every call auto-lands in Clients/AcmeCorp/Meetings/ with proper frontmatter. Your Claude agent reads the transcript, extracts action items, updates the client's project note, and adds due dates to your task query. You talk; your system organizes.

The Engineering Manager's 1:1 Archive

You do 1:1s with twelve direct reports. You need to track career conversations, flag concerns, and spot patterns over quarters. Tome captures every session with speaker diarization — you and your report are clearly separated. Your agent tags emotional sentiment, flags mentions of "burnout" or "promotion," and surfaces trends in your dashboard. Six months later, you have searchable, structured evidence for performance reviews instead of gut feeling.

The Researcher's Interview Corpus

You're conducting qualitative research — user interviews, expert consultations, ethnographic observation. Cloud transcription services create IRB nightmares and data governance violations. Tome keeps everything local. Each interview becomes a markdown file with timestamps and speaker labels. You use Obsidian's graph view to find thematic connections across dozens of conversations. Your university's compliance office loves you.

The Founder Investor Relations Log

You're raising a seed round. Every investor call matters — what you promised, what they asked, what you need to follow up on. Tome captures each call, tags it with the investor's name, and drops it in your fundraising vault. Your agent extracts commitment items, flags questions you dodged, and builds a follow-up task list. When you're doing due diligence and need to prove you said what you said, you have the transcript.

The Personal Knowledge Capture Ritual

Voice Memo mode for your shower thoughts, your drive-time reflections, your post-workout clarity. Each memo gets type: fleeting, lands in your inbox, and your weekly review agent surfaces the gems, archives the noise, and connects related ideas. Your second brain actually has a reliable input stream.

Step-by-Step Installation & Setup Guide

Tome has specific requirements, and they're non-negotiable. This is Apple Silicon-native software leveraging Metal and the Apple Neural Engine for local ML inference.

System Requirements

• Apple Silicon Mac (M1, M2, M3, or later). Intel Macs are explicitly unsupported — Parakeet and FluidAudio need Metal / ANE.
• macOS 26 or later
• Xcode 26.3+ (for building from source)
• Obsidian vault (obviously, though Tome writes standard markdown that works anywhere)

Installation from Source

# Clone the repository
git clone https://github.com/Gremble-io/Tome.git

# Enter the project directory
cd Tome

# Run the build script — this compiles and installs to /Applications
./scripts/build_swift_app.sh

The build script handles compilation, code signing (ad-hoc), and installation. First launch downloads the Parakeet ASR model (~600MB) and caches it locally. Subsequent launches are instant.

Development Build

If you want to hack on Tome or avoid the install script:

cd Tome
swift build

This produces a debug binary without the full app bundle packaging.

Critical First Launch: Gatekeeper Bypass

Because Tome isn't signed with an Apple Developer certificate (yet), macOS Gatekeeper will block it with "Tome is damaged and can't be opened." This is normal for open-source Mac apps.

The official workaround:

1. Find Tome.app in /Applications
2. Right-click (or Control-click) the app icon
3. Click Open
4. In the security dialog, click Open again

You only do this once — after that, Tome launches normally from Launchpad or Spotlight. Alternatively, building from source avoids Gatekeeper entirely since you compiled it yourself.

Required Permissions

Important: macOS re-prompts for Screen Recording permission roughly monthly. This is an OS-level security behavior, not a Tome bug. Just click through it.

Vault Configuration

In Tome's settings, point it to your Obsidian vault folder (or a subfolder like Vault/Meetings/). Tome will create dated subdirectories and write .md files there. Configure your preferred tags in AppSettings.swift before building, or modify the defaults.

REAL Code Examples from the Repository

Let's examine actual code and output from Tome's README, with detailed technical commentary.

Example 1: The Build Script

# Clone and build Tome from source
git clone https://github.com/Gremble-io/Tome.git
cd Tome
./scripts/build_swift_app.sh

This is the canonical installation path. The build_swift_app.sh script is doing significant work under the hood: compiling Swift 6.2 source, linking against ScreenCaptureKit and AVFoundation frameworks, ad-hoc code signing the resulting bundle, and copying to /Applications. The script abstracts away Xcode project complexities so users don't need to understand Swift Package Manager resolution or bundle identifier configuration. Building from source is also your escape hatch from Gatekeeper — self-compiled binaries aren't quarantined the same way downloaded ones are.

Example 2: The Core Data Flow

speak → capture → vault → agent → knowledge base

This isn't code, but it's the architectural philosophy made visible. Tome explicitly rejects the monolithic approach where one tool tries to do everything. It owns the first three stages — speech capture, local transcription, vault writing — and delegates downstream intelligence to whatever agent system you've built. This composability is why it works so well with Obsidian's plugin ecosystem. You're not locked into Tome's opinion about what happens after transcription.

Example 3: The Markdown Output Format

---
type: meeting
created: "2026-03-23"
time: "10:00"
duration: "18:42"
source_app: "Zoom"
attendees: ["You", "Speaker 2"]
tags:
  - log/meeting
  - status/inbox
  - source/tome
---

# Call Recording — 2026-03-23 10:00

**You** (10:00:03)
Morning. Quick sync on the product launch. Where are we at?

**Speaker 2** (10:00:07)
We're in good shape. QA signed off yesterday, marketing assets
are locked, landing page is live in staging.

This is Tome's actual output format, and it's deliberately designed for machine and human consumption. Let's break down the engineering decisions:

• YAML frontmatter enables Dataview queries, Templater automation, and any YAML-aware tool
• ISO 8601 date format (2026-03-23) sorts lexicographically without special handling
• Attendees as array allows multi-value matching in Obsidian and easy iteration in scripts
• Hierarchical tags (log/meeting, status/inbox) follow the Johnny Decimal / PARA conventions popular in productivity systems
• Speaker labels with timestamps make the transcript scannable and referenceable
• No proprietary formatting — pure CommonMark with YAML, readable in any text editor for the next 50 years

Voice memos use identical structure but with type: fleeting and single speaker. This consistency means your agent pipeline processes both meeting and memo transcripts with the same parser.

Example 4: The Architecture Directory Structure

Tome/Sources/Tome/
├── App/
│   ├── TomeApp.swift               # App entry point
│   └── AppUpdaterController.swift  # Sparkle update controller
├── Audio/
│   ├── SystemAudioCapture.swift    # ScreenCaptureKit + per-app filtering
│   └── MicCapture.swift            # AVAudioEngine mic input
├── Models/
│   ├── Models.swift                # Domain types (Utterance, Speaker, etc.)
│   └── TranscriptStore.swift       # Observable transcript state
├── Transcription/
│   ├── TranscriptionEngine.swift   # Dual-stream capture + diarization
│   └── StreamingTranscriber.swift  # VAD + Parakeet ASR pipeline
├── Storage/
│   ├── TranscriptLogger.swift      # .md output with YAML frontmatter
│   └── SessionStore.swift          # Session metadata
├── Settings/
│   └── AppSettings.swift
└── Views/
    ├── ContentView.swift
    ├── ControlBar.swift
    ├── TranscriptView.swift
    ├── WaveformView.swift
    ├── SettingsView.swift
    ├── OnboardingView.swift
    └── CheckForUpdatesView.swift

This structure reveals Tome's clean separation of concerns. The Audio/ module handles the messy reality of macOS audio capture — ScreenCaptureKit for system audio with per-app filtering, AVAudioEngine for microphone. Transcription/ contains the ML pipeline: voice activity detection segments speech, then Parakeet transcribes. Storage/ owns the markdown generation and YAML serialization. The SwiftUI views are thin presentation layers over observable state in Models/.

Key insight for contributors: If you wanted to add a new output format — say, JSON for a different tool — you'd only touch TranscriptLogger.swift. The architecture makes extension obvious.

Advanced Usage & Best Practices

Optimize Your Vault Structure for Ingestion

Don't dump everything in your vault root. Create a dedicated Inbox/ or Meetings/ folder with a Templater script that processes new Tome files. Move processed files to Clients/ or Projects/ hierarchies. Tome writes files; your automation organizes them.

Tag Taxonomy Design

The default tags (log/meeting, status/inbox, source/tome) are starting points. Customize AppSettings.swift before building to match your system. Consider adding client tags, project tags, or priority markers that your agent uses for routing.

Headset Mic for Better Diarization

The README is honest: diarization quality degrades with laptop speakers due to crosstalk. If you're doing important meetings where speaker attribution matters, use a headset. The remote audio stream separates much more cleanly.

Pair with a Processing Agent

Tome is intentionally just the capture layer. The real power comes from what happens next. A simple Python^{↗ Bright Coding Blog} script watching your vault folder can:

• Extract action items with regex or LLM
• Update CRM records via API
• Generate follow-up emails
• Build weekly summary digests

Version Control Your Vault

Since Tome writes plain text, your entire meeting history can live in Git. This gives you audit trails, diff history, and disaster recovery that no cloud service matches.

Comparison with Alternatives

The verdict: If you're already in Obsidian and running any kind of automation, Tome isn't just better — it's the only tool built for your actual workflow. MacWhisper is excellent for manual transcription of audio files but isn't designed for live meeting capture with vault integration. Everything else locks you into their ecosystem and makes you beg for your data in formats you can't use.

FAQ

Is Tome really completely free?

Yes. MIT licensed, no subscriptions, no freemium traps. You build from source or use a community release. The only cost is your Apple Silicon Mac, which you already own.

Does Tome work on Intel Macs?

No, and this is a hard technical limitation, not gatekeeping. Parakeet-TDT v3 and the FluidAudio framework require Apple's Metal GPU and Neural Engine for performant local inference. Intel Macs lack these components.

How accurate is the transcription compared to cloud services?

Parakeet-TDT v3 is competitive with cloud ASR for clear speech in supported languages. It struggles more with heavy accents, overlapping speech, and poor audio quality — same as cloud alternatives, honestly. The tradeoff is privacy and workflow integration, not accuracy sacrifice.

Can I use Tome without Obsidian?

Absolutely. Tome writes standard markdown files with YAML frontmatter. Any text editor, note app, or static site generator that handles markdown will work. Obsidian is just the optimized target.

Why does diarization run after the call instead of live?

Post-session diarization uses the complete audio context for better speaker separation. Live diarization requires either more compute than Apple Silicon can provide in real-time, or cloud processing, which violates Tome's core privacy principle.

Will there be a signed release to avoid Gatekeeper?

The README mentions this as a future possibility. For now, the right-click-open workaround or building from source are the official paths.

Can I contribute to Tome's development?

Yes — MIT license, open source, Swift 6.2 codebase. The architecture is clean and modular. Check the Audio/, Transcription/, and Storage/ directories for extension points.

Conclusion

Here's what it comes down to: your meetings are your intellectual property. Every insight, every commitment, every casual mention of a competitor's weakness — that's valuable data. And you've been giving it away to cloud services that don't even let you export it properly.

Tome is the antidote. It's a tool built by someone who actually lives in the Obsidian ecosystem, who understands that capture is just the first domino, and who cares enough about privacy to make everything verifiably local.

The workflow is irresistible in its simplicity:

speak → capture → vault → agent → knowledge base

Tome handles the first three. Your imagination handles the rest.

If you're running Apple Silicon, living in Obsidian, and even slightly paranoid about where your data goes, this is the tool you've been waiting for. No more copy-paste from Otter. No more proprietary formats. No more subscription creep.

Go get it. Build it. Wire it into your system. And never think about meeting notes again.

👉 Star Tome on GitHub and start capturing on your terms.