Let’s Talk About FOMAT – Fear of Missing Agent Time

You are out on a walk when an idea arrives: something you could hand to a coding agent immediately, if only you were back at your development machine. Or you leave an agent working, return half an hour later, and discover that it stopped almost as soon as you left. Michael Richman, an engineering leader at Bitly, calls this FOMAT: fear of missing agent time. In his example, a 30-minute absence leaves an agent blocked after just two minutes, waiting for an answer.

The difficulty is the unpredictable handoff. An agent may work independently for a while, then need a decision, clarification or permission. You cannot reliably schedule your next visit to the terminal around that request. Richman characterizes coding tasks at the time of the talk as taking five to 45 minutes, with relatively little agent idleness. But he asks what happens as work stretches to five hours or eventually five days. Those longer durations are prospective examples: checking back “in a bit” stops being a workable coordination strategy. You need to know both when an agent needs you and when it is done, wherever you happen to be.

Richman approaches this as a hands-on engineering leader who still writes code. At Bitly, he co-leads the AI coding tools strategy, trains engineers on AI practices and says he co-wrote the Bitly MCP server. That combination puts the day-to-day effectiveness of development tools directly in his path. He built Command and Control, or Cmd+Ctrl, because he needed to work with coding agents outside their terminals and IDEs.

The surrounding tools were already changing. Richman mentions Anthropic’s Remote Control and teleportation, along with a Cursor solution he says had appeared two days earlier. His own requirement is broader than reaching one tool remotely: put all his coding agents in one interface, accessible from a mobile device or elsewhere.

His desktop illustrates why. Multiple terminal windows contain multiple tabs, with Claude Code, Codex and Gemini sessions alongside the Cursor IDE. Different sessions are at different stages of work. Richman says he can track two or three sessions, but at four or five he loses track of what another session is doing and which one needs attention. The missing interface has to answer three practical questions: which agent is waiting for a decision, which needs a mid-task correction, and how can a new session begin when its user is away from the development machine?

Cmd+Ctrl provides an iPhone interface, with Android, web and watch access also described in the talk. It lets users monitor sessions, interact with them and launch new ones. Richman presents it as one response to a workflow problem, pointing to AgentCraft, demonstrated earlier at the conference, as a gaming-style approach to a similar need.

The first demonstration starts with a routine Claude Code prompt in a terminal. Its simplicity is deliberate: the capability under examination is conversation continuity, not code generation. In the phone simulator, Cmd+Ctrl groups sessions by notification subscriptions, sessions being watched and recent activity. The newly issued session appears with an age of 27 seconds. Opening it shows the same agent response as the terminal because it is the same session.

The next interaction tests whether that session can reach its user after the user leaves:

1. Subscribe to the session’s notifications.
2. Send the prompt, “Sleep for one second and say hello.”
3. Leave the app while the agent works.
4. Open the push notification when it arrives and read the hello response.
5. Return to the terminal and resume the session.

The resumed terminal contains both the message sent from the phone and the agent’s response. Changing devices preserves the conversation: the phone is a way to continue the existing work, and the notification removes the need to keep checking its native interface.

The second demonstration reverses the direction: create the session in Cmd+Ctrl, then pick it up in the terminal. Richman uses recorded demonstrations that he had prepared as backups rather than attempting the live version. The new-session interface offers the agents configured on his machine: Claude Code, Codex, GitHub Copilot and Cursor. He selects Claude Code, switches to a testing directory and asks what time it is.

Again, the trivial prompt isolates the handoff. The agent responds, and Richman resumes that mobile-created session in the CLI. The terminal displays the original question, a Bash command to retrieve the time, and the returned time and date. The underlying shell operation is simply:

date

The useful result is that the terminal already has the conversation begun elsewhere; there is no need to restate the task to a fresh agent.

From the terminal, Richman then asks for tomorrow’s date. Cmd+Ctrl shows the same conversation as it continues. He describes starting his day by sending prompts from bed, launching several sessions and later continuing them either in the CLI or on his phone. This workflow applies to the coding agents he has configured on his machine.

Remote access solves only part of the problem. Once many sessions are available in one place, the interface must help the user decide which ones matter now. The third demonstration revisits the session groups:

Richman describes the displayed history as containing thousands of sessions, rather than thousands of simultaneously running agents. These groups separate active attention from historical access: a session can remain easy to find without producing a stream of alerts.

Finding a session still leaves the cost of remembering what happened in it. The overview dashboard addresses that with a stand-up-style summary of recent sessions, using the last several messages from each to describe its activity. Together, the session groups and summaries provide two different aids: where to look, and enough recent context to re-enter the work. The resulting interface combines remote replies, new-session creation, session management and notifications across the coding agents in use.

The architecture separates agent execution from the interface used to supervise it. A Cmd+Ctrl daemon runs alongside each agent platform; Richman names Claude Code, Cursor, Codex, Gemini and OpenCode. The daemon monitors the agent lifecycle and reports changes, including blocked states and requests for help, to a control plane. The UI communicates with that API layer and notifies the user. This is what turns an event inside a development environment into something the user can respond to elsewhere.

The control plane aggregates agents across both platforms and machines. Execution can remain on a development machine, take place in a cloud VM, or span both. Richman’s concrete example is Claude Code running on his Mac while Codex CLI runs in a cloud VM: both sets of sessions appear in the same UI. The shared interface therefore does not depend on moving every agent to one host or adopting one coding tool.

Richman describes the system as coding-tool agnostic, with support for almost all such tools. He also describes the daemon layer as open source and says it can be integrated with other agent frameworks to make their sessions accessible through the existing UI. The integration point is the layer beside the agent; the user-facing benefit is that the agent can reach its user as well as the user reaching the agent.

These mechanisms address a limit that remote interfaces cannot wish away: coding agents still need human involvement. Richman cautions against treating them as maximally autonomous, especially when the human can interact with them only inside their native environments. Cmd+Ctrl is one way to make that involvement less dependent on being at a particular screen.

That changes the experience of development as well as its mechanics. Traditional flow means sustained concentration on one problem: you and your code, deeply focused. Richman describes a new form of flow as agent choreography. Several agents work in parallel while you move between them, unblocking one and redirecting another. The satisfaction comes from coordinating that work elegantly and seeing the results it produces.

There is a human limit to this choreography. Always-available agents make time away more valuable, because managing several sessions carries a high cognitive load and can be exhausting. Richman connects this observation to Matt Pocock’s remarks the previous day and to Simon Willison’s interview on Lenny’s Podcast the previous week. The ability to keep assigning work does not remove the need for a break.

Breaks are also where new ideas often arrive. Being able to send one to an agent when it occurs closes the loop with the opening walk: stepping away need not mean losing the opportunity to start useful work. Richman ends by inviting people to try Cmd+Ctrl and share their own workflows, hacks and pain points, with product and LinkedIn contact information on the closing slide. The practical goal is room to leave the desk, with a way back into the work when an idea—or an agent—needs attention.