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

Michael Richman

AI Engineer Europe 2026

[Talk page](https://ai.engineer/talks/W-SX_srBa3Y-lets-talk-about-fomat-fear-missing-agent) · [Video](https://www.youtube.com/watch?v=W-SX_srBa3Y)

## Fear of Missing Agent Time

Coding agents can keep working while you step away, but only until they need you. Cmd+Ctrl connects those interruptions, conversations and sessions across devices.

### An agent working—or waiting?

[0:16](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=16s)

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.

![Slide titled “Fear of Missing Agent Time” describes wanting to start a task while on a walk and an agent stopping after two minutes to ask a question, beside an otter photo.](https://ai.engineer/api/talk-essay-media/988350f8a83d826ede2d938001f5c0d85d125f516c02e7a9d26da2e6410e8fd9)

Fear of Missing Agent Time: an idea while away from the desk, or an agent blocked waiting for input.

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.

### One place for scattered sessions

[2:19](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=139s)

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](https://dev.bitly.com/bitly-mcp/overview/quickstart/). That combination puts the day-to-day effectiveness of development tools directly in his path. He built [Command and Control, or Cmd+Ctrl](https://cmd-ctrl.ai/), because he needed to work with coding agents outside their terminals and IDEs.

![“Who am I?” slide with Michael Richman's portrait and bullets about AI coding tool adoption across 15 engineering teams, the Bitly MCP server, 28 years in technology, and building Cmd+Ctrl.](https://ai.engineer/api/talk-essay-media/a2cfcffdb663df8490bda9997199ce9e70e298133488aad471e2f252b8e5dc6d)

Michael Richman's background and motivation: “Built Cmd+Ctrl because I needed it.”

The surrounding tools were already changing. Richman mentions Anthropic’s [Remote Control](https://code.claude.com/docs/en/remote-control) and [teleportation](https://code.claude.com/docs/en/claude-code-on-the-web), 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?

### Continue a terminal conversation from a phone

[4:49](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=289s)

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](https://www.getagentcraft.com/docs/getting-started), 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.

### Start remotely, then resume locally

[7:19](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=439s)

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:

```bash
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.

![Claude Code terminal showing the prompt “What time is it,” a Bash date command, a returned time and date, and an empty input prompt.](https://ai.engineer/api/talk-essay-media/336e34afce7fbb9c29900cf2fc29d19653235d1f86caf15ab49334750dba1806)

Claude Code displays the resumed “What time is it” conversation and its response.

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.

### Decide what deserves attention

[9:24](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=564s)

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:

| Group | Purpose |
| --- | --- |
| Subscribed | Receive push notifications. |
| On my radar | Keep a session visible without notifications for every message. |
| Recent | Find sessions from the last 24 hours. |
| Remaining sessions | Retain access to the rest of the history. |

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.

### Daemons feed a shared control plane

[11:32](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=692s)

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.

### Flow becomes agent choreography

[13:06](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=786s)

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.

![Slide contrasts the old flow, “Hyper focus on one task,” with the new flow, “Agent choreography,” beside a photograph of otters moving together.](https://ai.engineer/api/talk-essay-media/885ea999c0983352e768cd45e465192c610ad993ca5371900f53c959ba0ca606)

From “Hyper focus on one task” to “Agent choreography.”

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](https://simonwillison.net/2026/Apr/2/lennys-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.

## Resources

- [Cmd+Ctrl](https://cmd-ctrl.ai/) — Manage coding-agent sessions from mobile or web, receive notifications and continue conversations across devices.
- [What Is Cmd+Ctrl?](https://docs.cmd-ctrl.ai/blog/what-is-cmd-ctrl) — Michael Richman explains the workflow problem, agent choreography and the daemon-to-server architecture behind Cmd+Ctrl.
- [Cmd+Ctrl setup documentation](https://docs.cmd-ctrl.ai/) — Installation guidance for connecting supported coding agents to the Cmd+Ctrl mobile and web interfaces.
- [Bitly MCP Server quickstart](https://dev.bitly.com/bitly-mcp/overview/quickstart/) — Configure an AI client to use Bitly’s hosted MCP server.
- [AgentCraft installation and setup](https://www.getagentcraft.com/docs/getting-started) — Set up a real-time-strategy interface for spawning and monitoring coding agents as heroes.
- [Simon Willison’s Lenny’s Podcast highlights](https://simonwillison.net/2026/Apr/2/lennys-podcast/) — Willison’s notes and links for the interview, including parallel-agent exhaustion, phone-based coding and changing development workflows.
- [Claude Code Remote Control](https://code.claude.com/docs/en/remote-control) — Current guidance for continuing locally running Claude Code sessions from a phone or browser.
- [Claude Code cloud sessions and teleport](https://code.claude.com/docs/en/claude-code-on-the-web) — Current documentation for cloud execution and moving a cloud session’s branch and conversation into the terminal.

## Slides

### AI Engineer Europe

The AI Engineer Europe logo opens the recording.

[0:00](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=0s) [AI Engineer Europe logo on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/9bc84484548f4eb9f7b88a04e506953a7c2c2aed6778462cad0a5dc88fb1c4ab.webp)

AI Engineer
EUROPE

### Presenting Sponsor

Google DeepMind is the presenting sponsor.

[0:05](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=5s) [Google DeepMind presenting sponsor card.](https://assets.ai.engineer/sites/aiecode2025/sha256/7eab358dd46d1a3998b4a1f691d24334ce614d7adcc88aa2b2aa7f50a95bf70a.webp)

PRESENTING SPONSOR
Google DeepMind

### Platinum Sponsors

[0:10](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=10s) [Platinum sponsors Braintrust, WorkOS, and OpenAI.](https://assets.ai.engineer/sites/aiecode2025/sha256/cdf1a29d3e146ae1c56cb9547e8d27dd1d127a77ca89f3b2d3859a0436391e6e.webp)

PLATINUM SPONSORS

Braintrust
WorkOS
OpenAI

### Let's Talk about FOMAT

Michael Richman introduces FOMAT, or fear of missing agent time, as a counterpart to FOMO.

[0:17](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=17s) [Michael Richman's title slide introduces FOMAT: Fear of Missing Agent Time.](https://assets.ai.engineer/sites/aiecode2025/sha256/936c09615daf0058b22c5db2fccd9f4768304d6611766c42832ecee0a00cbed2.webp)

>Cmd+Ctrl

Let's Talk about FOMAT
Fear of Missing Agent Time

Michael Richman • Cmd+Ctrl • cmd-ctrl.ai

AI Engineer Europe
Apr 10, 2026

AI Engineer Europe
Presented by Google DeepMind

### Fear of Missing Agent Time

Richman calls it FOMAT when an idea strikes away from your dev machine, or an agent stops early to ask a question and waits while you’re gone.

[0:36](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=36s) [Slide describes wanting to start an agent task while away and an agent waiting for an answer; an otter peeks around a wall.](https://assets.ai.engineer/sites/aiecode2025/sha256/9ae3348a5a40c60f4000183a5f973f65836e212c3df0a3d6a700da605549fef0.webp)

Fear of Missing Agent Time

>Cmd+Ctrl

You’re out on a walk and you realize what task you want your agent to start working on - and you want to do it now.

Your agent stopped 2 minutes into a task to ask you a question. But you’re gone.

AI Engineer EUROPE
PRESENTED BY Google DeepMind
AI Engineer EUROPE
Braintrust
WorkOS
OpenAI

### The Window Is Growing

As coding tasks grow from 5–45 minutes to potentially five hours or five days, checking back becomes harder. An agent waiting for input can lose more time.

[1:12](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=72s) [Slide compares agent task windows of 5–45 minutes today, 5 minutes–5 hours soon, and 5 minutes–5 days eventually, beside an otter looking out a window.](https://assets.ai.engineer/sites/aiecode2025/sha256/271ffd92dd1fb8fb4a7a6369152d25cfe7b08b77fff6c45af7ca16c6deec0840.webp)

The Window Is Growing

>Cmd+Ctrl

Today: 5 minutes - 45 minutes
Soon: 5 minutes - 5 hours
Eventually: 5 minutes - 5 days

You can’t just “check back in a bit.”

Interface text:
AI Engineer EUROPE
Engineering the future of AI

[1:38](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=98s) [Task durations grow from 5–45 minutes today to 5 minutes–5 hours soon and eventually 5 minutes–5 days, alongside an otter looking out a window.](https://assets.ai.engineer/sites/aiecode2025/sha256/170c799de57c4eca0d436ff7b61a0daf4c8f9506f985adc1c1f4c86a3382cd56.webp)

The Window Is Growing

>Cmd+Ctrl

Today: 5 minutes - 45 minutes
Soon: 5 minutes - 5 hours
Eventually: 5 minutes - 5 days

You can’t just “check back in a bit.”

Interface text:
AI Engineer EUROPE
Braintrust
WorkOS
OpenAI

### Fear of Missing Agent Time

You may want to start a task while away, or miss agent time when it stops with a question. Richman says users need to know when an agent needs them or finishes, wherever they are.

[2:09](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=129s) [Two scenarios describe wanting to start an agent task while away and an agent stopping to ask a question while its user is gone; an otter peeks around a wall.](https://assets.ai.engineer/sites/aiecode2025/sha256/b5ae1d686cba89dbe10c8424a40363ab1103b3620d330df045363b3954f6a3c7.webp)

Cmd+Ctrl

Fear of Missing Agent Time

You’re out on a walk and you realize what task you want your agent to start working on - and you want to do it now.

Your agent stopped 2 minutes into a task to ask you a question. But you’re gone.

Interface text:
AI Engineer EUROPE
PRESENTED BY Google DeepMind
Engineering the future of AI

### Who am I?

Michael Richman leads engineering teams at Bitly and co-leads its AI coding tools strategy. He co-wrote the Bitly MCP server and built Cmd+Ctrl to work with coding agents outside the terminal or IDE.

[2:19](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=139s) [Michael Richman's biography lists engineering leadership, AI coding tool adoption, the Bitly MCP server, 28 years in technology, and building Cmd+Ctrl, beside his portrait.](https://assets.ai.engineer/sites/aiecode2025/sha256/5e55fade922c27acb5737869bc68946eef91a997af28d14d6df7a62830021d16.webp)

Who am I?

>Cmd+Ctrl

Michael Richman • VP Engineering, Founder

> Currently lead AI coding tool adoption across 15 Eng teams
> Wrote the Bitly MCP server
> 28 years in technology
> Built Cmd+Ctrl because I needed it

Interface text:
AI Engineer EUROPE
PRESENTED BY Google DeepMind
Google DeepMind

[2:41](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=161s) [Michael Richman's biography lists his engineering leadership, work on the Bitly MCP server, 28 years in technology, and creation of Cmd+Ctrl.](https://assets.ai.engineer/sites/aiecode2025/sha256/8fe9498b71a47215c798017c146247f5cf727266f33451856f9fa0038b1ce66b.webp)

Who am I?

>Cmd+Ctrl

Michael Richman • VP Engineering, Founder

> Currently lead AI coding tool adoption across 15 Eng teams
> Wrote the Bitly MCP server
> 28 years in technology
> Built Cmd+Ctrl because I needed it

Interface text:
AI Engineer EUROPE
PRESENTED BY Google DeepMind
Braintrust
WorkOS
OpenAI

### Claude Code

Richman shows Claude Code sessions spread across terminal windows and tabs. He says he can track only two or three sessions at a time when agents are at different stages of completion.

[3:50](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=230s) [Several Claude Code terminal sessions arranged around a central label.](https://assets.ai.engineer/sites/aiecode2025/sha256/ba1607a5d09292df975c5471aa52fe1ac7316db01681520c44416ce675591352.webp)

Claude Code

Top left terminal:
API restarted and daemons reconnected. Notice the unwatch spam is already reduced — the individual Sending unwatch_session lines are now Debug level, so only the summary lines show.

Task Output [illegible]
  { platform:iOS, name:iPhone 16 Pro }

  The requested device could not be found because no available devices matched the request.
  … +18 lines (ctrl+o to expand)

The device name includes "MR" — let me retry with the correct name.

Bash(cd /Users/mrwoof/src/cmdctrl/mobile/ios/CmdCtrlApp && xcodebuild -scheme CmdCtrlApp -destination 'platform=iOS,name=iPhone 16 Pro MR' -configuration Debug build…)
  ValidateEmbeddedBinary /Users/mrwoof/Library/Developer/Xcode/DerivedData/[illegible]/Build/Products/Debug-iphoneos/Cmd+Ctrl.app/Watch/Cmd+Ctrl.app (in target 'CmdCtrlApp' from project 'CmdCtrlApp')
  … +14 lines (ctrl+o to expand)
  (timeout 5m)

Build succeeded on your iPhone 16 Pro MR. Both the API restart and the device build are done. You can test it now — the retry logic will kick in on the initial load paths if the server isn't immediately reachable.

Brewed for 2m 0s · 1 shell still running
Background command "Build to physical iPhone 16 Pro" completed (exit code 0)
Already got it — both the API restart and the iPhone build completed successfully. You're good to test.

Top right terminal:
Feature spec: daemons/antigravity/FEATURES.md — documents supported/unsupported features, data formats, CDP details, risks

Daemon files created:
- package.json / tsconfig.json — scaffold with better-sqlite3, protobufjs, daemon SDK deps
- src/config/config.ts — paths to Antigravity's state.vscdb, ~/.gemini/antigravity/conversations/, CDP port 9224
- src/adapter/antigravity-db.ts — reads conversation index from SQLite (protobuf in ItemTable), reads .pb files for message history
- src/adapter/conversation-reader.ts — raw protobuf parser for .pb conversation files
- src/adapter/cdp-client.ts — CDP client with multiple selector fallbacks for Antigravity's chat input
- src/session-discovery.ts — discovers sessions from the SQLite index
- src/session-watcher.ts — polls for step count / timestamp changes
- src/commands/ — register, unregister, start, status, stop, update (all matching Cursor pattern)
- src/index.ts — CLI entry point

Key design decisions:
- CDP port 9224 (Cursor=9222, VS Code=9223)
- Agent type: antigravity
- Config dir: ~/.cmdctrl-antigravity/
- Hand-rolled protobuf decoder (no .proto schema needed — reverse-engineered field layout)
- Same observation-only fallback pattern as Cursor when CDP unavailable

The protobuf parsing is best-effort based on the reverse-engineered schema. It'll need tuning once we can test against a real Antigravity instance with actual .pb files.

/rename Build antigravity daemon
Session renamed to: Build antigravity daemon

Bottom left terminal:
The code signature is stale — CodeResources is from 00:10 but the binary was rebuilt at [illegible]. Xcode's incremental build broke the signature. Let me do a clean build.

Bash(cd /Users/mrwoof/src/cmdctrl/mobile/ios/CmdCtrlApp && xcodebuild clean -scheme CmdCtrlApp -destination 'platform=iOS Simulator,name=iPhone 17 Pro Max' 2>&1 | ta…)
  CreateBuildOperation
  ** CLEAN SUCCEEDED **

Bash(xcodebuild build -scheme CmdCtrlApp -destination 'platform=iOS Simulator,name=iPhone 17 Pro Max' -configuration Debug 2>&1 | tail -20)
  /usr/bin/codesign --force --sign - --entitlements [illegible]
  … +21 lines (ctrl+o to expand)

Clean build succeeded with proper codesigning. Now install and launch it on the simulator.

Bash(xcrun simctl install [illegible] "/Users/mrwoof/Library/Developer/Xcode/DerivedData/[illegible]/Build/Produ…")
  (No output)
Bash(xcrun simctl launch [illegible] ai.cmd-ctrl.app 2>&1)
  ai.cmd-ctrl.app: 23232
App launched successfully (PID 23232).

Bottom right terminal:
Claude in Chrome[tabs_create]
  Tab created
Claude in Chrome[navigate](localhost) [View Tab]
  Navigation completed
Three tabs open — llms.txt, llms-full.txt, and robots.txt.
Cooked for 1m 6s

good. commit and push

Bash(git diff --stat && git status --short)
  docs/.vitepress/config.mts          | 23 +-
  docs/installation/cursor-ide.md     |  4 +-
  docs/installation/vscode-copilot.md |  4 +-
  … +10 lines (ctrl+o to expand)

Bash(git add docs/.vitepress/config.mts docs/installation/cursor-ide.md docs/installation/vscode-copilot.md docs/package-lock.json docs/package.json docs/public/robo…)
  [main 9301816] Add AI discoverability: llms.txt plugin, sitemap, OG tags, robots.txt
  6 files changed, 1299 insertions(+), 32 deletions(-)
  create mode 100644 docs/public/robots.txt
Bash(git push)
  To github.com:mrwoof/cmdctrl.git

Interface text:
iTerm2  Shell  Edit  View  Session  Scripts  Profiles  Window  Help
Sun Mar 22  6:47:31 PM
Default
Ready (cmdctrl)
1 shell · ↓ to manage
Build antigravity daemon

### The Problem

With several agent sessions running, the speaker struggles to tell which need attention or have finished. Starting a session away from his development machine is another problem he built Cmd+Ctrl to address.

[4:09](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=249s) [Questions about monitoring and starting coding agent sessions, alongside a photo of otters.](https://assets.ai.engineer/sites/aiecode2025/sha256/89738bb8350c80f73110d7c072072b7a4be64da6df5c2f9427b343b02891e02e.webp)

The Problem

How do you know when it's stuck?

How do you know when it's done?

What if you want to start a new session and you're not at your dev machine?

How do you track all of them at once?

This is why I built Cmd+Ctrl.

>Cmd+Ctrl

### Demo

Cmd+Ctrl’s iPhone view groups agent sessions into notifications, a radar list and recent activity. The speaker says users can monitor, interact with and launch sessions from a phone, web browser or watch.

[4:47](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=287s) [A phone displays notification, watchlist, and recent session groups beside an otter photo.](https://assets.ai.engineer/sites/aiecode2025/sha256/6e2592d86179a627956e45eca5bdf373742656cb9ecb47f87fe76ea2c40065da.webp)

>Cmd+Ctrl

Demo

Notifications 1
Claude channels
Claude Code · cmdctrl
56 min, 20 sec
Michaels-2026-MacBook-Pro.local

On My Radar 2
Convert and prepare video for website
Claude Code · cmdctrl
4 days, 14 hr
Michaels-2026-MacBook-Pro.local

Fix watch grace period in daemon_hub.go
Claude Code · cmdctrl
4 days, 19 hr
Michaels-2026-MacBook-Pro.local

Recent 18
Add devices and sessions to admin page
Claude Code · cmdctrl
23 hr, 32 min
Michaels-2026-MacBook-Pro.local

Update system architecture diagram
Claude Code · cmdctrl
1 day, 1 hr
Michaels-2026-MacBook-Pro.local

Update pricing page
Claude Code · cmdctrl
2 days, 19 hr
Michaels-2026-MacBook-Pro.local

List next features by priority
Claude Code · cmdctrl
4 days, 15 hr
Michaels-2026-MacBook-Pro.local

Summarize contents of docs/public dir

Interface text:
3:18
>Cmd+Ctrl

### Session Handoff

The presenter starts Claude Code and asks what is in the docs directory, setting up a Command and Control session demo.

[5:35](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=335s) [A Claude Code terminal is processing a request to list a documentation directory.](https://assets.ai.engineer/sites/aiecode2025/sha256/0f86055d7b9e4b6f58e261ee6e8b3f99c12484a0193b205ce5ed22dea306295c.webp)

Session Handoff

(fab_venv) local:~/src/cmdctrl main % claude
Claude Code v2.1.91
Opus 4.6 (1M context) · Claude Max
~/src/cmdctrl

what is in the docs dir?

Listing 1 directory… (ctrl+o to expand)
  $ ls /Users/mrwoof/src/cmdctrl/docs/

✻ Philosophising…

-- INSERT --                                      /buddy

Cmd+Ctrl

Interface text:
iTerm2  Shell  Edit  View  Session  Scripts  Profiles  Window  Help
⌘1  ⌘2
Thu Apr 2 11:10:25 PM

### Resumed terminal session

The presenter resumes Claude Code in the terminal, where the one-second sleep request and the agent’s “Hello!” response are visible.

[6:58](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=418s) [A terminal shows a resumed coding-agent session and its hello response.](https://assets.ai.engineer/sites/aiecode2025/sha256/69aab4afe120cde8cec89c511e034ca0952d83c9bf348fd7b5cb4554ebd54ac4.webp)

Session Handoff

- reference/ — Reference docs:
  - api.md, changelog.md, daemon-commands.md, faq.md, mcp-server.md, troubleshooting.md, using-the-app.md
- public/ — Static assets

Resume this session with:
claude --resume 1f48a7bd-f985-49e1-93f3-31627f49499c

(fab_venv) local:~/src/cmdctrl main % claude -c
Claude Code v2.1.91
Opus 4.6 (1M context) · Claude Max
~/src/cmdctrl

what is in the docs dir?

Searched for 1 pattern, listed 1 directory (ctrl+o to expand)

The docs/ directory is a VitePress documentation site (published at cmd-ctrl.ai). Here's the structure (excluding node_modules and .vitepress/dist):

- index.md — Landing page
- building-a-daemon.md — Guide for building a daemon
- daemon-protocol.md — Daemon protocol spec
- blog/ — Blog posts (index.md, what-is-cmd-ctrl.md)
- installation/ — Per-agent install guides:
  - aider, claude-code, codex-cli, copilot-cli, cursor-cli, cursor-ide, gemini-cli, opencode, vscode-copilot
- reference/ — Reference docs:
  - api.md, changelog.md, daemon-commands.md, faq.md, mcp-server.md, troubleshooting.md, using-the-app.md
- public/ — Static assets

Sleep for 1 second and say hello

Bash(sleep 1)
  (No output)

Hello!

Interface text:
iTerm2  Shell  Edit  View  Session  Scripts  Profiles  Window  Help
Thu Apr 2 11:11:45 PM
Claude in Chrome enabled · /chrome
-- INSERT --
/buddy
Cmd+Ctrl

### Session handoff to mobile

The resumed terminal session and phone show the same question and “Hello!” response. The speaker can leave the terminal, receive notifications, and reply from the phone.

[7:06](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=426s) [A phone displays the conversation and response alongside the resumed terminal session.](https://assets.ai.engineer/sites/aiecode2025/sha256/fb91466bb217c77b13b3501499405e84748d86f560fba6e6ba58ffb4f876629f.webp)

Session Handoff

Terminal:
- reference/ — Reference docs:
  - api.md, changelog.md, daemon-commands.md, [illegible], using-the-app.md
- public/ — Static assets

Resume this session with:
claude --resume 1f48a7bd-f985-49e1-93f3-31627f49[illegible]
(fab_venv) local:~/src/cmdctrl main % claude -c
Claude Code v2.1.91
Opus 4.6 (1M context) · Claude Max
~/src/cmdctrl

what is in the docs dir?
Searched for 1 pattern, listed 1 directory [illegible]
The docs/ directory is a VitePress documentati[illegible] Here's the structure (excluding node_modules and .vitepress/dist):
- index.md — Landing page
- building-a-daemon.md — Guide for building a [illegible]
- daemon-protocol.md — Daemon protocol spec
- blog/ — Blog posts (index.md, what-is-cmd-ct[illegible]
- installation/ — Per-agent install guides:
  - aider, claude-code, codex-cli, copilot-cli[illegible], opencode, vscode-copilot
- reference/ — Reference docs:
  - api.md, changelog.md, daemon-commands.md, [illegible], using-the-app.md
- public/ — Static assets

Sleep for 1 second and say hello
Bash(sleep 1)
  (No output)
Hello!

Phone:
List contents of docs dir
Claude Code · Michaels-2026-MacBook... · src/cmdctrl
Beginning of conversation

what is in the docs dir?
11:10 PM

The docs/ directory is a VitePress documentation site (published at cmd-ctrl.ai). Here's the structure (excluding node_modules and .vitepress/dist):
- index.md — Landing page
- building-a-daemon.md — Guide for building a daemon
- daemon-protocol.md — Daemon protocol spec
- blog/ — Blog posts (index.md, what-is-cmd-ctrl.md)
- installation/ — Per-agent install guides:
  - aider, claude-code, codex-cli, copilot-cli, cursor-cli, cursor-ide, gemini-cli, opencode, vscode-copilot
- reference/ — Reference docs:
  - api.md, changelog.md, daemon-commands.md, faq.md, mcp-server.md, troubleshooting.md, using-the-app.md
- public/ — Static assets
11:10 PM

Sleep for 1 second and say hello
11:11 PM
Hello!
11:11 PM
Running: sleep 1
(Bash completed with no output)
Reply...

Interface text:
Cmd+Ctrl
Simulator  File  Edit  Device  I/O  Features  Debug  Window  Help
iPhone 17 Pro Max
iOS 26.1
11:12
Claude in Chrome enabled · /chrome
-- INSERT --
medium · /effort

### Mobile session list

The mobile list groups sessions into Notifications, On My Radar and Recent. The speaker uses On My Radar to watch sessions without a push notification for every message.

[7:18](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=438s) [A mobile session list is organized into notifications, watched sessions, and recent sessions.](https://assets.ai.engineer/sites/aiecode2025/sha256/1b8241473ac4d656f98b2051adb00759595433ccbc726cc8b6ae1b576f1f24ec.webp)

Notifications  3

Explore docs dir
Claude Code · cmdctrl
38 min, 56 sec
Michaels-2026-MacBook-Pro.local

Improve Daemon Message Handling
Claude Code · cmdctrl
2 days, 3 hr
Michaels-2026-MacBook-Pro.local

Claude channels
Claude Code · cmdctrl
4 days, 9 hr
Michaels-2026-MacBook-Pro.local

On My Radar  2

Write tests against the database
Claude Code · cmdctrl
4 hr, 27 min
Michaels-2026-MacBook-Pro.local

Fix daemon watch grace period
Claude Code · cmdctrl
3 days
Michaels-2026-MacBook-Pro.local

Recent  21

Determine next feature to work on
Claude Code · cmdctrl
3 min, 32 sec
Michaels-2026-MacBook-Pro.local

Echo hello back to me
Claude Code · cmdctrl
7 min, 41 sec
Michaels-2026-MacBook-Pro.local

Echo hello back

Interface text:
New Session
>Cmd+Ctrl
(fab_venv) local:~/src/testing %
iPhone 17 Pro Max
iOS 26.1
11:50
>Cmd+Ctrl
Simulator  File  Edit  Device  I/O  Features  Debug  Window  Help
Thu Apr 2 11:50:24 PM

### Start a mobile session

From the mobile interface, the presenter selects Claude Code and a testing directory, then asks for the time. The session runs the date command and returns an answer in the conversation.

[7:45](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=465s) [The new-session form shows an agent, working directory, and a prompt asking for the time.](https://assets.ai.engineer/sites/aiecode2025/sha256/f8aad22548ed469b5a2ee02081edb98476aba99a32f2cc749967887f1ff8afc5.webp)

New Session

New Session

Run On
Claude Code on Mic...6-MacBook-Pro.local
Select the agent and workstation to run this session

Working Directory
/Users/mrwoof/src/testing
Required: Path where the agent will run • Tap ▾ for recent paths

Message
What time is it
Describe the task for the AI agent

Interface text:
Cmd+Ctrl
(fab_venv) local:~/src/testing %
iPhone 17 Pro Max
iOS 26.1
11:50
Simulator  File  Edit  Device  I/O  Features  Debug  Window  Help
Thu Apr 2 11:50:52 PM

[8:09](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=489s) [A phone displays a coding-agent conversation asking for the time.](https://assets.ai.engineer/sites/aiecode2025/sha256/d0d2f3bc783e28b5f25650339aadf4c4f41622685f29a67ccefb14d3bb6a94a3.webp)

New Session

What time is it
Claude Code · src/testing

Beginning of conversation

What time is it
11:50 PM

Running: date
Thu Apr  2 23:50:58 MDT 2026

It's 11:50 PM MDT on Thursday, April 2, 2026.
11:51 PM

Reply...

Interface text:
Cmd+Ctrl
(fab_venv) local:~/src/testing %
iPhone 17 Pro Max
iOS 26.1
11:51
Simulator  File  Edit  Device  I/O  Features  Debug  Window  Help
Thu Apr 2 11:51:04 PM

### Session management: radar and recent

On My Radar keeps selected sessions visible without push notifications for every message. Recent groups sessions from the last 24 hours.

[10:01](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=601s) [A phone lists monitored and recent agent sessions.](https://assets.ai.engineer/sites/aiecode2025/sha256/0ee73a50df13d2ec833639b2eb697b8b976eac3b7330217d9cf6887382b16de9.webp)

Session Management

Notifications 3

On My Radar 2
Write tests against the database
Claude Code · cmdctrl
Michaels-2026-MacBook-Pro.local
4 hr, 34 min

Fix daemon watch grace period
Claude Code · cmdctrl
Michaels-2026-MacBook-Pro.local
3 days

Recent 22
npm release, commit, push, and publish ⚠
Claude Code · cmdctrl
Michaels-2026-MacBook-Pro.local
59 sec

Determine tomorrow's date
Claude Code · testing
Michaels-2026-MacBook-Pro.local
1 min, 28 sec

Determine next feature to work on
Claude Code · cmdctrl
Michaels-2026-MacBook-Pro.local
10 min, 43 sec

Echo hello back to me
Claude Code · cmdctrl
Michaels-2026-MacBook-Pro.local
14 min, 51 sec

Echo hello back
Codex CLI · cmdctrl
16 min, 44 sec

Summarize docs/public directory
Gemini CLI · cmdctrl
20 min, 58 sec

Interface text:
Cmd+Ctrl
iPhone 17 Pro Max
iOS 26.1
11:57
(fab_venv) local:~/src/testing %
Simulator  File  Edit  Device  I/O  Features  Debug  Window  Help
Thu Apr 2 11:57:35 PM

### Session management

The demo groups roughly the last 24 hours of sessions under Recent and the rest under Available, which shows 2,988 sessions.

[10:10](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=610s) [A phone displays an expanded list of recent agent sessions.](https://assets.ai.engineer/sites/aiecode2025/sha256/ffffb361aeaaed654efad8f47eefee0bfe787c22e7713f2c01bf613c30da86aa.webp)

Session Management

Cmd+Ctrl
Notifications 3
On My Radar 2
Recent 22

npm release, commit, push, and publish ⚠
Claude Code · cmdctrl
Michaels-2026-MacBook-Pro.local
1 min, 4 sec

Determine tomorrow's date
Claude Code · testing
Michaels-2026-MacBook-Pro.local
1 min, 33 sec

Determine next feature to work on
Claude Code · cmdctrl
Michaels-2026-MacBook-Pro.local
10 min, 48 sec

Echo hello back to me
Claude Code · cmdctrl
Michaels-2026-MacBook-Pro.local
14 min, 56 sec

Echo hello back
Codex CLI · cmdctrl
16 min, 49 sec

Summarize docs/public directory
Gemini CLI · cmdctrl
Michaels-2026-MacBook-Pro.local
21 min, 3 sec

Say 'resume test 2'
Claude Code · cmdctrl
Michaels-2026-MacBook-Pro.local
22 min, 59 sec

Say 'hello test'
Claude Code · cmdctrl
23 min, 29 sec

Interface text:
Simulator  File  Edit  Device  I/O  Features  Debug  Window  Help
iPhone 17 Pro Max
iOS 26.1
(fab_venv) local:~/src/testing %
11:57
Thu Apr 2 11:57:40 PM

[10:20](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=620s) [The mobile app lists available agent sessions under session management.](https://assets.ai.engineer/sites/aiecode2025/sha256/9fe06c9a0a942a9bffb835bd8a4af8be72f5b3098bc7be6e1aadf8a133ae4e59.webp)

Session Management

Cmd+Ctrl
Notifications 3
On My Radar 2
Recent 22
Available 2,988

Add devices and sessions to admin page
Claude Code · cmdctrl
Michaels-2026-MacBook-Pro.local
5 days, 8 hr

Update pricing page
Claude Code · cmdctrl
Michaels-2026-MacBook-Pro.local
7 days, 4 hr

Convert and prepare video for website
Claude Code · cmdctrl
Michaels-2026-MacBook-Pro.local
8 days, 22 hr

List next features by priority
Claude Code · cmdctrl
Michaels-2026-MacBook-Pro.local
8 days, 23 hr

Summarize contents of docs/public and internal-doc...
Claude Code · cmdctrl
Michaels-2026-MacBook-Pro.local
8 days, 23 hr

Summarize docs/public dir
Codex CLI · cmdctrl
Michaels-2026-MacBook-Pro.local
8 days, 23 hr

Summarize docs/public-docs dir
Gemini CLI · cmdctrl
Michaels-2026-MacBook-Pro.local
8 days, 23 hr

Interface text:
Simulator  File  Edit  Device  I/O  Features  Debug  Window  Help
iPhone 17 Pro Max
iOS 26.1
(fab_venv) local:~/src/testing %
11:57
Thu Apr 2 11:57:48 PM

### Overview dashboard

The overview dashboard gives a stand-up-style summary of recent agent sessions, using their last several messages, with a recent activity list below.

[10:42](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=642s) [The mobile dashboard shows a summary of recent agent activity and a recent activity list.](https://assets.ai.engineer/sites/aiecode2025/sha256/b2ea14e51afbba39ab6e5db308389accad31cbd191ccdff62083fd8a75615323.webp)

Session Management

Cmd+Ctrl
20
IDLE

Bring Me Up to Speed    Refresh

Here's a summary of agent activity, with a focus on recent task completions.

• npm release, commit, push, and publish (cmdctrl)
  Published new version, committed, and pushed the changes.
• Determine tomorrow's date (testing)
  Successfully provided tomorrow's date.
• Determine next feature to work on (cmdctrl)
  Listing launch blockers and indicating nothing is currently in progress.
• Echo hello back to me (cmdctrl)
  Echoed hello back to the user.
• Echo hello back (cmdctrl)
  Echoed 'hello' back to the user.
• Summarize docs/public directory (cmdctrl)
  Summarized contents of the docs/public directory and updated to the new version.

Recent Activity

npm release, commit, push, and publish The agent has published a new version, committed, and pushed the changes.
CLAUDE CODE  src/cmdctrl · 1m ago

Determine tomorrow's date The agent successfully provided the date for tomorrow.
CLAUDE CODE  src/testing · 1m ago

Determine next feature to work on The agent is listing [cut off]

Interface text:
Simulator  File  Edit  Device  I/O  Features  Debug  Window  Help
Thu Apr 2 11:58:15 PM
(fab_venv) local:~/src/testing %
iPhone 17 Pro Max
iOS 26.1
11:58
Cmd+Ctrl

### How It Works

A daemon monitors each agent and reports state to a control plane, which aggregates sessions for the phone, watch, and web interfaces.

[11:30](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=690s) [A diagram connects coding agents to a daemon, control plane, and interfaces for mobile, watch, and web.](https://assets.ai.engineer/sites/aiecode2025/sha256/0a9b27c92286d90d6151ac7734e73af0b816ead2c555c9b498dab418029c5761.webp)

How It Works

>Cmd+Ctrl

Agent
Claude Code
Cursor
Codex
Gemini CLI

↓

Daemon
Monitors lifecycle
Reports state

→

Control Plane
Aggregates all agent sessions

→

UI
iPhone
Android
Watch
Web

### From hyperfocus to agent choreography

The speaker describes a shift from focusing on one coding task to coordinating multiple agents, illustrated by otters moving together.

[13:35](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=815s) [The old flow is hyperfocus on one task; the new flow is agent choreography, illustrated by otters.](https://assets.ai.engineer/sites/aiecode2025/sha256/5840d3742ef0b6563b937ed7b43c49891394fd998b6ccc9f4b95c890f740880e.webp)

>Cmd+Ctrl

The old Flow:
Hyper focus on one task.

The new Flow:
Agent choreography.

Event branding:
AI Engineer EUROPE
[illegible]RESENTED BY
[illegible]ogle DeepMind
Braintrust
WorkOS
OpenAI

## Full transcript

[0:00](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=0s) [upbeat music] Thank you, everybody.

[0:16](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=16s) My name is Michael Richman. [lips smack] Um, I lead several teams at Bitly, the link shortener, but today I'm here to talk to you about FOMAT, uh, fear of missing agent time.

[0:29](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=29s) You know FOMO, fear of missing out. You also know FOMAT, you just didn't have a name for it.

[0:35](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=35s) Um, what is fear of missing agent time?

[0:40](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=40s) It's being out on a walk and having an idea that you want to task your agent with, [lips smack]

[0:48](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=48s) and having to wait to get back to your dev machine to actually do it.

[0:52](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=52s) It is when you get up from your desk and you had an agent working 30 minutes ago, chugging away, and you get back and you realize that after two minutes it actually stopped to ask you a question, and it's been waiting there blocked the entire time. [lips smack]

[1:15](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=75s) We all wanna believe that our agents are low touch-- or sorry, are low touch and high autonomy. But we all know the truth, right? It's back and forth, it's babysitting, and you cannot predict when you're going to be needed for input.

[1:36](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=96s) Right now, a coding task might typically take anywhere between five minutes or 45 minutes, and you kind of know when to check back.

[1:45](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=105s) There isn't that much time that's spent in agent idleness. [lips smack]

[1:50](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=110s) But that window is only gonna get longer, and the longer the agent waits for you, the more agent time that you have missed. If a task is running for five hours or eventually five days, you can't just check back in a bit.

[2:05](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=125s) You need to know when it needs you and you need to know when it's done, and that might be whenever you are, wherever you are. It might be whenever.

[2:15](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=135s) You can't predict it. You may not be at your dev machine.

[2:19](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=139s) Did I go back? I went back. Sorry. So like once I s- once I... Once again, my name is Michael Richman. I run several engineering teams at Bitly. I also co-lead our AI coding tools strategy.

[2:31](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=151s) Um, I'm a really hands-on engineering leader. I run teams and I also write code.

[2:37](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=157s) I co-wrote the Bitly MCP server, and I train our engineers on AI skills and best practices. I think about tools a lot, the tools that we use every day, how they work, whether they are effective for our workflows or not.

[2:57](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=177s) And agentic coding has really changed the world of software in the last year, and the road is very much being paved as we are driving on it. So I built a system called Command and Control in order to help me work with coding agents outside of the terminal or the IDE, because I really needed it and nothing

[3:19](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=199s) existed to solve it yet. Anthropic recently released some ways to address this with remote control and, uh, the teleportation mechanism, and I think it was just two days ago Cursor came out with a solution in the space. [lips smack]

[3:34](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=214s) So I wrote Command and Control. One of the things that is nice about Command and Control, and I'll show you it in a minute, is it is a way to get all of your coding agents in one place, uh, on your mobile device or really anywhere.

[3:47](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=227s) So this is what my setup looks like. I have multiple terminal windows. Each of these windows has multiple tabs. Here's Claude Code. Here's what Codex would look like here.

[3:57](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=237s) Here's Gemini. Here's the Cursor IDE. And at any given moment, I might have multiple sessions running multiple agents across all of these in various states of completion. And here's the thing, I don't know about you, but I cannot keep track of more than two or three sessions at a time.

[4:17](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=257s) As soon as I get to four or five, I don't know what session two is doing anymore. I don't know which one needs my attention, and I have no idea which states of completion things are in.

[4:28](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=268s) So how do you know when an agent is stuck and needs d- a decision from you? How do you know to check in on an agent mid-task, uh, and that, to find out that it's gone off the rails? [lips smack]

[4:41](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=281s) What if you wanna start a new session and you're not at your dev machine? That's exactly why I built this system.

[4:49](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=289s) So this is what it looks like on an iPhone app. It's on Android, it's on the web, and it lets you monitor and interact with agent sessions and launch new sessions from anywhere, from your phone, from the web, even from your watch.

[5:08](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=308s) I have a couple of video demos that I'm gonna play and show you a few of the features of it, and the point here really is like this is a solution to a workflow problem.

[5:18](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=318s) One solution. We saw this morning, uh, what was it called? AgentCraft, which is the gaming version, uh, uh, of something similar, which I thought was awesome. [lips smack] So here's the first demo slide.

[5:28](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=328s) Okay, here I am in the terminal. I'm gonna start a Claude Code session, and I'm gonna issue a command that's pretty run-of-the-mill. I'm not actually exercising Claude Code functionality.

[5:40](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=340s) I just wanna demonstrate Command and Control. So if I come over here to my phone simulator, you'll see that I've got a Command and Control app over here. And what I've got here is my sessions.

[5:54](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=354s) This is all of my sessions grouped by...

[5:57](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=357s) Ones I want notifications for and ones that I wanna keep my eye on and recent ones. And here you'll see the one we just issued here 27 seconds ago.

[6:08](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=368s) Let's get out of this session over here, and what you'll see here is the response I got from the agent is the same one because it is the same session.

[6:17](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=377s) Now, the beauty of Command & Control here is that let's say I wanna subscribe to this particular session for notifications, and I'm gonna issue a, um, response to this one.

[6:29](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=389s) I'm gonna say, "Sleep for one second and say hello." And as soon as I hit this, I'm gonna leave the agents working. I'm-- I left the app 'cause what I wanna demonstrate here is the push notification that I'm gonna get once it actually completes.

[6:48](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=408s) And there it is. So I can click right into that guy, and I got the hello. Now, if I come back over to my session and I resume this guy,

[7:00](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=420s) my response is right there with the agent response as well. The beauty of this is that I don't have to stay in my terminal. I can walk away with my phone, get notified when there are answers, and respond right from there.

[7:19](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=439s) So that's one basic feature of Command & Control, interacting with sessions from anywhere. Let's see another one. This is starting a new session in the mobile app.

[7:31](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=451s) I was gonna do a live demo after I recorded these videos backups, so I was like, "I'm gonna show the videos." So here's the next one.

[7:39](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=459s) I wanna demonstrate another important feature of Command & Control, and that is that I can start a new session right from the Command & Control UI. I can pick any configured agent that I've got here.

[7:52](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=472s) I'm gonna stick with Claude Code, but you see I've got Codex and GitHub Copilot and Cursor here. I'm gonna stick with Claude Code, and I'm gonna switch my directory to a testing directory, and I'm gonna just ask it what time is it.

[8:10](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=490s) Now, the reason I'm showing you a pretty simple prompt, the prompt doesn't matter 'cause the point is that I'm issuing a prompt to my agent, and I'm getting a response.

[8:20](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=500s) Now you can see I'm working late at night here. And the beauty is I can go over here and resume the session, and here's my session right here that I started from Command & Control.

[8:31](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=511s) I can go into it here and pick up where I left off. And if I issue a command here, what is the, hmm, date tomorrow, let's say.

[8:45](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=525s) What I will see over here is the same conversation, and that is the beauty of Command & Control. I often start my day

[8:56](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=536s) with prompts that I issue from bed, honestly, and start up a bunch of sessions and resume them either in the CLI, or I continue them right on my phone.

[9:09](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=549s) I hope you're starting to see the power of Command & Control here. And like I said, this applies to any of the coding agents that I've got configured on my machine.

[9:24](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=564s) Now, to the problem of keeping track of sessions. This third video, and then I'll talk a little bit more about the importance of this, is, uh,

[9:34](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=574s) session management. Now, I mentioned how hard it is to keep track of all the sessions you've got going. I mean, if you just look at the number of sessions I've got here, um, there are a lot.

[9:49](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=589s) And I wanted to revisit the different sections that are available in Command & Control. So, uh, as I mentioned, you can subscribe for push notifications. That's this top section here.

[10:03](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=603s) Uh, the on my radar section is ones that I just want to keep my eye on, but I might not want to have, um, be as chatty as push notifications for every message.

[10:14](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=614s) Uh, and then there's a recent section here, which is basically the last 24 hours, and then the rest. Now, you can see there are thousands of sessions here. I couldn't possibly keep track of them all, but here they all are organized for me.

[10:27](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=627s) Another useful feature in Command & Control is what is referred to as the overview dashboard. One of the really nice features of this one is you can get a kind of stand-up summary of the most recent sessions, and this is just using the last several messages to kind of give you an overview of what's been going on

[10:50](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=650s) for each of those. So I hope you can see the, the power here, and I think this is the kind of thing that we need in our new world of agent orchestration.

[11:03](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=663s) This is a number of things. This is interacting with your agent sessions or starting new sessions from wherever you are. It is session management. It is notifications, so you know when your agent needs you, and you don't have to guess.

[11:21](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=681s) And it's also all of the coding agents that you might be using in one place. It's all those things from wherever you are.

[11:32](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=692s) A little bit about the architecture of this, which you might be curious about. So the-- each agent platform, Claude Code, Cursor, Codex, Gemini, OpenCode, they have a command and control daemon that runs alongside.

[11:44](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=704s) They talk to a control plane layer. They monitor lifecycle of the agent. When things change, it's blocked, it needs your, uh, help, uh, it cont- communicates up to the control plane layer, and then the UI talks back to that API layer and notifies you of things

[12:01](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=721s) The control plane aggregates all of the agents, regardless of where they're running or what framework they're running on. And so this could be your dev machine, this could be a cloud VM, or it could be both.

[12:14](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=734s) And this is an important point that I wanna emphasize. I needed a system that is a single pane of glass into all of my agent sessions, regardless of which platform they're running on, regardless of what machine they are on.

[12:31](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=751s) I might have Claude Code running out of my Mac and Codex CLI running in a cloud VM, and all of the sessions from both of those are available via a single UI.

[12:44](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=764s) And like I said, it's coding tool agnostic. By design, it works with almost all of them. I will also add that the daemon layer is open source, so you could plug it into any of your agent frameworks that you're working on, and then access it through this, uh, the single UI today.

[13:01](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=781s) Uh, so whatever your agent, you can reach it and it can reach you.

[13:06](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=786s) And this brings me to the point of, like, we all want our agents to be maximally autonomous, right? And the honest truth is that they are not yet, as much as we hype it, and especially not if you're limited to how you can interact with them to their native environments.

[13:22](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=802s) This is one solution that addresses that problem. And I wanna talk about a little bit of a broader concept here that this is related to, and that is that r- just in the last year, the agentic coding workflow has completely transformed what software development is.

[13:44](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=824s) It has transformed how we work, and it has also transformed how we enjoy how we work. So you know the old c- the concept of flow, which is like being totally in the zone, locked into your code, hyperfocused on a single thing,

[14:01](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=841s) you and your code solving a problem. And I think that the new type of flow in the agentic world is more about agent choreography, multiple agents working

[14:16](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=856s) in parallel with you moving between them, unblocking one, redirecting another. And the new flow comes from the elegance of that choreography and the results on the other side.

[14:33](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=873s) So then maybe some of that fear of missing agent time can be alleviated. Another thing I really wanna note here is that this paradigm of the always available agent is actually highlighting the value and importance of time away from your agents.

[14:53](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=893s) Matt Pocock alluded to this yesterday. I don't know if you heard the Simon Willison interview on Lenny's podcast last week. The cognitive load of managing multiple agent sessions is really high, and it is exhausting, as you all probably are aware.

[15:12](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=912s) You need a break, and here's the thing. It is in those breaks that we often have our best ideas.

[15:22](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=922s) We need systems that make it possible to reach our agents during those breaks wherever we might be and whenever that happens. And that is how we truly alleviate the fear of missing agent time.

[15:39](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=939s) Once again, my name is Michael Richman. I'd love to hear about your workflows, your hacks, the pain points that you encounter. I invite you to give Command and Control a try if you're interested.

[15:50](https://www.youtube.com/watch?v=W-SX_srBa3Y&t=950s) Here's where to find it online, and here's where to find me on LinkedIn. I'd love to connect and continue the conversation. Thank you. [audience applauds] [upbeat electronic music]
