Skip to content

Releases

AgentMenu 1.7.0

Choose a tag to compare

@nisarganag nisarganag released this 06 Oct 15:07

Every kind of notification now has its own on/off switch — and the context warning that was flooding notifications fires once, the way it was meant to.

The context warning was firing far too often

The "near its context limit" warning is supposed to fire once, when a session crosses 80% of its context window. It kept firing because of a bug.

AgentMenu folds each Claude Code subagent's transcript into its parent session's row, and it took the context reading from whichever transcript had written most recently. So every time a subagent ran, the reading dropped from the session's ~85% to the subagent's few percent, which reset the warning — and the parent's next message pushed it back over 80% and fired it again. The row's context meter jumped around for the same reason.

Replayed over 14 days of real sessions:

warnings before warnings after
busiest session (82 subagents) 172 5
all sessions 248 18

Each of the 18 that remain came after the context had dropped to 3–10% and climbed back up — which is what happens after compacting. Those are genuine warnings.

The context reading now always comes from the parent conversation. A subagent is a separate conversation with its own window; how full it is says nothing about how full yours is.

Claude Code notifications were all labelled "needs permission"

Claude Code reports twelve different kinds of notification. AgentMenu was showing every one of them as "Claude Code needs permission" and lighting the red permission dot — including "waiting for your input", finished subagents, and sign-in or quota notices.

Each notification is now identified by the type Claude Code attaches to it. Only real permission prompts and questions mark a session as blocked; everything else notifies without touching that.

A switch for each notification type

Preferences → Notification types lists six, each with a line explaining when it fires:

  • Permission & input requests — an agent is blocked until you approve a tool or answer a question
  • Waiting for your input — Claude has finished and is idle at the prompt
  • Turn finished — an agent finished replying
  • Subagent finished — a Claude Code subagent completed its task
  • Context nearly full — a session crossed 80% of its context window
  • Other Claude Code notices — sign-in, quota auto-resume, and anything else Claude Code reports

All six start switched on. Anything you switch off stays off across updates, and any new kind added in a later release arrives switched on rather than silently missing.

Each type is also kept separate when notifications are merged to avoid duplicates. Previously they shared one slot, so a "waiting for your input" notice could hide a real permission request that arrived a few seconds later.

Smaller fixes

  • Every switch in Preferences now lines up on the right edge, the way macOS System Settings lays them out. The new card made the old layout — each switch sitting right after its own label — zig-zag noticeably.
  • A failed API request (a placeholder message with no input) no longer counts as the session's context reading, which could also reset the warning.

311 tests pass, 18 of them new.


Install: download AgentMenu-1.7.0.dmg, open it, and drag the app to Applications. It's ad-hoc signed and not notarised, so macOS blocks the first launch — the README covers three ways past that.

AgentMenu 1.6.0

Choose a tag to compare

@nisarganag nisarganag released this 27 Sep 17:04

Costs are correct again after the new Claude and GPT models shipped. This release is almost entirely about getting the dollar figures right.

How wrong it was

Measured before the fix, against an independent calculator written from the official price lists:

app showed correct
Claude, 7 days $725.10 $1,425.71
Claude, today $36.92 $242.58 — 6.6× low
Codex, 7 days $0.37 $13.53

It was wrong in both directions at once: whole sessions vanished from the totals while the sessions that were priced were priced too high. That's why it read as random rather than merely high or low.

After the fix the app and the calculator agree to the cent — $1,439.00 vs $1,439.02 — and no session shows "—".

What was wrong

Every session was priced at the model of its last message. A session's entire lifetime got billed at whichever model spoke most recently. Switch from Opus 5 to Opus 5.5 with /model and every earlier message was re-priced as Opus 5.5 — and since Opus 5.5 had no entry yet, the whole session showed "—" and dropped out of every total. One session lost ~$590 this way. Each message is now priced at the model that actually produced it, on both Claude and Codex.

Codex billed every cache write twice. Codex counts cache writes inside input_tokens, the same way it already counts cached reads, but only the reads were being subtracted. So written tokens were charged once as input and again as writes, on 96.5% of requests. This was checked against all 1,675 real token records rather than assumed, and an existing test that had locked the double-count in has been corrected.

Codex lifetime cost shrank after every restart. It was summed from a request log that gets trimmed to about a day whenever the app saves its state.

Prices

From Anthropic's pricing page and OpenAI's pricing page, fetched 2026-09-27:

  • Claude Opus 5.5 added — $4/$20. Its cache reads are $0.20, which is 5% of input rather than the usual 10%; since cache reads are by far the largest bucket, getting this ratio wrong would double the biggest line of the bill.
  • Claude Fable 5.1 / Mythos 5.1 added — cache reads are 2.5% of input.
  • Claude Sonnet 5 corrected from $3/$15 to $2/$10. That was announced as introductory pricing, but the planned increase was cancelled and it's now the standard price.
  • GPT-6 Astra, Sol and Luna added.
  • GPT-5.6 Sol corrected from $5/$30 to $4/$20. OpenAI describes this as promotional, available "at least through November 21, 2026".
  • GPT-5.5 — removed a cache-write charge OpenAI doesn't actually bill.

Three pricing dimensions the table couldn't express before are now handled: 1-hour cache writes (2× input, separate from the 1.25× five-minute rate), fast mode (2×), and US-only inference (+10%). Where a model doesn't offer one of these, that usage is left unpriced rather than quietly billed at standard rates.

When the next model comes out

A session that uses a model the price table doesn't know yet now shows what it can price, with a trailing + — $12.30+ means "at least this much" — instead of the entire session disappearing. The TODAY total gets its * marker. Adding the model to pricing.json fills in the rest; the file now records at the top where each price came from and when.

Also fixed: the build on macOS 27

  • macOS 27's SDK needs full Xcode to compile SwiftUI, so builds with only Command Line Tools failed. The Makefile now uses the 26.5 SDK automatically.
  • Swift 6.4 moved where build output goes, which made the Intel half of the universal binary silently overwrite the Apple Silicon half. The build now produces the universal binary in one step.

Worth knowing

  • Expect one slower launch. Saved state from earlier versions holds the wrongly priced history, so it's discarded and your transcripts are re-read once.
  • Codex doesn't record which service tier a request used, so all Codex usage is priced as standard tier. Flex and Batch (50% off) or regional processing (+10%) would be slightly misstated.

293 tests pass, 25 of them new. The test for the bundled price file now checks every individual rate against the official lists, not just that each model is present — which is how the wrong Sonnet price went unnoticed for a month.


Install: download AgentMenu-1.6.0.dmg, open it, and drag the app to Applications. It's ad-hoc signed and not notarised, so macOS blocks the first launch — the README covers three ways past that.

AgentMenu 1.5.0

Choose a tag to compare

@nisarganag nisarganag released this 27 Aug 09:47

The popover is a real Liquid Glass surface on macOS 26 — the desktop refracts through it the way Control Center does.

NSPopover could never have done this

NSPopover draws its background and arrow in a private frame view that sits below the hosted content. Anything glassy layered on top therefore samples that frame's material rather than the desktop — glass over grey, which is exactly what earlier builds looked like.

Confirmed by dumping the live view hierarchy rather than assuming: _NSPopoverWindow is already opaque=false with a clear background colour, its contentView is the NSHostingView, and there is no NSVisualEffectView anywhere inside it. Nothing was in reach to neutralise.

So the container is now GlassPanel, a borderless NSPanel with a genuinely clear background, which lets the SwiftUI .glassEffect beneath the content sample what is actually behind the window. It is an NSPanel with canBecomeKey overridden rather than a plain non-activating panel, because Preferences lives in this window now and its burn-budget field has to accept typing.

Below macOS 26 it falls back to .ultraThinMaterial — still genuinely translucent, just without the refraction.

What the popover was doing for free, now done by hand

  • Positioning under the status item, clamped to the visible frame so a 360pt panel cannot land half offscreen beside a right-edge status item.
  • Click-outside dismissal, via a global monitor (clicks in other applications) and a local one (clicks in this app, which the global monitor never receives).
  • Escape to close.

The local monitor deliberately ignores clicks on the status item itself. Left in, it would close the panel on the way past, so the button's own action would then read "not shown" and immediately reopen it — the icon would have become impossible to dismiss with, flickering shut and open on every click.

Two visual defects, both found by screenshotting against a real desktop

Legibility. Untinted .regular glass left the session rows genuinely unreadable over a busy wallpaper. The surface is now tinted — black 26% in dark mode, white 42% in light. Enough contrast to hold 10–11pt text, not so much that the refraction this change exists for is smothered back into a flat panel. Control Center tints its pills for the same reason.

Hard corners around the rounded glass, as reported. Two independent causes:

  1. host.layer is nil until wantsLayer is set, so setting layer?.backgroundColor = .clear beforehand silently did nothing and the backing layer stayed opaque and square.
  2. AppKit derives a borderless window's shadow from its frame, so the shadow itself cast square corners until invalidateShadow() ran after the mask was applied.

The corner radius is a single shared constant now. The layer mask and the SwiftUI glass shape must agree exactly — a mismatch of one point leaves either a hard edge outside the glass or a clipped highlight inside it.

Resources

Idle CPU with the panel closed measures 5.73%, against 4.8% before this change; RSS 75 MB. The panel's view tree is still destroyed on close, so StatusDot's repeat-forever pulse cannot run behind a hidden window — the regression fixed in 1.2.1 stays fixed.

The first reading taken was 15.44%. That was a cold-start re-parse after a pkill skipped the checkpoint save, and it was re-measured once settled rather than published as a regression.

Not covered by tests

None of this is. It is all AppKit window behaviour in AgentMenuUI, and the test target depends on AgentMenuCore only. 268 tests pass, and none of them touch a window.


Install: download AgentMenu-1.5.0.dmg, open it, drag to Applications. Ad-hoc signed and not notarised, so macOS blocks the first launch — the README covers three ways past that.

AgentMenu 1.4.1

Choose a tag to compare

@nisarganag nisarganag released this 26 Aug 11:20

One fix: a session's displayed duration was the wall clock, not the session.

Session time was counting the days since a session ended

The row rendered now - startedAt — the session's age, not its length. Since transcripts are retained for seven days, a finished session's figure kept climbing the whole time it sat on disk.

Measured on real sessions, before against after:

displayed before actual
187h04m 27m36s
161h02m 2m44s
160h56m 1s
160h54m 6m58s
147h38m 7m29s

A session that genuinely ran six minutes was reporting 167.9h. The entire difference was time after it had finished.

Duration is now AgentSession.span — first recorded activity to last. It takes no now parameter, and that is the fix rather than an omission: a finished session's length is a fact about the past with no clock left to drift against, and a live session needs no special case either, since its own lastEventAt advances as it works.

What it still counts, and why

Idle stretches within a session are included — a session left open over lunch counts the lunch. That is the honest answer to "how long was this session", and separating real working time from waiting-on-you time would mean inferring which gaps were which.

So sessions resumed across days still show long spans, and those figures are correct: first activity to last really was that far apart.

The two other elapsed-time readouts — "how long has this prompt been waiting" and "how long since the last activity" — remain deliberately now-relative, because those genuinely are questions about the present. All three now share one formatter, so the row and its tests cannot disagree.

Why this survived four releases

The calculation lived inside SessionRowView, and the test target depends only on AgentMenuCore — so no test could reach it. span and the formatter now live in Core specifically so they are testable.

9 tests added, 268 pass.


Install: download AgentMenu-1.4.1.dmg, open it, drag to Applications. Ad-hoc signed and not notarised, so macOS blocks the first launch — the README covers three ways past that.

AgentMenu 1.4.0

Choose a tag to compare

@nisarganag nisarganag released this 25 Aug 18:08

Notification sounds, real switches, a Liquid Glass Preferences panel — and Preferences is now a page of the popover rather than a window of its own.

Notification sounds

A Play sound toggle in Preferences, on by default.

It uses UNNotificationSound.default rather than a named system sound, because a named sound that is missing at runtime delivers silently — indistinguishable from the toggle not working. The osascript fallback path carries the setting too (sound name "Ping", present on every install); without that, sound would have been a coin-flip on whichever delivery route happened to be taken.

Deliberately not .defaultCritical, which would pierce Do Not Disturb. That is not a decision a menu bar app should make on your behalf. Focus and DND still apply, and the panel says so inline rather than leaving you to wonder why a setting you turned on made no noise.

Preferences: switches, glass, and no more separate window

Every control is a switch instead of a checkbox. .toggleStyle(.switch) is applied once at the root, so a control added later cannot quietly come back as a checkbox — which is AppKit's default and what all nine of these were.

Sections are Liquid Glass cards on macOS 26+, grouped in a GlassEffectContainer so the system blends them as one optical unit. Applied individually they are just separate frosted rectangles. The app still deploys to macOS 14, so every use is behind #available; the fallback is a real material card, not a no-op — without a background the sections lose their grouping entirely, and "looks plainer" is a fine degradation where "reads as one undifferentiated column of switches" is not.

Preferences now lives inside the popover. The separate NSWindow is deleted rather than hidden: showPreferences(), preferencesWindow, 45 lines of window setup, and the behind-window blur that only existed because it was a window. NSPopover already supplies the pane, and blurring an already-blurred surface reads as muddy rather than layered.

The header morphs instead of stacking a second bar — metrics and gear on the agent pages, "‹ Back" and PREFERENCES in settings. A second chrome row would read as a dialog inside a dialog. Cost figures are dropped from the settings bar on purpose: leaving them up while you edit a burn budget invites reading one as a preview of the other.

Settings state resets each time the popover opens. Opening the menu bar icon must always land on the agents, or it would silently defeat the attention routing that chooses which agent page to open on.

Three defects found by screenshotting the build

None were visible to the compiler or to 259 passing tests:

  1. The Preferences window collapsed to a bare 64pt titlebar, every control unreachable. NSHostingController publishes the SwiftUI content's size as preferredContentSize, and a ScrollView root reports a minimal height; the window obeyed. (Moot now that the window is gone, but it is why the ScrollView is sized the way it is.)
  2. Cards shrink-wrapped their own longest row, so section widths visibly jumped down the column.
  3. The titlebar rendered as a solid light strip above the dark panel.

Scroll indicators are .never, not .hidden — .hidden is advisory and is overridden by "Show scroll bars: Always" in System Settings, the same trap already documented for the agent pages.

Why your notifications say "Script Editor"

Investigated properly rather than guessed at, and now recorded under Known limitations.

macOS refuses an ad-hoc-signed app permission to use UNUserNotificationCenter at all:

UNErrorDomain Code=1 "Notifications are not allowed for this application"
granted=false

So AgentMenu falls back to osascript, whose display notification posts under Script Editor's identity. The app never appears in ~/Library/Preferences/com.apple.ncprefs.plist, which is why it never shows up in System Settings to be allowed in the first place.

Ruled out by testing rather than assumption: install location (same from /Applications), LaunchServices registration (same after lsregister -f), and launch path (same via open -a as when exec'd directly). The remaining variable is the ad-hoc signature, which cannot be confirmed without a Developer ID to test against — so signing is stated as the fix, not as a proven diagnosis.

The banners themselves are correct and carry sound. Only the name and icon in the header are wrong.

Still known to overstate

Sonnet 5 is priced at list ($3/$15) while its introductory rate ($2/$10) runs until 2026-08-31. That is roughly 5.5% high until then and exactly right afterwards. It is left at list so figures do not under-report once the intro lapses.

259 tests pass.


Install: download AgentMenu-1.4.0.dmg, open it, drag to Applications. Ad-hoc signed and not notarised, so macOS blocks the first launch — the README covers three ways past that.

AgentMenu 1.3.0

Choose a tag to compare

@nisarganag nisarganag released this 25 Aug 14:13

A correctness fix that changes every dollar figure the app has ever shown, plus a small addition.

Cost was 2.68× too high

Reported by the owner, who could check the figures against the Claude console.

Claude Code writes one JSONL record per content block of an assistant response — the text on its own line, each tool call on the next — and every one of those records repeats a verbatim copy of the whole response's usage. That usage belongs to the request, not to the record. Folding it per-record multiplied cost by however many blocks the reply happened to contain.

Measured across all 878 transcripts on the owner's machine before anything was changed:

duplicate groups 29,026
copies byte-identical in all four token buckets yes, every one
distinguishing field parentUuid only — same file, same requestId
reported vs real $20,271.36 vs $7,577.09 — 2.68×

Deduplication is keyed on the response id (message.id, falling back to the top-level requestId). Per-file deduplication was verified to capture the entire win — deduping globally across files changes the total by 1.000×, so response ids never recur across transcripts and no cross-file registry is needed.

The window is bounded at 128 rather than an unbounded set, because it is persisted in every checkpoint. That bound is sized off the real distribution: copies of one response are separated by a median of 2 records and at most 29 across every file on disk, the gaps being user-side tool_result records. Erring here is safe in one direction only — too small merely misses a duplicate and over-counts as before, and can never subtract usage that was real.

Deduplication skips the token fold only, never the whole record. The copies are the response's different content blocks, so the second and later ones carry the tool calls; bailing out of the record would have left every multi-block turn showing its opening sentence and never the tool it ran. That was caught during implementation and is covered by a test.

checkpointVersion 1 → 2 — not merely because a field was added, but because every checkpoint written before this holds the inflated totals. Carrying them forward would have meant the fix never reached anyone already running the app. Expect one slower launch as history is re-derived.

Verified against an independent implementation, not just against itself: over the live 7-day window the source produced 5,810,010 work tokens against 5,809,617 computed separately in Python — 393 apart on 5.8M (0.007%), which is the transcript growing between the two runs. The same window read 22,308,145 before the fix.

Codex is not affected — it assigns from the cumulative total_token_usage rather than summing, so repeated records are idempotent there. opencode reports cost natively and never used this path. Both were checked rather than assumed.

Also confirmed while investigating: every usage-bearing record is type assistant (23,975 in the 7-day window, none of any other type) and all four token buckets are always present, so nothing was being silently missed.

Version stamp in the footer

The running version now sits bottom-left of the popover, balancing "Quit" across from it — tertiary grey and monospaced so it reads as a stamp rather than a control, since it sits beside the only button down there.

It deliberately does not append CFBundleVersion. That counter is published nowhere — not in a release tag, not in the DMG name — and since the two use different numbering schemes, a "show it only when it differs" rule would have been true every single time, making it permanent noise on the one line that has to stay glanceable.

Absent rather than a placeholder when the bundle has no version, the same rule the rest of the app follows for anything it cannot establish.

Still known to overstate

Sonnet 5 is priced at list ($3/$15), but its introductory rate ($2/$10) runs until 2026-08-31. On the owner's data that is a further ~5.5% overstatement until then, and exactly right afterwards. Sonnet is the most-used model in that sample, so this is not negligible — it is left at list price so figures do not under-report once the intro lapses.

259 tests pass (was 248).


Install: download AgentMenu-1.3.0.dmg, open it, drag to Applications. Ad-hoc signed and not notarised, so macOS blocks the first launch — the README covers three ways past that.

AgentMenu 1.2.1

Choose a tag to compare

@nisarganag nisarganag released this 22 Aug 10:16

Two bug fixes from real use, both root-caused against live session data before anything was changed.

Opening the popover now lands on the agent that's actually running

Reported: Claude Code was mid-turn; opencode had finished over an hour earlier and its app was closed. The popover still opened on the opencode page.

Two independent defects were behind that:

  1. .working was not a tier at all. The landing order was exact permission → inferred permission → most-recent .done. A running agent contributed nothing to the ranking, so it lost to any finished session, at any age.
  2. The .done tier had no age limit. Every session ends in .done and the sources retain a week of them, so that tier was almost always matched by something stale. Fixing only the first defect would not have held — an idle Claude between turns isn't .working either, so a day-old opencode .done would have recaptured the page the moment a turn ended.

New order:

  1. exact permission prompt — most recent
  2. inferred permission prompt — most recent
  3. running session — the one running longest
  4. turn finished within the last 10 minutes — most recent
  5. the page you last chose

Tier 3 orders by earliest startedAt, the opposite direction to every other tier. That's deliberate: elsewhere the timestamp marks a moment that just demanded attention, here it marks the start of a stretch, and the longer the stretch the likelier it's the session you came to check on.

Permission prompts still outrank a merely-busy agent. A working agent needs nothing, and surfacing the one that does is the point of the app.

Idle CPU: 17% → 4.8%

Reported: 17% CPU at rest.

Profiling put Core Animation at the top, running a full commit/layout cycle at frame rate behind a closed popover. StatusDot drives a .repeatForever(autoreverses:) pulse for every working or blocked session, and a repeating animation doesn't care whether anyone can see it. The SwiftUI tree was built once in init and lived for the whole run of the app, so those pulses never stopped.

1.2.0's fix — suppressing model mutations while hidden — could never have caught this, because the animation is self-perpetuating and needs no model change to keep going. The tree is now mounted on open and torn down in popoverDidClose: a hidden view that doesn't exist can't do work, which closes the whole class of bug rather than this one instance. (NSPopoverDelegate was already declared on the controller but never assigned, so close events were going unobserved entirely.)

Measured with the popover closed and one session working:

1.2.0 1.2.1
CPU 17.0% 4.76%
Warm start — 4.96% CPU / 51 MB RSS
RSS over 6 open/close cycles — flat (101 → 100 MB)

An isolation build with the pulse disabled read 4.51%, pinning ~12.5 of the 17 points on the animation alone.

For the record: 1.2.0's release notes quoted 4.6%. That reading was taken with no session working, so no dot was animating — accurate for that moment, but not the steady state.

Not done, and why

1.2.0 suggested slowing the 2-second heartbeat while idle as the next lever. On inspection that isn't safe yet: spool.drain() is called only from that heartbeat, and the permission-hook spool has no file watcher of its own. Slowing the timer would directly slow permission alerts. It needs the spool watched first.

The README's "180 MB RSS and ~3% CPU" has been replaced with measured figures.

248 tests pass (was 239).


Install: download AgentMenu-1.2.1.dmg, open it, drag to Applications. It's ad-hoc signed and not notarised, so macOS blocks the first launch — the README covers three ways past that.

AgentMenu 1.2.0

Choose a tag to compare

@nisarganag nisarganag released this 21 Aug 12:54

Better numbers, a much lighter app, and four smaller improvements.

The numbers are now correct

A real "Today". 1.1.0 said "Since Launch" because the app could only count what it personally watched. Transcripts carry per-message timestamps alongside per-message usage, so the calendar-day figure is now computed exactly — local midnight, not a rolling 24 hours. opencode can't be windowed this way (its database stores per-session totals only), so when it's present the figure is marked partial rather than quietly under-reporting.

The token count stopped being alarming. It showed 804.7M tok for a day whose actual work was 2.1M — 92% of the raw total was cache reads, which are re-reads of context already counted once. The displayed figure is now input + output. Cost is unchanged; it always priced cache correctly at 0.1×.

Codex long-context pricing. OpenAI charges 2× input above 272k tokens. Applied per-request, where the rollout actually tells us the request size.

A measured rate limit, not a guessed one. AgentMenu still refuses to invent a quota percentage. But it now watches for real rate-limit errors and records your burn at that moment. Once it has seen one, it can show a percentage against a ceiling it actually observed. Until then: nothing.

Much lighter

Parser state is checkpointed alongside byte offsets, so a relaunch restores instead of re-reading your history.

1.1.0 1.2.0
Memory ~199 MB ~61 MB
Second launch ~4.0 s ~19 ms

A checkpoint is only trusted if the file's size and modification date still match and the format version agrees — anything else discards it and re-reads. Wrong token totals would be far worse than a slow launch.

Also fixed a 15.6% idle-CPU regression: the SwiftUI view tree stays instantiated behind a closed popover, so refreshing the model was re-rendering something nobody could see. Now ~4.6%.

Smaller things

  • Context warnings. A notification when a session passes 80% of its context window — the moment to compact. Only fires for sessions with a known window, once per crossing, and re-arms if it drops and climbs again.
  • Hide agents you don't use. Per-agent toggles, plus auto-hiding anything never seen on this machine. Page dots follow.
  • The menu bar says what's blocked. ⏸ ezeeabanotes for a single confirmed block, ⏸ 3 for several. Inferred attention keeps the amber treatment and is never described as blocked.
  • Scroll indicators removed from both axes — they persisted for anyone with "Show scroll bars: Always".

Not included

Gemini CLI support. It's installed on the author's machine, so it was considered — but its logs.json records only user prompts, with no assistant turns and no token usage anywhere. A Gemini page would be almost entirely —, which is worse than no page.

Install

Download the DMG, drag AgentMenu.app to Applications. macOS will block the first launch (ad-hoc signed, not notarised): System Settings → Privacy & Security → Open Anyway, or right-click → Open → Open, or xattr -d com.apple.quarantine /Applications/AgentMenu.app.

No Dock icon by design — look in the menu bar. Requires macOS 14+. Universal binary.

239 tests.

AgentMenu 1.1.0

Choose a tag to compare

@nisarganag nisarganag released this 21 Aug 08:13

One page per agent, a real app icon, and four bug fixes found by actually running 1.0.0.

New

Swipeable pages, one per agent. The single scrolling list is gone. Claude Code, Codex and opencode each get their own page, swiped horizontally, with three dots showing where you are. Opening the popover lands you on whichever agent most recently wanted something, so the thing demanding attention is the thing you see first.

That also fixes what the list was doing wrong: rows were sorted by state, so every state change reshuffled the whole list under your cursor, the scrollbar jittered, and scrolling down snapped you back to the top. Per-agent pages confine that churn to a handful of rows. The popover now has a genuinely fixed size too, so it no longer resizes and clips itself when a notification arrives while it's open.

An app icon — three segmented meters in the agent accent colours, matching the app's own visual language.

Fixed

  • A permission dot could never clear once the agent died. If you closed the terminal while Claude was asking for permission, the red dot stayed forever. It now releases when the agent's process is gone, or after 90 seconds of a stale transcript.
  • opencode kept showing WORKING long after you quit it. Its idle threshold was 120s while Claude and Codex used 25s. Now consistent, plus a process-liveness check.
  • The header cost was wrong by roughly 40x. On launch, every session's entire lifetime spend was counted as though it had just happened. It now seeds silently on first sight and only counts what it actually observes — and the label reads "Since Launch", because calling it "Today" would have been untrue.
  • Claude hooks could duplicate without bound and become un-uninstallable. Claude Code rewrites settings.json and strips unknown keys, including the marker AgentMenu used to recognise its own entries — so it kept re-adding them. Entries are now identified by their command path, which survives.
  • Codex reclaims its notify setting, which silently killed Codex alerts while Preferences still showed the toggle on. AgentMenu now detects this and says so plainly instead. It deliberately does not fight Codex on a timer — that would churn your config.

Install

Download the DMG, open it, drag AgentMenu.app to Applications.

macOS will block the first launch. AgentMenu is ad-hoc signed, not notarised (that needs a paid Apple Developer ID). Use whichever works on your version:

  • System Settings (most reliable on macOS 15+) — double-click once, dismiss the warning, then System Settings → Privacy & Security, scroll to "AgentMenu.app was blocked…", click Open Anyway.
  • Right-click (macOS 14, sometimes later) — right-click AgentMenu.app → Open → Open. Double-clicking and Launchpad will not work.
  • Terminal — xattr -d com.apple.quarantine /Applications/AgentMenu.app

There is no Dock icon and no window; look for the glyph in your menu bar. Click it → Preferences for Start at login and the permission hooks. Start at login requires the app to be in /Applications.

Requires macOS 14+. Universal binary (Apple Silicon and Intel).

Still true about the numbers

  • Codex permission state is inferred and shown as such — hollow amber ring, "MAYBE WAITING", never the solid red a confirmed block gets. Codex records no approval events anywhere.
  • No provider quota percentages — neither Claude Code nor Codex persists rate-limit state locally, so any "% of your weekly limit" would be invented.
  • Unknown numbers render as —, never $0.00 or a meter against a guessed context window.

155 tests. Verified end-to-end against live agents.

AgentMenu 1.0.0

Choose a tag to compare

@nisarganag nisarganag released this 20 Aug 23:42

A macOS menu bar app that tells you what your AI coding agents are doing — and when one is waiting on you.

Monitors Claude Code, Codex and opencode across CLI, IDE-extension and app modes: current activity, token totals, cost, context-window fill, and a permission alert when an agent is blocked.

Install

Download AgentMenu-1.0.0.dmg below, open it, drag AgentMenu.app to Applications.

macOS will block the first launch

AgentMenu is ad-hoc signed, not notarised (that needs a paid Apple Developer ID), so you'll see "AgentMenu.app cannot be opened because the developer cannot be verified." This is expected and happens once. Use whichever works on your version:

System Settings (most reliable on macOS 15+) — double-click the app once, dismiss the warning, then go to System Settings → Privacy & Security, scroll to "AgentMenu.app was blocked…" and click Open Anyway.

Right-click (macOS 14, sometimes later) — right-click or Control-click AgentMenu.app → Open → Open. Plain double-clicking will not work, and neither will Launchpad.

Terminal (if neither appears) — xattr -d com.apple.quarantine /Applications/AgentMenu.app

After it opens

There is no Dock icon and no window — that's intentional. Look for the pulse glyph in the menu bar, top right. Click it → Preferences to enable Start at login and install the permission-detection hooks.

Start at login requires the app to live in /Applications — SMAppService registration fails elsewhere.

Requires macOS 14+. Universal binary (Apple Silicon and Intel).

What's honest about it

  • Codex permission state is inferred, and shown as such. Codex records no approval events anywhere on disk, so a blocked Codex is a stall heuristic — rendered as a hollow amber ring and "MAYBE WAITING", never the solid red a confirmed block gets.
  • No quota percentages. Neither Claude Code nor Codex persists rate-limit state locally, so any "% of your weekly limit" would be invented. You get absolute rolling burn instead, plus an optional budget you set yourself.
  • Unknown numbers render as —, never as $0.00 or a meter against a guessed context window.

Touching your agent configs

Permission alerts need hooks in ~/.claude/settings.json and ~/.codex/config.toml. Both are opt-in from Preferences and fully reversible: a timestamped backup is written before any edit, every entry AgentMenu adds is tagged, and the Codex shim forwards to whatever notify program you already had. The installer refuses rather than risks a config it cannot safely round-trip.

Known limitations

  • Ad-hoc signed, not notarised (that needs a paid Developer ID).
  • Claude's permission_prompt hook subtype is unproven — the idle subtype was verified live and maps correctly.
  • opencode context meters require the model to be in pricing.json (deepseek-v4-pro and kimi-k3 ship).
  • Codex cost is an estimate; OpenAI's service-tier and long-context multipliers aren't modelled.
  • ~180 MB RSS and ~3% CPU while agents are active, most of it a one-time parse of transcript history at launch.

130 tests. Verified end-to-end against live agents.