{"id":4010,"date":"2026-09-22T08:00:44","date_gmt":"2026-09-22T15:00:44","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/azure-sdk\/?p=4010"},"modified":"2026-09-22T14:40:59","modified_gmt":"2026-09-22T21:40:59","slug":"using-azure-blob-storage-as-a-durable-filesystem-for-langchain-deep-agents-2","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/azure-sdk\/using-azure-blob-storage-as-a-durable-filesystem-for-langchain-deep-agents-2\/","title":{"rendered":"Using Azure Blob Storage as a durable filesystem for LangChain Deep Agents"},"content":{"rendered":"

\"azure<\/a><\/p>\n

LangChain Deep Agents<\/a> is an open-source agent harness with built-in capabilities for building LLM-powered agents and applications, including complex, multi-step workflows.<\/p>\n

A model can reason and generate responses, but it needs a harness to do useful work over time. The harness provides the tools and runtime that let the model retrieve the right context, take actions, and manage work across multiple steps. Deep Agents supplies that structure through planning, context management, a virtual filesystem, memory and skills, specialized subagents, and human approval points.<\/p>\n

Filesystems give agents a familiar way to organize and work with context. An agent can list and search files, read only what the current task needs, update artifacts, keep notes, and share work with subagents. This makes the filesystem useful as both a workspace and external memory for long-running tasks, a pattern LangChain highlights in its Deep Agents architecture<\/a>. Deep Agents exposes this pattern through tools for listing, searching, reading, writing, and editing files.<\/p>\n

When agents run in the cloud at scale, provisioning and managing a traditional filesystem for every agent can add infrastructure and lifecycle overhead. Developed through collaboration between LangChain and Azure Storage, AzureBlobBackend<\/code><\/a> gives Deep Agents<\/a> a virtual filesystem backed by Azure Blob Storage. The agent works through familiar filesystem tools such as ls<\/code>, read_file<\/code>, write_file<\/code>, edit_file<\/code>, glob<\/code>, and grep<\/code>, while Blob Storage provides durable, elastic storage underneath. Files can outlive an agent process, be shared across agents and applications, and remain accessible through familiar Azure security and data-management tools. The integration is available through the langchain-azure-storage<\/code><\/a> package in Public Preview.<\/p>\n

Why use Blob Storage for a Deep Agents filesystem?<\/h2>\n

Build self-improving workflows on durable state<\/h3>\n

Blob Storage can preserve the files that shape an agent’s behavior across sessions, including agent instructions, skill libraries, logs, memory, and offloaded context. Agents can read and update these artifacts over repeated runs, enabling feedback loops that retain useful experience and improve performance incrementally.<\/p>\n

Create secure, organized filesystems for collaborating agents<\/h3>\n

Blob containers provide access boundaries that can be secured with Azure role-based access control, while familiar blob paths keep shared artifacts organized. This makes it practical for multiple agents to collaborate through the same filesystem while keeping access appropriately scoped.<\/p>\n

Scale across enterprise document collections<\/h3>\n

Blob Storage provides durable, elastic storage for large enterprise document collections. Multiple agents can securely access the same corpus without relying on worker-local disks or managing storage capacity as data and workloads grow.<\/p>\n

Inspect and operate the filesystem outside the agent<\/h3>\n

Developers can inspect agent-created files through the Azure portal, Azure Storage Explorer, or other applications with authorized access. They can scan files, run independent processing, and support interactions with people or tools that use the same data. Access control, diagnostics, retention, recovery, and lifecycle management remain available independently of the agent.<\/p>\n

Getting started<\/h2>\n

Get started by connecting a simple agent to Blob Storage. The following example writes a file with one agent, then creates a second agent with the same backend and reads the file from their shared Blob-backed workspace.<\/p>\n

Create the filesystem container<\/h3>\n

Choose an Azure storage account and a blob container for the agent’s filesystem. You can use an existing container or create one in the Azure portal by opening the storage account, selecting Data storage > Containers<\/strong>, and selecting + Container<\/strong>. This article uses agent-files<\/code> as an example name. Copy the storage account’s Blob service endpoint, which has the form https:\/\/<storage-account>.blob.core.windows.net<\/code>.<\/p>\n

Grant access to the container<\/h3>\n

Assign Storage Blob Data Contributor<\/a> on the container to the identity that will run the agent. For local development, assign the role to your user account and sign in with the Azure CLI:<\/p>\n

az login<\/code><\/pre>\n
When the application runs in Azure, assign the same role to its managed identity or workload identity instead. The Azure host provides that identity to the application, so the deployed application does not need an Azure CLI sign-in or storage account keys.<\/p>\n
Install the integration<\/h3>\n
Use Python 3.11 or later. Install the storage integration:<\/p>\n
pip install -U \"langchain-azure-storage[deepagents]\"<\/code><\/pre>\n
Deep Agents supports multiple model providers. Choose and install one using the Deep Agents quickstart<\/a>. This example uses openai:gpt-6-astra<\/code>; if you choose it, install langchain-openai<\/code> and set OPENAI_API_KEY<\/code>:<\/p>\n
pip install -U langchain-openai<\/code><\/pre>\n
Set the API key in Bash:<\/p>\n
export OPENAI_API_KEY=\"your-api-key\"<\/code><\/pre>\n
Or, in PowerShell:<\/p>\n
$env:OPENAI_API_KEY = \"your-api-key\"<\/code><\/pre>\n
Connect the backend to the agent<\/h3>\n
Create AzureBlobBackend<\/code> with the Blob service endpoint and the exact name of your chosen container, \u201cagent-files\u201d in this example, then pass it to create_deep_agent<\/code>. By default, the backend uses DefaultAzureCredential<\/code><\/a>, so the same code works with your Azure CLI sign-in locally and an Azure identity when deployed.<\/p>\n
from deepagents import create_deep_agent\r\nfrom langchain_azure_storage.deepagents import AzureBlobBackend\r\n\r\nbackend = AzureBlobBackend(\r\n    account_url=\"https:\/\/<storage-account>.blob.core.windows.net\",\r\n    container_name=\"agent-files\",\r\n)\r\n\r\nagent = create_deep_agent(\r\n    model=\"openai:gpt-6-astra\",\r\n    backend=backend,\r\n)\r\n\r\nagent.invoke(\r\n    {\r\n        \"messages\": [\r\n            {\r\n                \"role\": \"user\",\r\n                \"content\": \"Create \/hello.py with a Python hello world script.\",\r\n            }\r\n        ]\r\n    }\r\n)<\/code><\/pre>\n
Deep Agents exposes filesystem tools backed by the container. In this example, the agent uses write_file<\/code> to create hello.py<\/code> as a blob.<\/p>\n
Share the workspace with another agent<\/h3>\n
Create another agent with the existing backend, then ask it to read the file. The two agent instances share the same Blob-backed workspace, even though the second agent has no earlier conversation state.<\/p>\n
another_agent = create_deep_agent(\r\n    model=\"openai:gpt-6-astra\",\r\n    backend=backend,\r\n)\r\n\r\nresult = another_agent.invoke(\r\n    {\r\n        \"messages\": [\r\n            {\r\n                \"role\": \"user\",\r\n                \"content\": \"Read \/hello.py and explain what the script does.\",\r\n            }\r\n        ]\r\n    }\r\n)\r\nprint(result[\"messages\"][-1].content)<\/code><\/pre>\n
Both agents use the same backend object and therefore the same Blob-backed filesystem. This lets multiple agents exchange artifacts through a shared workspace. With basic sharing working, explore the mortgage packet processing example<\/a> to see how the same approach supports a complete multi-agent workflow.<\/p>\n
Build a multi-agent mortgage processing workflow<\/h2>\n
\"Mortgage<\/a><\/p>\n
The mortgage processing example<\/a> provides a complete application pattern. It uses one coordinator and four specialist Deep Agents for packet intake, document classification, fact extraction, and underwriting. Instead of sending every file to Blob Storage, it uses CompositeBackend<\/code><\/a> to route only durable application data to three Blob-backed filesystem locations:<\/p>\n