Launching today
Heard
Give Claude Code and Codex a voice
216 followers
Give Claude Code and Codex a voice
216 followers
Heard is a macOS voice layer for your agentic workflows. It connects to Claude Code, Codex, and Cursor and turns their output into intelligent summaries you can hear. Full commentary when your eyes are elsewhere, or silence until something errors or needs a decision. With agents run in parallel, Heard summarizes at the project level, so you hear where the work stands, not five terminals talking over each other. Pair your phone and it comes with you. Open source, free for personal use.
Heard
this is a problem I've genuinely felt running a few agents in parallel - the terminal tiling stops scaling around agent 3. curious how Heard decides what's worth saying out loud versus staying silent. is it watching for specific signals like a tool-call failing or a permission prompt, or is there an LLM in the loop summarizing raw output, and if so how do you keep it from either talking over something important that's buried in a wall of routine logs, or going quiet during a long stretch that looks routine but actually needed a decision?
Heard
@galdayan yeah agent 3 is the exact wall. tiling breaks down and you end up alt-tabbing to check on things that didn't need you.
it's both of the things you guessed. some events are hard signals - permission prompts, tool-call failures, a run exiting - those get spoken no matter what. everything else goes through a pass that keeps context across the session, so it's not judging each line in isolation. it holds what's happened so far, learns what you actually care about, and decides when there's something worth saying.
the two failure modes you named are the whole problem and most of the tuning went there. talking over something buried in routine logs: the hard-signal list catches that, a permission prompt gets pulled even if it's mid-wall. going quiet during a long routine stretch that actually needed a decision: that's the harder one, and holding context is what makes it possible to catch - it knows a decision point is coming even when the surrounding output looks boring.
curious how many agents are you running, and where does it start breaking for you?
The hard signal versus context aware pass is a clean way to handle the two failure modes above. One thing I haven't seen addressed: what happens when two agents fire a hard signal within the same few seconds, say two permission prompts at once. Does it queue them and speak one after the other, interrupt whichever is talking, or try to merge them into one utterance? That's a different problem from deciding what's worth saying. It's deciding what to say first when everything worth saying happens at once.
Heard
@mohsen_bashirzadeh great question, yes it queues them - by importance :) and speaks the queue in order
@itskellysun thx , Well done
Congratulations on the launch!
This solves a problem i run into daily with multiple AI agents.how does Heard decide which updates are important enough to speak instead of reading everything? is the prioritisation customizable for different workflows?
Heard
@avery_thompson2 thanks!
two layers. hard signals always get through - permission prompts, failed tool calls, a run finishing. the rest goes through a pass that keeps context across the session, so it's weighing what actually matters against what you've already seen, not reading you every line.
and yeah, customizable. there's a verbosity dial from full commentary down to errors-only, so you can run a chatty agent loud and a background one near-silent. different workflows, different settings.
how many terminals do you typically run?
congratulations! love seeing tools that reduce context switching. how does Heard integrate with Claude Code, Cursor and Codex? is setup just a few clicks?
Heard
@imogen_wallace hey, yes! you just download the app, and it automatically picks up what's going on in claude code and codex, and speaks up right away! super easy and simple onboarding
i really like the focus on reducing cognitive load. does heard work well with very large codebases? how does it maintain context across long development sessions? curious about the underlying approach.
Heard
@james_carter35 thanks, that's the whole reason it exists.
large codebases are fine because Heard isn't parsing your repo - it's watching what the agent emits, not the code itself. so the size that matters is the session, not the project. a 400k-line monorepo and a tiny script look the same to it if the agent's output volume is similar.
long sessions are the real design problem, and it's the context part of your question. it holds state across the whole session rather than judging each event fresh, so it knows what already happened, what you've reacted to, and what's still open. that's what lets it stay quiet through an hour of routine work and still speak up when something four steps back finally resolves into a decision. reading everything would be easy - remembering enough to know what's worth saying is the actual work.
what does a long session look like for you, mostly one agent going deep or several in parallel?
Congrats on the launch! How are you guys attributing events to the right agent when they're separate processes, parsing stdout or tapping the hooks Claude Code and Codex expose?
Heard
@artstavenka1 good question, and it's the part that took the most fiddling.
hooks where they exist, stdout where they don't. Claude Code exposes hooks so that's the clean path - events come tagged with the session, no guessing. for anything that only gives you a stream, each agent runs under its own watched process, so attribution comes from the process boundary rather than trying to parse identity out of the text. the voice mapping hangs off that, which is why two agents never get confused for each other even when their output looks similar.
the messy middle is agents that half-expose structure - some signal, some raw. those get the stdout treatment with the hook data layered on top where it's available.
the thing i keep going back and forth on: how much to lean on hooks long-term. they're clean but every agent implements them differently, so a pure-stdout approach is more portable even if it's messier. curious where you'd land on that if you were building it.