The agent babysitting problem is now a social media operations problem
If you run social for a living, you’ve probably noticed that your job stopped being “write captions and hit publish” somewhere around the time your team started shipping AI-assisted everything. The same shift that gave us CapCut auto-captions and Canva bulk-resize also gave us a fleet of background agents — Claude Code sessions drafting alt-text at scale, Codex runs rewriting a month of LinkedIn hooks, scripts chewing through a year of analytics exports. And the dirty secret of that workflow is that agents don’t fail loudly. They stall silently, waiting on a permission prompt you never saw because you were in another window approving a Reel draft.
That’s the context for Evlat, a free macOS menu-bar-adjacent utility from maker Omer Kala that puts one ring per running agent session on the edge of your screen and turns it amber when a session needs you. It is, on its face, a developer tool. But the operational pattern underneath it — ambient visibility into many parallel background processes — is exactly what social teams are missing as they scale from “one person, one scheduler” to “three people, nine agents, forty accounts.” My take: the interesting thing here isn’t the app. It’s the management model.
What Evlat actually solves, and why “usage limits” tools missed it
Kala’s own framing on the launch page is unusually honest about the gap he was filling: he was running several Claude Code sessions at once and kept missing the ones that were blocked on him, and the tools he found were “mostly about usage limits, not about what each session was actually doing.” That distinction matters more than it sounds.
Most of the AI-ops tooling that’s shipped over the past eighteen months optimizes for the wrong scarce resource. Token dashboards, rate-limit trackers, spend alerts — these all assume the bottleneck is capacity. For a solo creator or a two-person social team, the bottleneck is almost never capacity. It’s attention. When I’ve got five background jobs running — a batch of TikTok caption variants, a YouTube description rewrite, a Pinterest pin-description pass, a competitor scrape, and a Metricool export being cleaned up — the failure mode isn’t that I run out of credits. It’s that job three has been sitting on a confirmation prompt for eleven minutes while I futz with a hook in Threads.
Evlat’s answer is deliberately minimal. Each session gets a ring. Amber means blocked on you. Hover shows every session plus your Claude and Codex limits. One click opens the right tab in iTerm, Warp, Claude Desktop, Metalterm, or Bateri. There’s also an evlat watch command that puts any long-running shell command — builds, tests, training runs — on the bar, and remote servers work over SSH.
That’s the whole product. No dashboards, no analytics, no team seats. Which is either refreshing or insufficient, depending on your stack.
Why TikTok creators should care more than LinkedIn ones
Here’s an operator’s-eye read on who this actually helps. If your content workflow is high-volume and short-cycle — daily TikToks, multiple Reels, a constant churn of Instagram Stories — you’re already running agents in parallel and you already feel the stall problem. A blocked agent for ten minutes is a blocked agent for a tenth of your production day.
If your workflow is low-volume and high-touch — two LinkedIn posts a week, a monthly newsletter — you probably don’t need ambient monitoring, because you’re not running five things at once. You’re running one thing, slowly, on purpose. Evlat won’t hurt you, but it also won’t change your day. The tool’s value scales with your parallelism, and parallelism is a function of how many platforms you publish to and how aggressively you’ve automated the boring parts.
How it works under the hood — and why that matters for trust
The most interesting exchange on the launch page is between Kala and commenter Can Dizdar, who asked the obvious skeptical question: how do you detect that a session is waiting on input with no macOS permissions at all, and how do you plan to keep up when the underlying CLIs change their file formats?
Kala’s answer is the reason I’d actually install this. Evlat doesn’t scrape session files. It uses hooks — Claude Code’s and Codex’s official extension points. Setup adds a small curl command that POSTs each event to a loopback-only local server, which is why no macOS permissions are required: it’s just localhost HTTP. “Waiting” is derived directly from those events — a permission request or a question means the agent is blocked on you. Session files are used only as a supplement for session name and liveness, and are explicitly treated as estimates. If the format changes, a detail goes quiet, but the core signal still rides on the documented hook API.
That’s a meaningfully better architecture than the alternative, and it’s worth understanding why if you’re evaluating any agent-adjacent tool right now. Session-file scraping is fragile: it breaks on every CLI update, and it forces you to grant filesystem permissions that expand your attack surface. Hook-based event streaming is contract-based: the vendor has committed to the event shape, so your integration survives version bumps. For remote servers, Evlat opens an ssh -R reverse tunnel so the server’s hooks report back to your Mac, each machine with its own key.
My take: this is the right way to build a monitoring layer, and it’s the pattern I’d want to see from any tool that wants to sit between me and a cloud service. The tradeoff is that hooks have to exist. Where they don’t, Evlat can’t see anything — which brings us to the limitations.
Where the math breaks
The launch page is refreshingly free of hype, but the comments surface two real gaps.
First, Codex desktop sessions aren’t tracked. Commenter Vilmer Frost reported that Evlat doesn’t track Codex sessions, and Kala confirmed the cause: Evlat tracks Codex through its official hooks, and the Codex desktop app currently doesn’t run hooks at all. The same ~/.codex/hooks.json fires every event from the Codex CLI but nothing from the app, which Kala describes as a known upstream regression linked to an open issue on the OpenAI Codex repo. The practical implication: if your team lives in the Codex desktop app rather than the CLI, Evlat shows you nothing for those sessions today. Kala’s position is that once OpenAI fixes hooks in the app, those sessions should appear with no change on Evlat’s side — which is exactly the payoff of the hook-based design, but it does mean you’re waiting on someone else’s release cycle.
Second, there’s an open request for Antigravity / AGY usage alongside Claude and Codex, and another for an option to include Codex/ChatGPT sessions — both still marked open on the roadmap. The shipped list is mostly quality-of-life: optional alerts when a session has been waiting longer than N minutes, clicking “Go to Session” actually working, approval right from the tab, and support for answering Claude Code AskUserQuestion prompts from the bar. That last one is the quietly important item. If you can answer an agent’s question from the monitoring strip without context-switching into a terminal, the tool stops being a notification layer and starts being a control surface. That’s the direction I’d bet on.
The honest limitations
A few things the launch page doesn’t claim, and you shouldn’t assume:
- It’s macOS-only. The maker calls it “my first desktop app” and describes it as a strip on the edge of your Mac’s screen. No Windows or Linux story is mentioned.
- It’s not a scheduler. Evlat has nothing to do with publishing to social platforms. It doesn’t know what Buffer, Hootsuite, or Later know. It’s a process monitor for agents, full stop.
- It’s free and open source, with no disclosed monetization. Kala says it’s free and the code is on GitHub. Pricing, future tiers, and team features are not disclosed. For a solo operator that’s great; for a team standardizing on it, you’re betting on an early-stage project with no stated business model.
- “Everything stays local” is the maker’s claim. The architecture supports it — loopback-only HTTP, no macOS permissions — but I haven’t audited the code, and you shouldn’t treat a launch-page sentence as a security review.
- It’s not for you if you run one agent at a time. The entire value proposition is ambient awareness across parallel sessions. Serial workflows get nothing from it.
What social teams should steal from this, regardless of whether they install it
The reason I’m writing about a developer utility on a social-media blog is that the underlying pattern is portable, and most content teams are about to need it.
Right now, the average social operation looks like this: a scheduler (Buffer, Later, Metricool, Sprout Social), a design tool (Canva, Figma), a video editor (CapCut, Descript), an analytics layer, and — increasingly — a pile of AI agents doing grunt work in the background. What’s missing is a single ambient surface that tells you which of those background jobs is blocked, which is done, and which has silently died.
You can approximate this today without Evlat:
- Give every background job a heartbeat. If an agent is drafting 30 captions, have it write progress to a shared note or a Slack channel at each milestone. If you don’t hear from it, it’s stuck.
- Separate “needs a human” from “needs time.” Most agent workflows conflate the two. A permission prompt and a long-running render look identical if your only signal is “no output yet.”
- Stop treating usage dashboards as the answer. Knowing you’ve burned 40% of your monthly tokens tells you nothing about whether today’s work is actually moving. Capacity metrics are lagging indicators; blockage metrics are leading ones.
- Prefer hook-based integrations to scrape-based ones when you’re choosing tools. It’s the difference between an integration that survives a vendor update and one that breaks every Tuesday.
The deeper point: as social teams absorb more automation, the operator’s job shifts from doing the work to supervising the work. That’s a different skill, and it needs different interfaces. Evlat is a small, well-built example of what those interfaces look like — one glance, one ring, one color.
What I’d watch / test next
Three concrete things to do this week, in order of effort.
First, audit your actual parallelism. For one working day, write down every background job you kick off — every agent session, every export, every batch render. If the number is consistently above three, you have the problem Evlat solves and you should look at the launch page and decide whether a free, local, hook-based monitor beats your current “alt-tab and hope” strategy. If it’s consistently one or two, skip it and revisit when your volume changes.
Second, test the hook pattern in your own stack. Even if you don’t install Evlat, find out which of your tools expose webhooks or event streams versus which ones only offer a polling API or a file you have to watch. That inventory will tell you which parts of your workflow you can actually monitor reliably and which parts will always be guesswork. It’s the same due diligence you’d do before committing to any scheduling API integration.
Third, watch the Codex desktop hooks issue. If you or your team uses the Codex desktop app, Evlat’s coverage of those sessions depends on an upstream fix in the OpenAI Codex repo. That’s a useful thing to track anyway, because it’s a clean example of how much of your tooling’s reliability lives outside your control. When the fix lands, Evlat should pick it up with no update on its side — and if it does, that’s a real validation of the architecture, not just a changelog line.
The thing I’d most like to see next, and which the roadmap hints at but hasn’t shipped, is answering agent questions directly from the bar. That’s the moment a monitor becomes a cockpit. For social teams running fleets of background agents, the cockpit is the thing worth waiting for.
