Managing Files and Output in the Devin AI Tool: Workflows and Best Practices

Web Download UI

For manual, ad-hoc file retrieval, the Devin web interface provides inline file previews. When Devin generates visual files, such as HTML reports, PDF documentation, or SVG images, these files are displayed in the session sidebar. A download button is available in the toolbar of each preview panel. Users can click this button to save individual files to their local disk. While convenient for quick checks, this manual process does not scale for continuous deployment pipelines where hundreds of build artifacts are generated automatically.

Git Repository Integration

The standard method for persisting source code changes is through Git. Devin connects to platforms like GitHub and GitLab. When the agent completes a software task, it commits the changes and opens a pull request. This ensures that the primary codebase remains versioned and secure. However, Git is not suitable for non-code artifacts. Database dumps, compiled binaries, test reports, and large media files will bloat a code repository, making this method impractical for rich media workflows.

Mounting External Storage

For local terminal sessions, developers using the Devin CLI can mount cloud-based storage folders. Since the CLI runs on the host machine, standard utility tools like rclone can mount remote storage directories (such as Amazon S3, Google Drive, or Dropbox) locally. By pointing Devin to the local mount path, the agent reads and writes files directly to cloud storage. This configuration is helpful for devin tool workflows that require large file reads.

Querying Session Attachments

Every file generated or uploaded during a session is tracked as an attachment. The Devin API provides endpoints to manage these assets. First, developers must retrieve a list of attachments associated with a specific session ID. The HTTP request must include an authorization header with a service token, which is generated under Organization Settings in the web interface and starts with a cog_ prefix.

The endpoint to retrieve the list of attachments uses the following URL structure: GET https://api.devin.ai/v3/organizations/{org_id}/sessions/{devin_id}/attachments

This request returns a JSON response containing an array of attachment objects. Each object includes a unique uuid and the file name.

Downloading Attachment Files Programmatically

Once the attachment UUID is known, developers can download the file. The API exposes a download endpoint: GET https://api.devin.ai/v1/attachments/{uuid}/{name}

When this endpoint receives a valid request, it returns a 307 Temporary Redirect status code. The response directs the client to a presigned URL. This presigned URL provides temporary access to the file and expires after 60 seconds. The client must immediately follow the redirect to download the file contents.

Here is a Python script that automates listing and downloading all files in a session:

import os
import requests

def download_all_artifacts(org_id, devin_id, api_token, target_folder):
    headers = {"Authorization": f"Bearer {api_token}"}
    list_url = f"https://api.devin.ai/v3/organizations/{org_id}/sessions/{devin_id}/attachments"
    
    response = requests.get(list_url, headers=headers)
    if response.status_code != 200:
        raise Exception(f"Failed to list attachments: {response.text}")
        
    attachments = response.json().get("attachments", [])
    os.makedirs(target_folder, exist_ok=True)
    
    for item in attachments:
        file_uuid = item["uuid"]
        file_name = item["name"]
        
        # The download API redirects to a presigned storage link
        download_url = f"https://api.devin.ai/v1/attachments/{file_uuid}/{file_name}"
        file_res = requests.get(download_url, headers=headers, allow_redirects=True)
        
        if file_res.status_code == 200:
            output_path = os.path.join(target_folder, file_name)
            with open(output_path, "wb") as f:
                f.write(file_res.content)
            print(f"Downloaded: {file_name}")
        else:
            print(f"Failed to download {file_name}: {file_res.status_code}")

In addition to the attachments API, teams can export entire session conversations and logs. Using the Devin CLI, running the devin command with the --export flag followed by a target file path saves the run history in ATIF format. This is useful for auditing and troubleshooting run failures.

Shared Workspace Organization

Fastio provides organization-owned workspaces where humans and AI agents collaborate on project assets. Instead of managing individual files, teams share structured folders with granular permissions. Fastio maintains a complete per-file version history. When Devin modifies a design layout or a configuration file, Fastio saves the change as a new version. If the agent makes a mistake, developers can restore the previous version instantly. This version control occurs automatically, making concurrent developer and agent activities fully auditable. Fastio tracks this activity in an append-only audit log, which records every file modification, access event, and share link generation.

Structured Extraction with Metadata Views

When Devin outputs test logs, build reports, or database structures, developers must extract key metrics. Fastio features Metadata Views to turn documents into structured databases. By navigating to the Metadata Views page, users can define custom schemas using fields like build success, error count, or deploy date. Fastio automatically processes incoming files, parses the data, and populates a filterable spreadsheet. This structured layer differs from Intelligence Mode, which focuses on text search and summarization. Metadata Views provide the structured extraction layer that Devin or human team members can query using MCP tools, turning raw logs into searchable data.

MCP Connection Setup

To interface with Fastio, the Devin AI tool uses the Model Context Protocol (MCP). Fastio exposes action-based MCP tools that allow agents to manage files, create folders, and run search queries. Access is available via Streamable HTTP at the /mcp endpoint or legacy SSE at /sse. The specific tools and implementation guides are detailed in the Fast.io MCP server guide. For onboarding, the developer documentation is hosted in the agent onboarding guide. Devin reads this guide, connects to the MCP server, and writes build outputs directly to Fastio workspaces.

When files arrive in the workspace, Fastio's Intelligence Mode indexes them for semantic search. Devin can query the index to locate relevant deployment files, referencing specific sections using citations. When the session finishes, Devin can initiate an ownership transfer, handing the workspace over to a human team lead while keeping access for future runs.

Branded Shares and Subscription Details

Fastio supports branded shares to distribute outputs safely. Teams can configure Send, Receive, or Exchange links. These shares can have expiration dates or custom access permissions.

Fastio has no permanent free plan and no free agent tier. The platform requires a paid subscription for organizational work. The Starter plan is priced at $29/mo, the Business plan at $99/mo, and the Growth plan at $299/mo. Pricing details are available on the pricing page. Every organization account starts with a 14-day free trial, which requires a credit card. This trial allows teams to configure workspaces, test Devin MCP tool connections, and evaluate automated workflows before any charges occur. Fastio provides these workspace security features without claiming formal compliance certifications.