How do you stay aware of what your AI coding agents are doing?

@andrew_king10 

Direct answer: yes, but only if you get one design decision right, and most attempts get it wrong. The unified thing cannot be a place you check. It has to be a thing that checks you. The moment it's a tab you're supposed to glance at, you've rebuilt the terminal grid with nicer fonts, and it joins Slack and email in the pile of surfaces you're already half-monitoring. The dashboard failure mode isn't ugly UI, it's wrong polarity.

So the reliable pattern is push-first with a brutal filter: the layer stays completely dark except for three states, done with a summary, stuck on input, failed. Everything else lives in logs you visit by choice. If it interrupts you, your brain is genuinely required, every time, no exceptions. That's what keeps the channel trusted instead of muted. The discipline is in what it refuses to show you, not what it can.

That's exactly the shape I built Pushary around: one inbox across Claude Code, Cursor, and Codex, silent by default, and when it does ping, the notification carries the decision, what changed, what it needs, what's risky, answerable from your phone. You never monitor it. It taps you, you rule, you go back to deep work. If it ever tempts you to sit and watch it, I built the wrong thing.

And your capability-versus-visibility framing is the correct diagnosis, by the way. The models stopped being the bottleneck months ago. The human's perception bandwidth is the constraint now, and context switching is how you pay for the gap. Question back: when you context-switch to check an agent, what costs you more, the check itself or reloading whatever you were doing before? I keep finding the reload is the real tax and the check is just the trigger.

@aadilghani  @andrew_king10  Visibility over capability is exactly right, context switching is the hidden tax. The trick is solving it without adding one more dashboard you have to babysit.

@md_khayruzzaman 

Your closing line is the whole thread in one sentence: the workflow is surprisingly manual considering how autonomous the agents are becoming. That's the paradox exactly. The agents got self-driving and the supervision is still a guy walking between terminals with a clipboard. The autonomy moved down the stack, the awareness didn't move at all.

And your setup proves the point better than any pitch could. Desktop notifications plus separate terminals plus a Pushover script plus periodic checks, that's four partial systems doing one job badly. Each piece works, but you've become the integration layer between them, which is why it feels like another thing to monitor. You didn't eliminate the babysitting, you distributed it.

Here's the part I have to just say plainly: your four-point wishlist is Pushary's feature list, almost word for word. One place for all agent status, instant ping when one needs input, a summary of what changed while you were away, and approvals you can answer from your phone. You wrote the spec, I built it, pushary.com. I'd genuinely like you to try it and tell me where it falls short of the list you just wrote, because you've clearly lived this problem long enough to be a brutal judge.

One question to calibrate: of your four wishes, which one would you pay for first? My bet is number four, phone approvals, because the 30-minute blind wait is the one you called the biggest issue. But people keep surprising me by picking the summary instead.

@kevinzrzgg 

The new idea in this one is your last sentence, and it's bigger than the spec: "if it can't produce that summary, I'd rather keep the run small." You just made the handoff a precondition for autonomy, not a nice-to-have. The size of task you're willing to delegate is capped by the quality of the report you get back. No summary, no long leash. That's the cleanest articulation of trust I've seen in this thread, and it flips the usual framing, people think autonomy is about the agent being smart, you're saying it's about the agent being legible.

Which means the handoff isn't a notification feature, it's the thing that unlocks bigger runs. Improve the report, and the same agent safely earns longer horizons. That's the actual product, the trust dial.

And agreed on the split, done and stuck are different species. Done is informational, read it whenever. Stuck is a blocked thread costing you minutes right now. They shouldn't even sound the same on your phone.

Pushary's bet is exactly this shape: the handoff (status, files, tests, waiting-on-what) as the standard payload, stuck as the loud one. One question, since you've effectively defined the trust dial: what's missing from today's agent summaries that stops you trusting longer runs, accuracy of what they report, or the stuff they leave out? Lying versus omitting feels like the difference between fixable and dangerous.

@yashvinder_singh 

"Fast but unaccountable junior developers" is the right mental model, and the word doing the work is unaccountable. A human junior has skin in the game, embarrassment, a performance review, a memory of last time. An agent has none of that, so the accountability has to live in the system around it: diffs, tests, linters, small reviewable steps. You're not describing caution, you're describing replacing the missing accountability with architecture. That's the correct trade.

The phrase I'd frame, though, is your last one: supervising execution at speed. Because that's where the model strains. Diffs-as-control works perfectly at one agent, the math is on your side. At four agents producing PR-sized diffs in parallel, the diffs don't shrink, your hours do. The control mechanism stays correct and you become its bottleneck. Reviewing everything was the answer when the agents were slower than you. They aren't anymore.

So the question becomes how to keep your discipline affordable at speed, and the answer isn't reviewing less carefully, it's triaging what reaches you. Tests and linters already filter the mechanical failures before your eyes get involved. The missing layer is the same filter for attention: which diff touched something risky, which agent is blocked on a judgment call, which run finished clean and can wait until after lunch. That's the slice Pushary handles, the handoff arrives with the diff, the test results, and a risk flag, so your review time lands on the 20% that needs a human and the routine stuff stops costing you context switches.

You clearly run this discipline for real, so the question I'd ask: at how many parallel agents does your review-everything approach start to crack? Everyone has a number where the queue outruns the reviewer. Mine was three. Curious where yours is, because that number is basically the whole market for this category.

@theuniverseson 

"Finished, looks done, quietly wrong" is the scarier sibling of the silent wait, and you're right that it bites harder. A blocked agent costs you minutes. A confidently wrong "done" costs you whatever gets built on top of it before anyone notices. The wait wastes time, the lie compounds.

The move you made is the important one: you demoted the agent's "done" from a fact to a claim. Self-report is testimony. The diff is evidence. And your economics are exactly right, ten seconds of reading evidence beats re-running a task that testified falsely, every single time. The diff can't lie about what changed, it can only be misread, and that's a much better failure mode to own.

That's precisely why Pushary's "done" notification refuses to arrive empty-handed. The claim ships with its evidence attached: the diff, the tests that ran, what failed, flags on anything risky. "Done" alone is the agent grading its own homework. "Done, here's exactly what I touched" is the agent submitting it for your ten-second scan. The notification's job isn't to tell you it finished, it's to make your distrust cheap.

One question, because you've clearly tuned this: does the ten-second scan ever miss the quietly-wrong case where the diff itself looks reasonable, right files, plausible changes, but the logic is subtly off? That's the layer where I suspect the scan needs test results sitting next to it, because a clean-looking diff with a failing test tells you in two seconds what reading the code might miss in ten.

@nayan_joshi 

You just named the actual engineering problem underneath this whole thread, and you're right: there is no output contract. One agent announces completion, one just goes quiet, one blocks on stdin without saying a word, and silence is semantically ambiguous across all three. Done, stuck, and crashed can produce the identical absence of output. You can't build a clean signal on top of systems that don't agree on what stopping means.

So any honest notification layer has two choices. Hope a standard emerges, or absorb the brittleness on behalf of everyone. The good news is it's not pure terminal-scraping anymore: Claude Code ships hooks, Codex has lifecycle events, and where a real hook exists you get a true state transition instead of a guess. Where one doesn't, you're back to heuristics, process state, file activity, stdin-wait detection, and yes, that adapter is brittle and needs maintenance every time a tool changes its behavior. The question is just where that brittleness lives: in a thousand people's personal dotfiles, each breaking separately and silently, or in one adapter layer that's somebody's actual job to keep current.

That second option is literally what Pushary is. Per-agent adapters on the bottom, normalizing whatever each tool emits into one state machine, running, blocked-on-input, failed, done-with-diff, and one contract on top that your phone and your team consume. The agents never agreed on a standard, so the layer fakes the standard and eats the maintenance. You pay us to own the brittleness so your tmux split can go back to being a layout choice instead of a monitoring strategy.

And if a real standard ever does emerge, some agent-lifecycle event spec the vendors actually adopt, that's not a threat to the layer, it's a gift, the adapters get thinner and the value moves up into routing, policy, and the approval flow. Genuine question from the trenches: of the agents you run, which one's blocked state is hardest to detect from outside? My ranking has the silent-stdin-wait as the worst offender by far, since it's indistinguishable from thinking, but you're running the same pair and I'm curious if your experience matches.

@vlasoffchess 

You and at least five other people in this thread independently landed on the same two words, "control center," and then immediately flinched at them, because you all also said the same fear: not another dashboard to babysit. That tension is the whole design problem in one breath. People want one place that knows everything and zero places they have to watch. Those sound contradictory and they're not, but only if you get the polarity right.

The resolution is that a control center you check has failed, and a control center that checks you has worked. Same data, opposite default. It sits dark, knows the state of every agent, and stays silent until one crosses into a state that needs you: blocked on input, finished with a diff, failed. The "what each agent is doing" view exists for the moment you want it, but you're never required to look, because the looking comes to you. The babysitting fear is real and the fix isn't a prettier dashboard, it's making "forgot to check it" impossible by never requiring the check.

Your last item is the sharp one, by the way: "whether it is safe to approve." That's the highest bar in the list. Status is mechanical, the diff is mechanical, but "safe to approve" requires the layer to know that a payment change or an auth edit is a different animal than a typo fix. That's the risk flag, and it's the difference between a notification you glance at and a decision you can actually make from the lock screen.

That's exactly the shape of Pushary, so the honest test is whether it clears your bar without becoming the thing you fear. Question back, since you've run multiple agents: would you trust the layer to tell you "safe to approve," or do you want it to just surface what changed and let you make that call every time? I keep going back and forth on whether people want the judgment or just the evidence, and your answer tells me which one to build louder.

@jiaqi_lu 

A desktop aquarium as an agent status light is the most charming thing in this entire thread, and underneath the whimsy you solved the exact problem everyone else is overcomplicating. You turned monitoring into ambient peripheral vision. Nobody "checks" an aquarium, you just notice when it changes color, which means zero context-switch cost. That's the part most notification systems miss: the best status signal isn't one you read, it's one your eyes catch without focusing. You made the awareness free.

Your three states are also quietly correct. Blue for done-or-idle, the generating shimmer as pure ambient "it's alive, relax," and amber as the only one that actually pulls you back. That's the done/working/needs-you split everyone in this thread keeps reinventing, except yours doesn't make you read anything. The genius is that amber is the only color that costs you attention, and it only fires when attention is actually owed.

Here's the one ceiling, and you already know it because you said "for myself": the aquarium is on your desk. It's a beautiful local solution to a problem that follows you to lunch, to meetings, to the moment you've walked away, which is precisely when the amber matters most. Glanceable is perfect while you're in the room. The thread's whole pain is the thirty minutes you weren't.

That's the only real difference between your aquarium and what I'm building, honestly, Pushary is the amber light that travels, plus the part the aquarium can't carry, which question it's asking and what changed, so you can answer without walking back. Same philosophy, ambient until it isn't, but it reaches your pocket. Genuine question, because you clearly think about this well: does the amber alone get you back fast enough, or do you still lose time walking over to read which question it's stuck on? The "what is it even asking" gap is the thing I can't see how to solve with color, and I'm curious if it bites you too.

@sleekzheng 

Ha, the TikTok-to-panic-switch is the most honest workflow anyone's posted in this whole thread. "I seemed to realize something" is doing a lot of work there, that's your brain's background process quietly pinging you that the agent probably finished twenty minutes ago. You built a notification system out of guilt. It works, it's just powered by vibes and has a 30-minute latency.

The actual problem isn't the TikTok, by the way. Zoning out while the agent works is fine, that's the dream, the agent works so you don't have to hover. The problem is the only thing that pulls you back is a random pang instead of the agent actually telling you it's done or stuck. You're using your own restlessness as the alert, which is both unreliable and a little stressful, you can never fully relax because part of you is on guard duty.

That's the whole pitch, honestly: let the agent ping your phone when it's actually done or needs a yes, so you can scroll with a clear conscience and get pulled back exactly when it matters, not 30 minutes after. Same TikTok, zero guilt, no wasted half-hour. Question for you, since you live this: would a buzz on your phone actually pull you out of TikTok, or would you swipe it away like every other notification? I keep wondering if the agent alert needs to feel different from the noise, or people will just train themselves to ignore it too.

@shakutovbekzat 

You've hit a real wall, but I think it's two different problems wearing the same costume, and separating them is the whole fix.

Problem one is execution context: what the agent needs loaded to do the work right now. That's the one that gets slow and token-hungry as it grows, because every message re-sends the whole pile and you pay for it each turn. Problem two is awareness context: what you need to know about what the agent did, status, what changed, what it's waiting on. People try to solve both with one giant growing context, and that's what's killing you, you're making the agent carry your audit trail in its working memory, so the thing it needs to think and the thing you need to review are competing for the same expensive space.

The move is to stop storing awareness inside the agent's context at all. When the agent finishes a step, it emits a small structured summary, files touched, what changed, what it's blocked on, and that gets written somewhere durable outside the conversation. Then you can prune the execution context aggressively, because the record of what happened doesn't live in the chat anymore, it lives in the log. The agent stays fast and cheap because its context only holds what it needs to act, not the full history of everything it's done. You get the persistent context you want, the agent doesn't pay tokens to carry it.

That externalized summary trail is basically what Pushary is, the per-step handoff lives outside the agent, so awareness persists without bloating the thing that has to stay lean. You're right that you need context maintained locally somewhere, the key word is somewhere, just not inside the agent's working memory where it taxes every reply.

Question back, since you've felt the token pain directly: when context gets large and replies slow down, is it mostly the agent re-reading its own past work, or genuinely needing all of it to make the next decision? Because if it's the former, externalizing the history fixes the cost outright. If the agent truly needs the whole history live to decide well, that's a harder problem and a more interesting one.