Skip to content

Home

Jump to bottom
lukataylor-pixel edited this page Apr 4, 2026 · 2 revisions

NotchBar

NotchBar is a macOS notch application for monitoring local coding agents.

Instead of burying agent state inside terminal tabs, it turns the notch into a compact status surface for active sessions, pending actions, recent tool activity, and session cost. The app is designed for people who already work with terminal-first agents and want a faster way to stay aware of what those agents are doing.

Core Idea

Modern coding agents spend long stretches working outside the place you are currently looking. They read files, run commands, write patches, ask for approval, and occasionally block on user input. In practice, that means you either keep a terminal front and center or you lose visibility.

NotchBar solves that visibility problem.

It does not replace the terminal session. It sits above it and continuously answers the questions that matter:

  • Which agent is currently active?
  • What is it doing right now?
  • Did it just modify something important?
  • Is it waiting for me?
  • How much work and cost has accumulated in this session?

What the App Shows

The notch panel is built around active agent sessions.

For each session, NotchBar can surface:

  • current state
  • recent task timeline
  • last reasoning snippet
  • last response
  • token usage
  • estimated cost
  • pending approval state
  • terminal availability
  • git status context

When the panel is collapsed, it behaves like a high-signal status strip. When expanded, it becomes a session dashboard.

Supported Providers

NotchBar is not hard-coded to a single agent runtime. The app is built around a provider layer so multiple local agents can share one UI.

Claude Code

Claude is currently the most integrated path.

  • live hook events
  • live approval flow
  • tool lifecycle tracking
  • session monitoring
  • resume support
  • instruction file discovery through CLAUDE.md

Claude integration is installed by writing NotchBar-managed hook entries into:

~/.claude/settings.json

Codex

Codex support is implemented as a first-class provider, but the runtime model is different.

  • running session discovery from local codex processes
  • transcript-driven task parsing from ~/.codex/sessions
  • resume support
  • terminal input support
  • instruction file discovery through AGENTS.md
  • managed NotchBar Codex profile in ~/.codex/config.toml

Codex still owns its terminal approval UX. NotchBar tracks the session and timeline around it rather than faking Claude-style hook approvals where they do not exist.

Onboarding Flow

On first launch, NotchBar walks through a provider-aware onboarding flow.

That flow covers:

  • what the app is for
  • which provider is selected by default
  • what integration will be installed for that provider
  • approval preferences
  • global shortcuts

The integration step is provider-specific:

  • Claude installs hooks
  • Codex installs a managed notchbar profile

This matters because the app avoids pretending all providers behave the same way.

Install and Runtime Model

NotchBar is a local macOS app built with SwiftUI and AppKit.

It uses a provider-neutral core and provider-specific runtime controllers.

At a high level, the architecture is:

  1. App shell Owns windows, notch panels, menu bar items, settings, onboarding, and shortcuts.
  2. Shared session model Owns provider-neutral session state, task state, costs, approvals, and UI-facing metadata.
  3. Provider implementations Own session discovery, transcript reading, integration install/remove, resume behavior, and provider-specific parsing.

This split keeps the shared UI from collapsing into a large chain of provider-specific special cases.

Why the App Uses the Notch

The notch is persistent, visible, and already centered around glanceable interaction.

That makes it unusually well suited to agent monitoring:

  • always near the top edge of the workspace
  • visible without taking over a full window
  • easy to expand only when more detail is needed
  • ideal for short-lived interruptions like approvals or input requests

The app treats the notch as a control surface, not just a branding gimmick.

Current Maturity

NotchBar is already functional, but it is still actively evolving.

Current strengths:

  • multi-provider architecture
  • Claude live integration
  • Codex session and transcript support
  • clear onboarding and installer flow
  • local-first runtime model

Current limits:

  • Codex live approval routing is not yet equivalent to Claude hooks
  • multiple concurrent sessions in the same project can still collapse into one visible card depending on provider session association
  • the product is still early enough that provider support continues to deepen over time

Intended Audience

NotchBar is for developers who:

  • use Claude Code or Codex locally
  • prefer terminal-first workflows
  • want agent visibility without dedicating screen space to a full dashboard
  • care about approvals, diffs, and session progress at a glance

It is especially useful when multiple sessions are running or when the agent is doing meaningful work in the background.

Summary

NotchBar is a local-first macOS utility that makes coding agents easier to supervise.

It takes a part of the screen that is usually decorative or ignored and turns it into a practical runtime dashboard for agent work. The result is a lighter, faster feedback loop between developer and agent, especially when the real work is happening in the terminal.

Clone this wiki locally