# Let's Talk About FOMAT: Fear of Missing Agent Time Michael Richman, Cmd+Ctrl | AI Engineer Europe 2026 | 16:17 Source: https://www.youtube.com/watch?v=W-SX_srBa3Y Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks. Page: https://aietalks.com/talks/lets-talk-about-fomat-fear-of-missing-agent-time Published: 2026-05-24 Tags: agents, computer-use, multi-agent, tool-use ## TL;DR - Coding agents can spend long periods waiting for a user decision, so developers need notifications when an agent is blocked or finished. - Cmd+Ctrl brings Claude Code, Codex, Gemini, Cursor, and other agent sessions into one mobile, web, and watch interface. - A shared control plane and open-source daemon layer let sessions run across local machines and cloud VMs while remaining accessible from one UI. ## Summary Michael Richman defines FOMAT, or fear of missing agent time, as the worry that an agent has stopped for a question while its user is away. He built Cmd+Ctrl to let developers monitor sessions, receive push notifications, answer prompts, and start new sessions from a phone, watch, or web browser. The demo shows a Claude Code session staying synchronized between a terminal and an iPhone, including replies sent from the phone and resumed in the terminal. Cmd+Ctrl groups sessions by notification status, personal attention, and recency, and its overview dashboard creates stand-up summaries from recent messages. Its architecture uses a daemon beside each coding agent and a shared control plane that can aggregate sessions from developer machines and cloud VMs. Richman also describes a new form of flow based on coordinating several agents while preserving time away from them. ## Key ideas ### Agent work creates idle time that users cannot predict [00:40](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=40s) FOMAT is the experience of leaving a coding agent running and discovering that it stopped after two minutes to ask a question. Richman describes the agent as blocked for the entire time its user was away. Current coding tasks may last from five to 45 minutes, but he expects agent tasks to run for five hours or even five days. At that point, checking back occasionally is not enough. The user needs to know when the agent needs input and when it has finished, even when they are away from the development machine. ### Cmd+Ctrl connects many coding agents to one remote interface [02:25](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=145s) Richman built Cmd+Ctrl because he wanted to work with coding agents outside the terminal or IDE. His setup has multiple terminal windows and tabs containing Claude Code, Codex, Gemini, and Cursor sessions. He says he cannot keep track of more than two or three sessions at once. Cmd+Ctrl brings these sessions together on iPhone, Android, the web, and a watch. It lets users monitor and interact with sessions, find out which ones need attention, and launch new sessions when they are away from their development machine. ### Push notifications let users leave an agent running [05:29](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=329s) In the first demo, a Claude Code session appears in both a terminal and the Cmd+Ctrl phone app. Richman subscribes to the session, sends the instruction to sleep for one second and say hello, then leaves the app. Cmd+Ctrl sends a push notification when the agent completes. Opening the notification shows the response, and resuming the session in the terminal shows the same conversation and reply. The intended workflow is to walk away with a phone, respond when needed, and return to the terminal without losing the session state. ### Users can start sessions from a phone and continue them elsewhere [07:29](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=449s) The mobile app can start a new session with a configured agent. Richman selects Claude Code, changes to a testing directory, and sends a simple prompt. The resulting session is available in the app and can also be resumed in the terminal. He says he sometimes sends prompts from bed at the start of the day, then continues them in the CLI or on his phone. The same workflow applies to the configured coding agents, including Codex, GitHub Copilot, and Cursor. ### Session grouping reduces the burden of tracking many agents [09:31](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=571s) Cmd+Ctrl organizes sessions into sections with different levels of attention. Subscribed sessions can send push notifications. The on-my-radar section contains sessions Richman wants to watch without receiving a notification for every message. Recent sessions cover the last 24 hours, followed by the remaining sessions. He shows an account with thousands of sessions and says the organization makes them possible to review. An overview dashboard also creates a stand-up summary of recent sessions from their last several messages. ### A daemon and control plane unify agents across machines [11:29](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=689s) Each supported agent platform has a Cmd+Ctrl daemon running alongside it. The daemon monitors the agent lifecycle and reports changes such as a blocked session or a request for help to a control plane. The user interface communicates with that API layer and sends notifications. The control plane aggregates agents regardless of their framework or location. Richman describes using Claude Code on a Mac and Codex CLI in a cloud VM, with both available through one interface. The daemon layer is open source, so developers can connect other agent frameworks to the same UI. ### Agent autonomy still depends on access to the user [12:58](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=778s) Richman says coding agents are not yet maximally autonomous, especially when users can interact with them only through their native environments. Cmd+Ctrl addresses the access problem by letting the user reach an agent and letting the agent reach the user from different locations. The system does not remove the need for decisions. It reduces the time an agent spends waiting because the user was not at the terminal. ### The new developer flow is coordinating agents while protecting breaks [13:46](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=826s) Richman contrasts the traditional idea of flow, where one person stays deeply focused on one coding problem, with agent choreography. In this model, multiple agents work in parallel while the developer unblocks one and redirects another. He also says that managing many sessions creates high cognitive load and becomes exhausting. Time away from agents matters because people often have their best ideas during breaks. A system that makes agents reachable during those breaks can reduce the fear of missing agent time without requiring the developer to remain at the machine. ## Notable quotes - "You cannot predict when you're going to be needed for input." (01:07) - "I needed a system that is a single pane of glass into all of my agent sessions." (12:12) - "The new type of flow in the agentic world is more about agent choreography." (14:13) - "We need systems that make it possible to reach our agents during those breaks, wherever we might be and whenever that happens." (15:05) ## Tools & references mentioned - Bitly - Cmd+Ctrl - Claude Code - Codex - Gemini - Cursor - GitHub Copilot - Open Code - Anthropic - Matt Pocock - Simon Willison - Lenny's podcast - Agent Craft - Bitly MCP server ## Who should watch - You run several coding-agent sessions and lose track of which ones are blocked, finished, or waiting for a decision. - Your agents run on a terminal, IDE, or cloud VM, and you want to answer prompts without staying at your development machine. - You are designing an agent orchestration layer and want an example based on per-agent daemons, a shared control plane, and session summaries. ## Related talks - [Containing Agent Chaos](https://aietalks.com/talks/containing-agent-chaos) (Solomon Hykes, Dagger, 23:48) - [Develop at Idea Velocity](https://aietalks.com/talks/develop-at-idea-velocity) (Jeffrey Lee-Chan, Snapchat, 15:28) - [Building an ACP-Compatible Agent Live](https://aietalks.com/talks/building-an-acp-compatible-agent-live) (Bennet Fenner, Zed, 18:19) - [Realtime multiplayer, automation, and you!](https://aietalks.com/talks/realtime-multiplayer-automation-and-you) (Idan Gazit, GitHub, 21:41) - [Give Your Agent a Computer](https://aietalks.com/talks/give-your-agent-a-computer) (Nico Albanese, Vercel, 1:08:53)