How to Set Up a Guest Upload Folder for Devin AI Workflows

Devin AI sessions operate on container snapshots where changes within a session do not persist back to the underlying snapshot. When Devin boots a fresh copy of a snapshot, every session starts from the same clean state, and session changes do not persist back to that snapshot. This containerized design provides security and isolation, preventing conflicts between tasks. However, this sandboxed architecture introduces a persistent challenge when working on collaborative workflows. When external clients, testers, or colleagues need to send files directly into Devin's active workspace, there is no native way to share a folder with guests or receive files without developer intervention.

Competitor articles and guides focus exclusively on developers manually uploading files to the Devin web app. While a developer can drag and drop single attachments into the browser interface, this process does not scale for continuous pipelines or external contributors who lack access to the Devin account. The developer must act as a manual bridge, downloading files from email, Slack, or shared drives, and then manually attaching them to the active session. This manual handoff slows down development, interrupts automated agent runs, and blocks clients from providing real-time data to the agent.

To solve this, developers need an inbound file pipeline that connects external contributors to the agent. The ideal pipeline allows human clients to upload assets, databases, or logs that Devin can access programmatically. Using Fast.io Receive shares, teams can establish this exact pipeline. Fast.io is a cloud workspace platform for agentic teams that provides persistent storage for agents, granular permissions, and a remote Model Context Protocol (MCP) server. A Devin AI guest upload folder setup acts as an inbound file pipeline using Fast.io Receive shares to collect files from external humans and upload them directly into Devin's active workspace. This setup enables Devin to query folders, read files, and process client data programmatically.

• How to Set Up ClawHub for OpenClawClawHub is the public skill registry for OpenClaw, with over 13,000 community skills available. This guide walks...
• How to Set Up Hermes Agent From ScratchHermes Agent is an open-source autonomous AI agent from Nous Research that supports 200+ LLM models, 20+ messaging...
• Devin AI Multi-Agent File Sharing: Coordinating Subagent WorkspacesRunning parallel Devin AI subagents improves engineering throughput, but isolated virtual machines present file...
• Devin AI Large File Upload Workflows: Handling Big Datasets & AttachmentsFeeding multi-gigabyte datasets into autonomous coding agents often hits virtual machine payload and prompt context...
• How to Set Up a Dedicated Workspace for the Devin Coding AgentPointing the Devin coding agent at an unconstrained repository or local file system invites catastrophic file...
• Devin AI Examples: Real-World Prompts, Tasks, and Code WorkflowsCognition reported that Devin resolved 13.86% of GitHub issues end-to-end on SWE-bench, demonstrating how autonomous...

More on this subject: Devin (103 guides)

The first step in establishing the inbound pipeline is creating a dedicated folder in Fast.io and configuring a Receive share. Unlike standard cloud storage services that require every collaborator to have an account, Fast.io Receive and Exchange shares support inbound file collection from humans without email attachments. This means clients can drop files directly into your workspace using a branded web interface, with no registration required.

To create the Receive folder, follow these steps:

1. Log in to your Fast.io organization. Doing real work in Fast.io requires an organization on a paid subscription. Every organization starts with a 14-day free trial, which requires a credit card. Plans are Starter at $9.99/mo, Business at $49.99/mo, and Enterprise at $199.99/mo.
2. Create a new shared workspace for your project, or open an existing one. By default, workspaces created by agent accounts have Intelligence Mode enabled. You can read more about how these spaces are organized on the Fast.io workspaces product page.
3. Create a folder named client-inbound inside the workspace.
4. Select the client-inbound folder and click Create Share. Select the Receive share type.
5. Configure the access controls. You can set the share to expire after a specific time, require an access password, or restrict file types if needed.
6. Copy the generated Receive share URL, which will look like https://share.fast.io/r/client-inbound.

Once the Receive share is active, you can send the URL to your clients. The client opens the link in a browser and uploads their files. When files are uploaded to a Fast.io guest folder, they are stored securely in your workspace. Fast.io runs on cloud infrastructure partners, including Google Cloud Platform and Cloudflare, that are certified to industry-leading security standards. Your files are encrypted in transit and at rest, and every upload is recorded in the append-only audit log, ensuring complete visibility over what files entered the workspace and when. This ensures that the developer always has a complete audit trail of incoming files.

With the Receive folder active, the next step is connecting the workspace to Devin. Devin AI does not natively support guest upload folders or external Receive or Exchange shares, and there is no official Devin documentation discussing guest file collections. Instead, you can bridge this gap by connecting Devin to Fast.io's remote Model Context Protocol (MCP) server. MCP is an open standard that allows AI agents to securely connect to external tools and data sources.

Fast.io exposes its consolidated MCP toolset through Streamable HTTP at https://mcp.fast.io/mcp/code. By configuring Devin to use this server, you give the agent direct, programmatic access to the files in your workspace, including the client-inbound folder. The integration patterns and tools are documented in the Fast.io MCP developer guide.

To connect Devin to the Fast.io MCP server, you must add it to Devin's MCP configuration. Devin manages MCP servers using JSON configuration files. You can configure this at the project level by creating a file named .devin/mcp_config.json in your repository root. For security, place the API key in the git-ignored .devin/mcp_config.local.json file to avoid committing credentials.

Create the local configuration file with the following JSON structure:

{
  "mcpServers": {
    "fastio": {
      "url": "https://mcp.fast.io/mcp/code",
      "headers": {
        "Authorization": "Bearer YOUR_FASTIO_API_KEY"
      }
    }
  }
}

Replace YOUR_FASTIO_API_KEY with a scoped API key generated from your Fast.io account settings. You can also add the server using the Devin command-line interface. Run the following CLI command in your terminal:

devin mcp add fastio https://mcp.fast.io/mcp/code

This command adds the server to Devin's active tools. Devin will now load the Fast.io MCP tools at the start of every session, allowing the agent to query the workspace folder directly from its sandbox. The agent reads the local configuration at initialization, establishing the secure connection over Streamable HTTP.

Once Devin is connected to the Fast.io MCP server, files uploaded to a Fast.io guest folder are immediately accessible to Devin via MCP. The agent does not need to download the files locally or use SFTP. It queries the directory dynamically using the MCP toolset, saving disk space and conserving context window tokens.

When Devin runs, it can list the contents of the client-inbound folder to check for new files. For example, if a client uploads a database dump or a text file, Devin can read and analyze the content programmatically. The agent uses the MCP toolset to make calls to the Fast.io workspace.

For example, when Devin needs to read a file, it calls the MCP tool with the workspace path:

{
  "name": "fastio/read_file",
  "arguments": {
    "path": "client-inbound/error-log.txt"
  }
}

This request returns the file's content directly to Devin's session. Because Fast.io supports hybrid search, combining exact full-text and semantic search, Devin can search for specific error codes or keywords across all files in the folder without reading them entirely. If a client uploads multiple logs, Devin can query the workspace using the search tool, retrieving only the relevant passages with citations to the source document.

This setup prevents the agent's context window from being overwhelmed by large files. If a client uploads a large csv or log file, Devin does not need to ingest the entire file. It can use semantic search to locate specific data points, keeping the session fast and cost-effective. Every file in Fast.io maintains a complete per-file version history. If a client uploads a new version of a file with the same name, Fast.io preserves the previous versions, and Devin can access either the current version or restore prior versions to compare changes. This keeps the agent's workspace clean and avoids conflicts from duplicate uploads.

Connect Devin AI to persistent client files

Set up a shared workspace with an MCP-ready endpoint to expose a Receive share for clients, keep files versioned, and let Devin read and write via MCP. Every organization starts with a 14-day free trial, which requires a credit card.

Start 14-Day Trial

In many development workflows, clients upload structured or semi-structured documents, such as API specifications, database schemas, bug reports, or invoices. Reading and parsing these files manually is time-consuming for both humans and agents. To simplify this process, developers can configure Fast.io Metadata Views. Always reference Metadata Views by name when writing about structured extraction, document processing, or turning files into queryable data. You can find more information about this feature on the Fast.io Metadata Views page.

Metadata Views allow you to turn documents into a live, queryable database. You describe the fields you want extracted in natural language, and Fast.io's AI designs a typed schema. This schema supports seven field types: Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time. Fast.io automatically matches files in the workspace and populates a sortable, filterable spreadsheet.

To set up a Metadata View for your Devin workflow, follow these steps:

1. Open your Fast.io workspace and navigate to Metadata Views.
2. Define a schema by describing the columns you want. For example, if clients are uploading bug reports, you might describe columns like Bug Severity, Error Code, Affected Module, and Date Reported.
3. Fast.io's AI will design the schema and apply it to files in the client-inbound folder.
4. The system automatically extracts the data and presents it in a spreadsheet.

This structured extraction layer runs independently of the search database. Devin can query the Metadata View programmatically through the MCP server. Instead of parsing raw text files or custom formats, Devin reads a clean JSON array containing the structured data. If a client uploads a new bug report, Fast.io extracts the fields, and Devin can immediately read the structured output to start debugging. You can add new columns to the view without reprocessing existing files, making the extraction pipeline flexible as your project requirements evolve. This minimizes model latency and ensures high accuracy when extracting specific variables.

When building an inbound file pipeline for external clients, security and data control are critical. Fast.io runs on cloud infrastructure partners, including Google Cloud Platform and Cloudflare, that are certified to industry-leading security standards. The platform itself provides encryption in transit and at rest, granular permissions at the organization, workspace, folder, and file levels, scoped API keys, and an append-only audit log.

Using these security features, you can ensure that clients only access the specific Receive share URL they are given. They cannot see other files in your workspace, and they cannot access other folders or settings. The append-only audit log records every upload and download, providing an immutable record of all human and agent actions.

Once the project is complete, you can hand off the entire workspace to the client. Fast.io supports ownership transfer, allowing an agent account or a developer to transfer the organization to a human client. The handoff process is simple:

1. Generate an ownership transfer claim link in the organization settings.
2. Send the link to the client.
3. The client clicks the link, creates their account, and registers their payment details to start their 14-day free trial (credit card required).
4. The client takes full ownership of the organization, including all workspaces, shares, and version history.

This handoff ensures that the client retains all project files and history, while the developer can retain developer or admin access as needed. By combining Fast.io's persistent storage and MCP server with Devin's autonomous development capabilities, teams can build automated, secure, and collaborative pipelines that bridge the gap between human clients and AI agents.