Devin AI Local: Running Devin Agents on Your Machine

According to the official Devin Desktop documentation, the Devin Local agent framework achieves up to 30% greater token efficiency than the previous Cascade engine, largely driven by aggressive prompt caching [Devin Desktop Documentation 2026]. This metric highlights a broader shift in autonomous software engineering: the movement of agent runtimes from ephemeral cloud environments directly onto local developer machines.

Devin Local refers to the Devin agent capability within Devin Desktop and the command-line interface (CLI) that executes development tasks directly on a user's local machine rather than a cloud sandbox. In this execution mode, the agent accesses your local files, shell environments, and system tools directly. This shift eliminates the boot delays and API boundaries associated with remote cloud virtual machines.

Running an agent locally gives it immediate access to custom compilers, private packages, and running databases. Developers no longer need to configure SSH keys or sync large repositories to the cloud before starting a task. However, this direct access introduces substantial security risks. A local agent executes terminal commands with your user privileges, meaning a logic loop or an unverified command could modify, corrupt, or delete files on your system. Understanding how to wrap the agent in secure boundaries is the first step in adopting local execution models.

To mitigate these issues, Devin Local relies on a dual-layered protection strategy. First, developers specify permission boundaries using local JSON configurations to block writes to critical folders. Second, Devin Local integrates network filters to restrict outgoing connections, preventing the agent from sending credentials or data to external servers. This setup ensures that you gain the advantages of local execution without exposing your operating system to unverified writes.

Setting up the local execution environment inside Devin Desktop requires modifying your active agent settings. The Devin Desktop interface provides an agent selector that allows you to switch between Devin Cloud and Devin Local. This configuration is necessary to control where the agent executes commands and compiles your project code.

Follow these step-by-step instructions to configure the local agent environment in Devin Desktop:

1. Open Devin Desktop and launch the project directory where you want to execute tasks.

2. Access the Command Palette by pressing Cmd+Shift+P on macOS or Ctrl+Shift+P on Windows and Linux.

3. Type 'Devin: Settings' and select the configuration panel from the list.

4. Locate the agent selector drop-down menu in the bottom-right corner of the interface.

5. Select 'Devin Local' from the options to change the active execution engine from the default cloud sandbox.

6. If the option is missing, check that you have installed the command-line helper by running the install command via the Command Palette: 'Install devin-desktop in PATH'.

Once selected, Devin Local will initialize its runtime. The agent will scan your active workspace directory to build a repository index. This indexing step uses prompt caching to verify that subsequent instructions reuse context without consuming extra tokens. Developers must note that Devin Local operates in a preview mode, which is not supported in JetBrains IDE plugins. Additionally, the local engine does not persist memories between individual sessions, making it necessary to define reusable rules and custom capabilities in external configuration files.

Running an autonomous developer agent on your physical machine requires strict security boundaries. Most online guides overlook the OS-level sandboxing needed for local agent executions, exposing systems to unintended file writes or execution loops. Devin Local addresses this by employing permission scopes and network filters configured via JSON files.

The configuration interface relies on three files:

• User-level settings: Located at ~/.config/devin/config.json (or %APPDATA%\devin\config.json on Windows). This file defines global defaults for all local agent runs.

• Project-level settings: Located at .devin/config.json in your repository root. This file is committed to version control to share safety policies across development teams.

• Local overrides: Located at .devin/config.local.json. This file is gitignored and is used to store local environment overrides or private API keys.

You can configure permissions using 'allow', 'deny', and 'ask' directives for file access, shell execution, and tools. When the agent attempts a command that matches an 'ask' rule, it prompts you for verification. You can pre-approve common safe paths to prevent constant interactive prompts.

Below is an example of a .devin/config.json file configuring local sandboxing limits:

{
  "permissions": {
    "allow": [
      "Read(**)",
      "Exec(git)",
      "Exec(npm run test)"
    ],
    "deny": [
      "Write(~/.ssh/*)",
      "Write(~/.aws/*)",
      "Exec(sudo)"
    ],
    "ask": [
      "Write(*)",
      "Exec(*)"
    ]
  },
  "network": {
    "network_mode": "limited",
    "allowed_domains": [
      "github.com",
      "npmjs.com",
      "api.fast.io"
    ]
  }
}

The network configuration block controls outbound traffic. By setting network_mode to limited, you restrict the agent to standard GET, HEAD, and OPTIONS requests, preventing unauthorized data exfiltration. Specifying an allowlist of domains ensures the agent only contacts trusted API endpoints during execution. This sandbox policy prevents a runaway agent from accessing sensitive credentials or running root-level commands.

When a local task demands high compute power, runs into complex dependency issues, or requires long background execution, you can transfer your local session to the cloud. Devin CLI provides a dedicated handoff protocol for this workflow. The /handoff command uploads your current workspace state to an ephemeral cloud VM, spawning a remote session that runs independently of your local hardware.

The handoff process executes the following steps:

• First, the CLI packages the conversation history and local environment variables.

• Second, the CLI captures your active Git branch and any uncommitted file changes.

• Third, the workspace state is uploaded to Devin's cloud environment, provisioning a new sandboxed virtual machine equipped with a shell and browser.

• Finally, a cloud session is started, returning a tracking URL so you can monitor progress.

To initiate a handoff, run the CLI tool in your terminal. After starting an active session with devin, use the handoff syntax directly in the prompt window:

devin> /handoff compile the project and run the integration test suite

If you execute /handoff without a task description, the cloud agent will automatically continue working from the last active instruction in the conversation history. This transfer allows developers to close their laptop or work on other branches while the cloud VM executes resource-intensive operations in the background.

Once the cloud task completes, you can retrieve the modified files by running devin sync or pulling the changes from your remote branch. This workflow provides a balanced environment: you use local execution for fast editor edits, and hand off to isolated cloud sandboxes for heavy compilation and background testing.

Persist Devin agent files in a collaborative workspace

A shared workspace with an MCP-ready endpoint for your agent's reads and writes, complete with file versioning, Intelligence indexing, and RAG search built in. Starts with a 14-day free trial.

Start 14-Day Trial

While Devin Local handles individual file edits and hands off tasks to ephemeral cloud VMs, teams face a persistence challenge. Ephemeral VMs are deleted once a session ends, and local sandboxes do not share state across team members. For collaborative development, teams need a persistent, organization-owned workspace that acts as the source of truth for both humans and AI agents.

To solve this, developers use cloud storage platforms like S3, Google Drive, or Box to store assets, but these lack agent-native interfaces. Fast.io serves as an intelligent workspace platform designed for agentic teams. Instead of basic storage, Fast.io provides a shared directory where humans use a web interface and agents connect via the Model Context Protocol (MCP) server.

Fast.io exposes its tooling via Streamable HTTP at /mcp and legacy SSE at /sse. Developers can refer to the agent storage page or check the standard onboarding parameters to connect their agents. Once connected, Fast.io provides several key capabilities for local and cloud agents:

• Intelligence Mode: Enabling Intelligence on a workspace automatically indexes files for semantic search. Agents can perform hybrid search, combining exact full-text matches with meaning-based queries, returning passage matches with citations.

• Metadata Views: Turn files into queryable data grids. Users describe desired fields in plain English, and the AI extracts structured schemas (Text, Integer, Decimal, Boolean, URL, JSON, Date & Time) from invoices, PDFs, or notes without manual rules. Learn more at the document data extraction page.

• Collaborative Notes: Real-time co-editing with live cursors for both human developers and agents.

• Ownership Transfer: Agents can build workspaces, configure shares, and transfer ownership to humans via a claim link, retaining administrator access.

Fast.io runs on a paid subscription model: the Starter plan is $29/month, the Business plan is $99/month, and the Growth plan is $299/month. Every organization starts with a 14-day free trial that requires a credit card. Teams can run their local Devin agents against a shared Fast.io workspace, ensuring that every code build, test log, and extracted document remains versioned, searchable, and collaborative.