Let Agents Work While You Sit in Meetings

The modern developer schedule is often fragmented by synchronous communication, creating a paradox where deep work is required but rarely supported by the calendar. To reclaim this lost time, you can let agents work while you sit in meetings by shifting from a manual coding approach to an asynchronous oversight model. This transition requires a specific environment where tools can operate independently on your local machine while providing you with a secure window to monitor progress without leaving your call or your seat.

The Cost of Synchronous Context Switching

Every hour spent in a status update or a planning session is an hour where the compiler is idle and the IDE is closed. Traditional developer tools are designed for active, foreground interaction. If you are not typing, the work stops. This linear dependency creates bottlenecks in the development lifecycle, especially when dealing with repetitive tasks like boilerplate generation, unit test writing, or large scale refactoring.

By adopting agentic workflows, you move from being the sole executor to being the orchestrator. The goal is to set a high level objective before a meeting starts, such as "refactor this module to use the new API pattern" or "increase test coverage for the auth service," and allow a specialized agent to handle the implementation details.

Architecting for Background Execution

Not all environments are suited for autonomous work. If an agent requires constant human feedback for every line of code, the benefit disappears. To successfully let agents work while you sit in meetings, your stack should support three core pillars.

Persistent Local Environments

Agents need a stable place to run. Cloud based IDEs are powerful but often operate in ephemeral containers that might timeout or require active browser tabs. A local first approach ensures that the process continues running on your hardware regardless of your network status or browser activity. When an agent is running a long sequence of terminal commands, it must have persistent access to your file system and local shell.

Secure Remote Observation

The primary anxiety when letting an agent work autonomously is the lack of visibility. You need a way to check in on the process from a secondary device, like a phone or tablet, without exposing your local machine to the public internet. This is where a secure relay becomes essential. It allows you to peek at the terminal output or the current state of a code file during a lull in a meeting, ensuring the agent hasn't stalled or hallucinated a destructive command.

Multi Agent Orchestration

Different agents have different strengths. Some excel at architectural logic, while others are better at executing shell commands and fixing linter errors. Running these agents side by side in a unified workspace allows you to delegate specific chunks of a project to the most capable tool.

Integrating Deska into Your Workflow

Deska provides a specialized environment designed for this asynchronous style of development. It is a free desktop app for Mac, Windows and Linux that functions as an infinite canvas workspace. Instead of switching between tabs, you can place terminals, a code editor, and browser panels anywhere on the canvas and zoom out to see the entire operation at once.

Within this canvas, you can run multiple tools like Claude Code, Codex CLI, and OpenCode side by side as panels. This setup is particularly effective for background work. Before your next meeting, you can initiate a task in one terminal panel and monitor the file changes in the Monaco based code editor panel.

If you need to move away from your desk, the Deska mobile app allows you to monitor and continue work from your phone. The connection uses a secure relay where devices pair directly, meaning no ports are exposed on your local machine. You can verify that the agent is still progressing and even issue minor course corrections through the chat interface.

For those who prefer a more conversational control method, Ask Deska acts as a voice and chat assistant. It can drive the workspace by opening panels, running commands, and checking the status of active sessions. This allows for hands free interaction if you are preoccupied with other tasks.

Comparing Agentic Environments

When choosing a platform for autonomous coding, it is helpful to look at how different tools handle persistence and privacy.

Standard cloud IDEs offer great portability but often differ in approach when it comes to long running background tasks, sometimes suspending processes to save resources. Local terminal agents are robust but lack a visual layout for complex multi file tasks. The canvas approach in Deska attempts to bridge this by keeping everything local while providing a high level visual overview.

Practical Steps to Prepare for a Meeting

To maximize the work done while you are unavailable, follow a structured preparation routine:

1. Define the scope: Choose a task that is well defined and verifiable, such as fixing a specific set of bugs or implementing a documented UI component.
2. Initialize agents: Open your terminals and start your preferred agent. Use the coding agents documentation to optimize your startup commands.
3. Set up the view: Position the code editor next to the terminal and the browser panel. Zoom out so all relevant panels are visible.
4. Pair your device: Ensure your mobile app is linked via the secure relay so you can monitor the agent threads remotely.
5. Exit gracefully: Leave the desktop app running. Since Deska is local first, your files and sessions stay on your machine.

Privacy and API Security

A major concern with AI tools is data residency. When you use the BYOK (Bring Your Own Key) model, you maintain control over your API costs and data usage policies. The workspace itself remains free, while the data and storage remain local. This ensures that even while an agent is working in the background, your source code is not being stored on external servers beyond what is required by your chosen AI provider.

FAQ

How to run AI coding agents in background?

To run agents in the background, use a persistent terminal environment that does not terminate when the window loses focus. Tools that provide mobile relays allow you to monitor these background processes without being physically present at your workstation.

Best way to monitor long running dev tasks?

The most effective way is to use a multi panel workspace where terminal output, file changes, and web previews are visible simultaneously. Combining this with a secure mobile link provides the best balance of visibility and mobility.

Are autonomous coding agents safe for production code?

Safety depends on the constraints and the verification process. Always run agents in a local environment where you can review changes before committing them to Git. Using a local first tool ensures you have the final say over any code generated during an asynchronous session.

Getting Started with Background Workflows

Reclaiming your time starts with trust in your tooling. By moving your autonomous tasks to a persistent, local first environment, you turn dead time into productive output. You can explore the various panels available to customize your workspace for specific languages and frameworks.

To start building your own persistent agent workspace, you can download the Deska desktop app for your preferred operating system and begin configuring your first automated session.