Devin.ai: How to Configure and Manage Persistent Developer Workspaces

Only 13.86% of software engineering issues were resolved unassisted by Cognition AI's Devin when it was first benchmarked on the SWE-bench dataset [Cognition AI 2024 Technical Release]. While that initial score established the state of the art for autonomous code generation, the rapid evolution of autonomous systems has shifted the focus from raw generation to integration. The core challenge of modern agentic workflows is not just generating code, but managing the persistent workspace state where files, dependencies, and configurations reside across complex runs.

A Devin workspace is a persistent directory in Devin's VM that hosts code, dependencies, and temporary file configurations necessary for executing software engineering runs. When Devin initializes, it boots into a cloud-hosted Linux virtual machine, typically running an Ubuntu-based environment. This sandbox provides an isolated terminal, a web browser, and a development server. The sandbox environment contains three primary directories: the codebase resides in the /workspace folder, runtime configurations are loaded into the user's home directory under /home, and temporary logs are written to the /tmp folder. While this complete isolation protects the host machine, it introduces friction. A standard cloud session is ephemeral. When a software engineering run finishes, the container is destroyed, and any files or configurations not written to a remote system are lost.

To overcome this, developers must configure workspace environments that persist configurations, code updates, and database states. Ephemeral containerized systems are ideal for running test suites in isolation, but they fail to support the iterative development cycle. When an agent works on a complex application, it must download packages, build local databases, compile assets, and generate logs. If these files are wiped between sessions, the agent must repeat the configuration steps on every invocation, wasting time and API usage credits.

Bridging these sandboxed environments with persistent directories ensures that Devin can pick up exactly where it left off. This requires an understanding of how Devin manages directory access, how to construct blueprint specifications, and how to connect the agent's VM with external storage and persistent directories to avoid losing work.

Setting up a Devin.ai workspace requires connecting the local developer environment to the cloud sandbox. When developers need to start a workspace session, the Devin CLI serves as the primary bridge.

To answer the common question: "How do I set up a Devin.ai workspace?" the process involves initializing the CLI inside your project directory. Navigating to the target folder in the local terminal and executing the initialization command establishes bidirectional synchronization. This command starts an interactive session:

devin

The Devin CLI automatically detects the directory context and replicates the files into the cloud VM. The local files, configurations, and Git branch details are synced. If developers use Devin Desktop, they can further customize the container using Dev Containers. By adding a devcontainer.json file inside the .devcontainer/ folder, developers can specify directory mounts to attach local paths to the container workspace:

{
  "name": "Devin Development Container",
  "image": "mcr.microsoft.com/devcontainers/typescript-node:20",
  "mounts": [
    "source=/Users/username/projects/data,target=/workspace/data,type=bind,consistency=cached"
  ]
}

Beyond Dev Containers, the configuration of the virtual machine environment is managed via a blueprint file located at .devin/blueprint.yaml. Blueprints are declarative configurations that define how the VM should prepare itself. A blueprint configuration file includes instructions for downloading dependencies, configuring environment variables, and establishing database services. Devin's build system splits the build process into two distinct execution blocks:

1. Initialize Section: The initialize commands run once when the snapshot is created. The resulting filesystem changes are cached as a read-only container layer.

2. Maintenance Section: The maintenance commands run every time the workspace starts up, ensuring packages and configurations are up to date.

Here is an example of a workspace blueprint:

version: "1"
name: "NodeJS Backend Project"
image: "ubuntu-22.04"
env:
  NODE_ENV: "development"
  PORT: "8080"
initialize:
  - run: "curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -"
  - run: "sudo apt-get install -y nodejs"
  - run: "npm install"
maintenance:
  - run: "npm prune && npm install"

Once defined, devin.ai builds an environment snapshot. The platform saves this snapshot as a base image, allowing subsequent sessions to start in seconds without re-downloading modules or re-compiling packages.

Many developers struggle to integrate autonomous agents into automated CI/CD pipelines because guides rarely cover CLI directory mounting and webhook integrations, leaving developers guessing on environment setups. Programmatic workspace access is essential for triggering Devin when tests fail or when new issues are created in a tracker.

To address this content gap, developers can use the Organization API to trigger and manage sessions programmatically. Rather than using manual CLI runs, the Devin Workspace API supports programmatic directory access, allowing teams to create, read, and manage workspace files through automated endpoints.

To launch Devin with a custom workspace API configuration, follow this step-by-step process:

Step 1: Generate a Service User token. Navigating to app.devin.ai, opening Settings, and selecting Service Users allows organization admins to create a token with ManageOrgSessions permissions.

Step 2: Note the Organization ID from the URL or settings dashboard.

Step 3: Make an HTTP POST request to the sessions endpoint, passing the authentication token in the Authorization header.

Here is a curl command to programmatically start a session and direct Devin to work on a specific repository:

curl -X POST https://api.devin.ai/v3/organizations/YOUR_ORG_ID/sessions \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Fix the failing integration tests on the main branch",
    "snapshot_id": "snap-982347",
    "git_repo": "github.com/org/repo",
    "git_branch": "main"
  }'

For reactive workflows, webhooks automate Devin sessions based on external events. While Devin offers built-in triggers for GitHub and Linear, custom webhooks allow teams to integrate custom alert platforms or internal databases.

To configure custom webhooks:

Step 1: Open the Devin dashboard, navigate to automations, and create a new Webhook trigger.

Step 2: Copy the unique HTTPS endpoint URL and the security secret key.

Step 3: Set up the external system to send an HTTP POST request to the webhook URL whenever an event occurs. The JSON payload must remain under the 200 KB limit. Devin parses this payload and uses the content as context inside the new VM workspace session.

Coordinate devin.ai runs inside Fast.io workspaces

Provide your devin.ai runs and developer agents with persistent storage, per-file version history, and automatic semantic indexing. Starts with a 14-day free trial.

Start 14-Day Trial

Developers often ask: "Does Devin AI store files persistently?" The answer is that the cloud VM filesystem is ephemeral. While the blueprint configuration defines the environment setup, any files, logs, or reports generated during a session are deleted when the session ends.

To ensure permanent file storage, Devin relies on Git. Any code changes made by the agent must be committed and pushed to a remote repository. When devin.ai completes a task, it creates a pull request. However, this workflow is only suited for source code. Developers cannot commit database dumps, test logs, audio recordings, or media files to Git without bloating the repository.

For non-code assets, teams often use external storage layers:

1. Object Storage: Writing custom upload scripts to copy files to S3 buckets or cloud buckets. This requires managing API keys and writing upload logic inside Devin's scripts. The AWS keys are configured in Devin's organization-level environment settings to prevent key exposure.

2. Network File Systems: Mounting cloud-based file shares directly into the VM container, though this requires complex network routing and access controls.

3. Intelligent Workspaces: Connecting Devin to a persistent storage platform like Fast.io workspaces. Fast.io provides shared, organization-owned workspaces that act as the single source of truth. Unlike raw object storage, Fast.io includes automatic file indexing, per-file version history, and an append-only audit log.

If multiple agents or developers modify files concurrently, Fast.io tracks every change, allowing teams to restore prior versions or review activity feeds. Fast.io also supports granular permissions, ensuring that sensitive project folders are only accessible by authorized service users or human team members. Fast.io provides these workspace management capabilities directly without claiming compliance certifications.

To build a functional collaborative environment, teams can pair Devin AI with Fast.io. Fast.io operates as an intelligent workspace rather than basic storage, acting as a shared environment where both human developers and AI agents collaborate on documents, code, and project assets.

For agentic access, Fast.io exposes action-based Model Context Protocol (MCP) tooling. Developers can connect Devin to the Fast.io MCP server to read, write, and manage files programmatically. Fast.io provides Streamable HTTP at /mcp and legacy SSE at /sse to connect external agents. The configuration details and tool interfaces are detailed in the Fast.io MCP server guide. Onboarding documentation for autonomous agents is available in the agent onboarding guide.

Once Devin is connected to a Fast.io workspace, several features enhance the workflow:

Intelligence Mode: When files are uploaded to a workspace, Fast.io automatically indexes them for semantic search and retrieval-augmented generation (RAG). Devin can query this intelligent index to find project requirements or code specifications, returning answers with precise citations from the files.

Metadata Views: Instead of relying on manual parsing scripts, developers can use Metadata Views to turn documents into structured databases. By linking to the Metadata Views page, developers can configure schemas that extract fields (like invoice totals, contract dates, or PR review status) from incoming files. Devin can query these views through MCP to read structured document data.

Ownership Transfer: Devin can create workspaces, build project folders, and upload artifacts. Once the task is complete, the agent can initiate an ownership transfer, handing the workspace over to a human manager while retaining administrative access.

Cloud Import: Fast.io allows importing files from Google Drive, OneDrive, Box, and Dropbox via OAuth. This allows agents to pull large files directly into the workspace using URL import without running local input-output operations.

Getting started with Fast.io requires choosing a paid subscription, as the platform does not offer a permanent free plan or free agent tier. The Starter plan is priced on the pricing page as $29/mo, the Business plan at $99/mo, and the Growth plan at $299/mo. Every organization subscription starts with a 14-day free trial, which requires a credit card. Teams can sign up their agents, configure the workspace, and evaluate the platform before the trial expires.