maccap
Health Gecti
- License — License: MIT
- Description — Repository has a description
- Active repo — Last push 0 days ago
- Community trust — 32 GitHub stars
Code Basarisiz
- network request — Outbound network request in integrations/orbital-taxi/orbital_assist.py
- network request — Outbound network request in integrations/orbital-taxi/test_orbital_assist.py
- rm -rf — Recursive force deletion command in release.sh
Permissions Gecti
- Permissions — No dangerous permissions requested
Bu listing icin henuz AI raporu yok.
Call notes on your own Mac: records calls with no bot and no cloud, live on-device notes, Claude Code follow-ups. Only record people who have said yes.
MacCap
Call notes on your own Mac: no bot joins the call and nothing goes to the cloud.
Meeting recorders join your call as a guest, upload the audio and charge per
seat. MacCap is a menu-bar app that records the call where it already is, on
your Mac. While the call is on, it shows a live transcript, notes and your talk
time. When the call ends, it lists the next steps. With Claude Code, it splits
them into what Claude can draft for you and what only you can do.
[!IMPORTANT]
Only record people who have said yes. MacCap doesn't join the call, so
nobody else gets a notice from it. Telling them is up to you. Ask everyone
before you record. In many places recording a call without consent is against
the law, and some places need every person on the call to agree. MacCap asks
you to agree to this before it records anything. Its menu and its "Recording"
notification copy a short consent message you can paste into the call's chat.
See Recording with permission.
| During the call | When it ends, with Claude Code |
|---|---|
![]() |
![]() |
What it does
- Records calls on its own. It starts when Zoom, Meet, Teams, Slack,
FaceTime, WhatsApp, Webex or Discord uses the microphone, and also when you
answer an iPhone call on the Mac. It stops 45 s after the call ends. - Keeps you and them apart. Each call is one stereo
.m4a: your microphone
on the left channel and everyone else on the right. Transcripts know who is
speaking without guessing. - Takes live notes on the Mac (macOS 26+). Apple's on-device speech model
writes the transcript, and an on-device model (or your own local LLM) writes
the key points, questions and actions every minute. - Coaches you. It shows your share of the talking, the questions each side
asked, and a nudge when you've talked for too long. - Hands off the follow-ups. When the call ends you get next steps to tick.
With Claude Code they split into what Claude can draft and what only you can
do. Hand off writes the drafts (emails, messages, outlines) into one file.
Nothing is sent. - Plugs into your own tools. Any program can follow the call as JSON lines
and send cards back, for example who someone is, from your CRM.
Orbital/Taxi is one example.
Try it without a call
Nobody needs to be recorded to see it work. The demo plays a made-up call
between "you" and Priya from a made-up company into the real windows, using
your Mac's built-in voices:
python3 scripts/demo-call.py # writes demo-call.m4a (90 s)
build/MacCap.app/Contents/MacOS/MacCap demo demo-call.m4a # live window, then meeting finished
The demo records nothing and saves nothing to your recordings folder.--speed 2 plays it twice as fast. This is that call:
Install
You need an Apple silicon Mac with macOS 15 or later (macOS 26 for live notes
and the demo).
- Download: the latest release
hasMacCap-<version>.dmg, signed with a Developer ID and notarized by Apple.
Drag MacCap to Applications, thenbrew install ffmpeg. - Homebrew:
brew trust jhammant/tap && brew install --cask jhammant/tap/maccap(brings ffmpeg too).
Build from source
You also need the Xcode command-line tools (xcode-select --install) and
ffmpeg (brew install ffmpeg).
git clone https://github.com/jhammant/maccap.git && cd maccap
./build.sh test # build, then run the self-tests (no microphone needed)
./build.sh install # copy to /Applications/MacCap.app
open /Applications/MacCap.app
macOS ties the Microphone and System Audio Recording permissions to the app's
signature. Set MACCAP_SIGN_IDENTITY to your signing identity (in your
environment or in an uncommitted build.local.env) and you only click Allow
once. Ad-hoc builds ask again after every rebuild. MACCAP_BUNDLE_ID changes
the bundle ID (default io.maccap.MacCap).
Recording with permission
MacCap records two things: what your microphone hears and what your Mac
plays. Nothing joins the call, so the other people won't see a recording
notice unless you give them one.
- At first launch MacCap asks you to agree to record only people who have
said yes. Until you agree it records nothing: no automatic recordings, and
Start recording now asks first. - Copy consent message (in the menu, and the button on the "Recording"
notification) puts this on the clipboard for the call's chat: "Before we
start: I'd like to record this call so I can take notes. The recording stays
on my Mac. Is everyone OK with that?" Set your own withconsent_messageinconfig.json. - If someone says no: Stop and skip this call stops recording. The
audio so far goes toaudio/skipped/, so delete it there.
Pause auto-record stops automatic recording for calls you shouldn't
record. - Recordings stay on your Mac under
~/.maccap, readable only by you.
MacCap never uploads them. Claude Code, an assist or a notes endpoint only
get what you configure them to get. - Screen sharing: MacCap's windows ask to be left out of screenshots and
shared screens. Not every app honours that, so share one window rather than
your whole screen until you've checked yours.
The law differs from place to place, and when a call crosses borders it can
depend on where each person is. If you're not sure, ask everyone, every time.
How it works
flowchart LR
call["Call app uses the mic<br/>Zoom · Meet · Teams · FaceTime"] --> rec["MacCap starts recording"]
rec --> mic["Microphone<br/>(you, left)"]
rec --> sys["System audio tap<br/>(them, right)"]
mic --> file["Stereo .m4a + JSON sidecar<br/>crash-safe segments"]
sys --> file
mic --> stt["On-device transcription<br/>Apple SpeechTranscriber"]
sys --> stt
stt --> live["Live window<br/>transcript · notes · coach"]
stt -. "JSON lines" .-> assist["assist_command<br/>e.g. Orbital/Taxi"]
assist -. cards .-> live
live --> done["Meeting finished<br/>next steps to tick"]
done -. final_notes_command .-> claude1["Claude Code<br/>who does what"]
done -. followup_command .-> claude2["Claude Code<br/>drafts, never sent"]
Why two channels
Keeping you and them apart makes speaker labelling much easier: the left
channel is always you, so a diarizer only has to separate the other side.
Both channels share one host-time timeline, so they stay aligned for hours.
How it captures
- System audio: a Core Audio process tap (macOS 14.2+) behind a private,
tap-only aggregate device. It hears audio that ScreenCaptureKit cannot, such
as FaceTime (avconferenced) and iPhone calls (callservicesd). - Microphone: AVAudioEngine on the default input, downmixed to mono.
- Crash-safe: while recording, each side is written as AAC ADTS segments,
which survive a crash or power loss. On the next launch, unfinished
sessions are finalized automatically. - Safeguards:
- AirPods: the sample rate is read live, and checked against the real
frame rate every 10 s. This catches a Bluetooth headset switching to
16 kHz mid-call. - Denied permission: if the other side stays silent for about a minute
while you are talking, MacCap tells you. A denied System Audio permission
records silence rather than failing, so this is the only sign of it.
- AirPods: the sample rate is read live, and checked against the real
Use
Open MacCap.app. It sits in the menu bar and:
- starts recording 4 s after a call app starts using the microphone, and
stops 45 s after the call ends - offers Start recording now for anything else (manual recordings never
stop on their own) - offers Stop and skip this call, which keeps the audio in
audio/skipped/
but leaves it out of the main folder - offers Copy consent message, Pause auto-record, Start at login
and Open recordings folder
The first recording asks for Microphone and System Audio Recording
access. Grant both to MacCap itself. If you run it from a terminal, macOS asks
on behalf of the terminal instead, so always go through the app bundle:
open -W -n -a MacCap.app --args record --seconds 20 # test recording
MacCap.app/Contents/MacOS/MacCap callers # who is using audio now
MacCap.app/Contents/MacOS/MacCap finalize-pending # save unfinished sessions
With Claude Code
integrations/claude-code has one script for
both after-call steps. Add this to ~/.maccap/config.json, changing the path
to where you cloned MacCap:
{
"final_notes_command": ["/usr/bin/python3", "/path/to/maccap/integrations/claude-code/maccap_claude.py", "final-notes"],
"followup_command": ["/usr/bin/python3", "/path/to/maccap/integrations/claude-code/maccap_claude.py", "follow-up"]
}
- When the call ends, Claude reads the whole transcript and rewrites the
next steps: up to four it can do (each one a draft for you to approve), up
to two only you can do, and what the other side promised. - Hand off sends the ticked steps back to Claude, which writes each draft
into one Markdown file under~/.maccap/follow-ups/. The window shows
"4 drafts ready" with an Open link.
Claude runs with claude -p and no tools, so it can only write text: it
can't send, post or change anything. You need Claude Code installed and logged
in. Set MACCAP_CLAUDE_MODEL to use a model other than Sonnet.
With Orbital/Taxi
integrations/orbital-taxi is a call assist
that looks up the people and companies said on the call in
Orbital, through its Taxi semantic layer, and shows
them as cards while you talk. The lookups are TaxiQL templates in a config
file, so they follow your own schema, whether the facts live in a CRM, a
database or an API:
"…Priya Shah from Northwind Logistics…" → find { Person(PersonName == "Priya Shah") } → person card
→ find { Company(CompanyName == "Northwind…") } → company card
It's one Python file with no dependencies and no language model, so the same
call always gives the same cards. Its README covers setup and adapting the
templates.
Live notes
On macOS 26 or later, a small floating window opens while a call is
recorded. It shows a live transcript (You = your microphone, Them = the call)
and, every minute, notes in three parts: key points, questions, and actions
(who promised what). When the call ends the notes are saved next to the
recording as <name>.notes.md, with the transcript under them.
- Transcription: Apple's on-device SpeechTranscriber, one per side.
Nothing is sent anywhere. The speech model for your language downloads once
if it isn't installed. For calls in other languages, see
Languages. - Echo: on a speakerphone your microphone also hears the call. A line from
your side that repeats what the call side said at the same moment is left
out. - Notes model: Apple's on-device model by default (no setup; it sees the
most recent ~1,500 words). For better notes, pointnotes_model_urlat any
OpenAI-compatible endpoint, such as LM Studio or Ollama on your Mac. For a
local reasoning model (Qwen 3), MacCap turns thinking off so updates take
seconds, not minutes. - Parts of the call: the same model splits the transcript into parts as
the call goes ("Introductions", "Volumes and pricing", "Next steps"), shown
as headings in the transcript, in the Parts menu to jump to one, and in
the saved transcript. Only the part still open is looked at again, so the
parts already closed never move and a long call costs no more per update. - Picking lines: click lines in the transcript (shift-click for a run) or
a part's heading to pick the whole part. With a call assist, Help with
these or Ask about these lines… sends them (and the whole call as
background) and the answer comes up in the Assist tab; without one, Copy. - The window: menu → Show live notes while recording. Untick Open
live notes when recording to keep it closed. It asks screen sharing to
leave it out, but not every app honours that, so share a window rather than
your whole screen until you have checked yours. - Try it without a call:
MacCap demo FILE.m4a(see
Try it without a call).MacCap notes FILE.m4a
replays a recording through the same pipeline and prints the transcript and
notes, andrecord --seconds N --notestakes live notes during a test
recording.
If live notes fail, the window and the log say why. The recording carries on
regardless.
Languages
Live notes work in any language Apple's transcriber knows, about 45
languages and regional variants. These include English, Spanish, French,
German, Italian, Portuguese, Japanese, Korean, Chinese and many Indian
languages. The notes model is asked to write the notes, parts and moments in
the language of the call.
- Pick it in the live window: the 🌐 menu at the top shows the language
being transcribed. If a call turns out to be in another language, pick that
one. The transcript carries on in it from that moment, and the lines
already written stay as they are. The first time you use a language, Apple
downloads its speech model in a few seconds, and transcription carries on
in the old language until it is ready. - Or in the menu bar: Call language sets the language the next call
starts in. If you're recording, it switches that call too. - It remembers: a call starts in the language you picked last. The
languages you have picked before and the ones your Mac is set to come first
in both menus. All the others are under More languages. - Before you've picked one:
live_notes_localeinconfig.json(for
example"es_ES"), else your Mac's language. - Limits: Apple's transcriber hears one language at a time and can't tell
which one is being spoken. A call that switches between two languages is
only transcribed well in the one you picked. MacCap's own window and menus
are in English for now. - Test with a recording:
MacCap notes FILE.m4a --language es_ESreplays
a recording in a language, and--switch es_ES@90changes language 90
seconds in, as the menu does.
Notes only grow during a call: each update is merged into what is there, so
an action noted early stays in the list. With notes_model_url set, Apple's
model answers any update that endpoint can't (LM Studio not running).
Moments, actions and the next call
- Moment (button or Control-Option-M): the last minute or so becomes one
line (who does what, by when) from the notes model, as a card and a ticked
next step. Saying a phrase like "action point", "I'll follow up" or "I'll
send you" marks one by itself, unticked (moment_phrases;[]turns it off). - Typed: the box at the bottom adds an Action or a Note, or (with an
assist) asks it a question. - Said: Control-Option-A (or the mic button), say the action, press it
again. MacCap hears your microphone directly, so mute yourself in the call
app first if the others shouldn't hear it. - Next call (button, menu or Control-Option-N): saves this call and starts
recording the next at once, for back-to-back calls in the same app. Its
meeting-finished window waits until the next call ends. Stop recording
now stays stopped until the call app lets go of the mic.
Cards open on a click when they have more to show (detail, a long body,
a link); a click on the map opens its card.
Coach
The window's Coach tab shows who has done the talking: your share as a
ring (green while balanced, orange, then red past the limit), everyone as one
bar, the questions each side asked and your longest unbroken stretch. A short
"yes, go on" from them doesn't end your turn; silence does. It is measured
from the transcribed lines, so it is a guide, not a stopwatch.
A nudge appears as a card when you have talked for 90 s without a break
(coach_monologue_seconds), done 65% of the last five minutes' talking
(coach_talk_share), or asked nothing for eight minutes. Each nudge shows at
most every five minutes and never two within two minutes. "coach": false
turns it off. Talk time is saved with the notes.
Call assist
Point assist_command at a program (absolute path, then its arguments) and it
follows the call: the Coach tab becomes Assist, with cards it sends (who
someone is, an answer, something to watch for), a map of what the call brought
up, a Help me answer button, a question box, and Control-Option-H from any
app ("assist_hotkey": false turns that off). MacCap knows nothing about
where cards come from; the program gets the call as JSON lines on stdin and
answers on stdout:
| MacCap sends | Fields |
|---|---|
start |
v (1), started_at, session_dir, apps |
line |
stem (mic or system), speaker, text, start, end (seconds from the start) |
ask |
id, question, at, transcript (the call so far, so it can be asked about anything said), topics; focus (+ part) when it is about lines you picked; follows + thread when it follows up an answer |
help |
id, at, transcript (the call so far), topics, and focus + part when you picked lines (part: the title, if you picked a whole part) |
moment |
id, at, transcript (the last minute), auto (a phrase marked it) |
action |
id, text, at (one you typed or said) |
end |
(stdin then closes; 5 s to finish) |
| The program sends | Fields |
|---|---|
card |
id, kind (brief, person, company, answer, watchout, commitment, question, screen, coach, note), title, optional chips, quote, body, detail (shown when opened), link (an Open button), source, at, state (looking, ready, failed), pinned, action (next_call adds a Start next call button) |
remove |
id |
status |
text |
context |
title, workspace (shown at the top) |
speaker |
stem, start, end, name: who was talking then; the transcript uses the name |
topics is the parts of the call so far, [{"start": 130.0, "title": "Priya's volumes"}]; focus is the picked lines as [mm:ss] Who: words.
Every answer card has a Follow up button. A follow-up is an ask withfollows (the id of the answer it follows) and thread, the questions and
answers so far in that thread, oldest first: [{"question": "Ideas so far", "answer": "…"}]. If the first answer was about picked lines, so is the
follow-up (focus again). The card answering it is shown inside the first
answer's card, under the answers before it.
Sending a card with an ask or help request's id answers it. A card'sbody and detail are Markdown (bullets, numbered lists, ### headings,
quotes, code, bold, italic, links); answer cards are always shown whole,
other cards open on a click when they are long. Lines it
can't read are logged and skipped; if it stops, the call is still recorded.
Cards are saved with the notes. MacCap notes FILE.m4a --help-me --ask "…"
replays a recording through it (--follow-up "…" then follows that answer up).
Speakers call assist names enrolled voices on the call side live and can chain an existing assist with --then.
Meeting finished
When a call with live notes is saved, a window opens with how the talking went
and the next steps the notes found, all ticked: edit them, untick, add your
own. Copy notes puts a Markdown recap on the clipboard. Setfollowup_command and Hand off sends the ticked steps to it: the meeting
as one JSON object on stdin (type meeting_finished, title,started_at, duration_seconds, apps, recording, notes_file,key_points, open_questions, next_steps, talk). The last line it prints
may be JSON {"status": "...", "url": "..."}; the window shows the status and
an Open link. "meeting_finished": false turns the window off.
Set final_notes_command and the window's next steps, key points and open
questions are rewritten from the whole call once it ends: the program gets
the same JSON with type final_notes and the full transcript, and prints
one JSON object:
{
"ai_steps": ["Draft the follow-up email to Priya with the pricing bands."],
"your_steps": ["Confirm the two training slots."],
"waiting_on": ["Priya will send the printer model."],
"key_points": ["Volumes are up to 1,200 orders a month."],
"open_questions": ["Does the lower rate apply to every user?"],
"model": "Claude Code (sonnet)"
}
ai_steps show under Claude will do and your_steps under For you;waiting_on is listed apart and never handed off. A reply with onlynext_steps is read as your own steps. Steps you added during the call stay;
if you have already edited the list, the new steps are added unticked. If the
program fails or prints nothing, the live notes' steps are used.
Files
Everything lives under ~/.maccap (override with MACCAP_HOME). All files
are owner-only.
| Path | What |
|---|---|
audio/YYYYMMDD HHMMSS-<id>.m4a |
the stereo recording (Voice Memos naming) |
audio/…maccap.json |
sidecar: apps, channels, offsets, health, route |
audio/…notes.md |
live notes and transcript from the call (macOS 26+) |
sessions/<stamp>-<id>/ |
raw ADTS segments and session.json (kept) |
config.json |
optional settings (below) |
maccap.log |
log |
config.json (every key optional):
{
"audio_dir": "~/Recordings/calls",
"extra_allowlist": ["com.example.MyCallApp"],
"start_after_seconds": 4,
"stop_after_quiet_seconds": 45,
"narrow_tap_to_call_apps": false,
"ffmpeg_path": "/opt/homebrew/bin/ffmpeg",
"live_notes": true,
"live_notes_locale": "en_GB",
"notes_interval_seconds": 60,
"notes_model_url": "http://localhost:1234/v1",
"notes_model": "qwen/qwen3.6-27b",
"notes_model_api_key_env": "MY_NOTES_API_KEY",
"coach_talk_share": 0.65,
"coach_monologue_seconds": 90,
"assist_command": ["/usr/local/bin/my-call-assist", "--verbose"],
"followup_command": ["/usr/local/bin/my-follow-ups"],
"final_notes_command": ["/usr/local/bin/my-final-notes"],
"consent_message": "Mind if I record this call for my notes? It stays on my Mac."
}
allowlist replaces the built-in list of call apps; extra_allowlist adds to
it. Entries match a bundle-ID prefix or a process name.narrow_tap_to_call_apps (macOS 26+) records only the call apps instead of all
system audio. It is off until it has been proven on real calls.
Credits
The process tap, the shared stem timeline and the remote-silence detector are
adapted from Minutes (MIT, © 2026 Mat
Silverstein). See THIRD_PARTY_NOTICES.md.
License
MIT. See LICENSE.
Yorumlar (0)
Yorum birakmak icin giris yap.
Yorum birakSonuc bulunamadi

