How to Set Up Devin AI Desktop App with Persistent Workspaces

Two coding agents pointed at the same repository will write conflicting changes and overwrite files without a shared coordination layer. The local editor session needs a mechanism to preserve file states, test logs, and configurations in a persistent cloud workspace that human developers and cloud-based agents can access in real-time. In traditional software engineering setups, code remains trapped on the local hard disk. When developers deploy autonomous AI coding agents, this local isolation creates a disconnect. If the agent runs tests locally but the human team member cannot inspect the logs, or if a cloud agent needs to review a local build output, the workflow breaks down.

This isolation becomes particularly problematic when working with multiple agents running on different machines or within distinct containerized environments. Standard version control systems like Git are excellent for source code, but they are not designed for real-time state sharing of active execution logs, raw dependency configurations, database migrations, or intermediate build files. When developers run agents without a shared filesystem, they must continuously run manual git commands or sync loops. This interrupts the agent's autonomous planning and execution cycle.

Against that backdrop, developers have moved to the Devin AI desktop app, which Cognition announced on June 2, 2026 as the next generation of Windsurf. Devin Desktop shifts the focus of software engineering from simple code writing to active agent fleet management. It features the Agent Command Center as its default primary surface, allowing developers to track pull requests, manage local and cloud agents, and group context using a concept called Spaces. It also integrates support for the Agent Client Protocol (ACP) to run multiple compatible agents in parallel. This protocol makes it possible for teams to configure multiple agents running on separate engines to interact with the same local development folder, coordinating tasks like code generation, local compilation, and QA verification.

However, if the files Devin Desktop operates on are only stored locally, the benefits of fleet management are lost. Teammates cannot collaborate on the active codebase without constant manual git operations. While developers can copy files manually or wire up their own upload scripts, these approaches are not designed for agent operations. Consumer cloud storage drives lack direct agent APIs, and raw object storage like S3 requires writing custom scripts to handle high-frequency file reads and writes. Giving the agent a shared Fastio workspace to write into solves this problem, serving as the neutral substrate where both humans and agents read and write build artifacts, logs, and documentation.

The goal is that anything Devin produces which a teammate or a second agent needs to see lands somewhere both can reach, rather than staying on one laptop. Source code belongs in Git. The artifacts Git is a poor fit for, such as test output, build logs, dependency manifests, exported schemas, and design references, belong in a shared workspace the agent can write to directly.

Use the following procedure to set up Devin Desktop alongside a persistent workspace:

1. Visit the official Cognition portal and complete the Devin AI desktop app download for your operating system.

2. Install and launch the application, signing in to your Devin account to complete the initial setup.

3. Create a dedicated project directory on your local machine, such as ~/Developer/devin-workspace, and open it in Devin Desktop using Open Folder.

4. Create an organization-owned workspace in Fastio for the project, with a folder for the artifacts you want shared.

5. Connect Devin to that workspace over MCP using the configuration in the next section, so the agent can write to it as part of a run rather than as a separate manual step.

With this in place, the agent finishes a coding loop and writes its own output to a location the rest of the team can already see. There is no custom upload script to maintain and no manual file transfer after the run.

Developers connect their local IDE to workspace resources using the Model Context Protocol (MCP). The Devin AI desktop app includes built-in support for the Agent Client Protocol (ACP), which allows running multiple compatible agents in parallel. By integrating an MCP server, these agents can query, read, and write files directly within the persistent workspace. This design enables developers to build custom skills and automate repository-level operations across multiple coding tools.

Fastio exposes a consolidated MCP toolset from a remote server at mcp.fast.io, available over Streamable HTTP with a legacy Server-Sent Events (SSE) transport also supported. You can review the full integration details in the official Fastio Storage for Agents documentation. Because the server is remote, local sessions of Devin Desktop and remote instances of other compatible agents read and write files programmatically against the same central index.

To configure Devin Desktop to connect to the Fastio MCP server, you can edit the user-level or project-level configuration file. The user-level configuration is located at ~/.config/devin/mcp_config.json on macOS and Linux, or %APPDATA%\devin\mcp_config.json on Windows. Open the file and add the Fastio remote server connection detail to the configuration object:

{
  "mcpServers": {
    "fastio-mcp": {
      "url": "https://mcp.fast.io/mcp",
      "env": {
        "FASTIO_API_KEY": "your_api_key_here"
      }
    }
  }
}

Once configured, reload the MCP servers in the Devin editor panel. The local agent or any secondary ACP-compatible agents running in parallel can now read files, search directories, and write outputs directly to the Fastio workspace. This enables the agent to search the codebase using hybrid search, which combines exact full-text matching with semantic meaning-based retrieval. The agent can query documentation and codebase files by meaning, even when the exact words are not present. This capability is highly useful when Devin needs to resolve context across multi-folder workspaces or complex projects.

When a developer agent finishes writing code, running tests, or building a specific feature, the work must be handed off to a human team member for review and deployment. Devin Desktop supports local-to-cloud handoffs, allowing developers to delegate complex tasks to cloud-based agents when they need to step away from the local IDE. This hybrid loop ensures that development progress is not gated by the developer's local availability, as the cloud-based agent can continue running tests and compiling logs in the background.

Fastio supports this handoff with ownership transfer. An agent can create an organization, build out the required workspaces, and then transfer the organization to a human sponsor. The human receives a secure claim link to register their payment details, starting a 14-day trial (credit card required), and takes full ownership of the workspaces. The agent account retains developer access, ensuring continuity while putting billing and admin controls in human hands. Every organization subscription runs on a paid plan: Starter ($29/mo), Business ($99/mo), or Growth ($299/mo).

To prevent concurrent edits from corrupting your project, Fastio provides per-file version history. Unlike simple file stores that overwrite data silently, Fastio tracks every revision. If an agent writes faulty code or saves an invalid configuration, you can view the version history and restore any prior state. An append-only audit log records every read, write, and permission change, providing an immutable record of both agent and human actions, ensuring transparency and ease of auditing.

Teammates can also collaborate in real-time using Collaborative Notes. Fastio Notes supports multiplayer co-editing directly in the workspace. Human developers and AI agents can edit notes simultaneously with visible cursors. You can use this space to draft sprint plans, record agent prompts, or build checklists that the agent updates as it completes tasks, keeping everyone aligned on project requirements.

Give Devin Desktop a workspace its output can live in

Let your coding agent write build logs, test output, and docs straight into a persistent, searchable Fastio workspace. Starts with a 14-day trial.

Start 14-Day Trial

In addition to coding files and documentation, development projects generate structured data like test reports, benchmarking logs, and API schemas. Reviewing these files manually is slow, particularly when dealing with extensive codebases. You can use Fastio Metadata Views to turn documents into a queryable database inside your workspace. This feature extracts structured fields directly from files without requiring you to write custom parser code or maintain complex OCR configurations.

To extract structured data from developer reports or specifications, you describe the fields you want in natural language. Fastio automatically designs a typed schema (supporting Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time fields) and populates a filterable spreadsheet with the matching data from your files. Gemini 2.5 Pro designs these schemas automatically, suggesting columns and field types based on the actual contents of the files in your workspace.

For example, if Devin Desktop writes test log files to your mapped directory, you can create a Metadata View with columns for Test Name, Status, Failure Reason, and Execution Time. The underlying system parses the logs and extracts these fields automatically, without requiring custom parser scripts or OCR rules. Developers and agents can query the spreadsheet, sort columns, and click through to the source log files. Because the MCP server exposes Metadata Views programmatically, your coding agents can query these structured views to check the outcome of a test suite or find which components failed, enabling a tighter development loop. This structured database runs alongside the main RAG search index, ensuring that your agents can access both structured metrics and unstructured documentation in the same workspace environment.