AI assistants have traditionally worked as reactive tools: you provide a prompt, receive a response, and then perform the next step yourself. Many workplace tasks, however, involve several connected steps—finding files, analyzing information, using applications, creating deliverables, and organizing the results.
From Chat-Based Assistance to Agentic Workflows
Traditional chat-based workflows usually require you to handle each step yourself. You ask a question, receive an answer, and then provide the next instruction or move the result to another application.
Agentic workflows can handle multiple related steps as part of a single task. With access to appropriate tools, Cowork can:
- Work through multi-step tasks: Read information, analyze it, create files, and perform other connected operations.
- Use external tools: MCP servers can provide access to files, APIs, databases, and other applications.
- Work with existing context: Relevant files, project information, and connected tools can reduce the amount of information you need to provide manually.
- Produce complete outputs: Instead of returning only an answer, Cowork can create a report, update a file, or prepare another requested deliverable when the connected tools support those actions.
MCP does not automatically make every workflow secure. Security depends on how the connected tools, permissions, authentication, and environment are configured.
Real-World Automation Use Case
Cowork can be useful for workflows that combine several repetitive tasks.
1. Competitive Research
Instead of manually collecting information from multiple sources and preparing a report, a connected workflow can:
- Gather information from approved sources.
- Organize and compare the findings.
- Identify important changes.
- Create a structured report.
Example: Research these competitors, compare their latest product updates, and create a Markdown report with the key findings.
2. CRM and Email Workflows
A CRM workflow can combine customer information, company guidelines, and email drafting.
For example:
- Retrieve the relevant customer information.
- Read the approved communication guidelines.
- Draft the email.
- Prepare the draft for review.
Save it to the CRM if the connected tool supports that operation.
3. Content Repurposing
A content team can provide a transcript and ask Cowork to turn it into multiple deliverables.
Example: Review this webinar transcript, identify the strongest sections, create a timestamped cut list, and draft social media posts for each section.
Configuring Claude Cowork with MCP
To start automating tasks, you need to configure Claude Desktop to route Cowork's reasoning engine through MCP servers. In this example, we will connect Cowork to your local file system and enable a Long-Term Memory tool.
Step 1: Locate Configuration File:Path depends on your OS.
First, you must access the Claude Desktop configuration file where MCP servers are registered.
- macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
- Windows: %APPDATA%\Claude\claude_desktop_config.json
Step 2: Add MCP Connectors
Open the JSON file in your preferred code editor. We will add a local File System server (allowing Cowork to read/write specific folders) and a custom tool.
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/username/Desktop/Automations",
"/Users/username/Documents/Reports"
]
},
"pieces-ltm": {
"command": "npx",
"args": ["-y", "@pieces.app/mcp-server"]
}
}
}
Step 3: Limit the Access
Give the MCP server access only to the directories or services it needs.
For example, if a workflow works with reports, create a dedicated folder:
Documents/
├── Reports/
└── Automations/
This is particularly important for agentic workflows because Cowork can perform actions through connected tools. Anthropic's current Cowork architecture also uses scoped filesystem access, including read-only and read/write modes, to limit what the agent can access
Step 4: Restart or Reload Claude Desktop
- After installing or configuring an MCP server, restart or reload Claude Desktop if required.
- Check that the MCP server appears as an available tool before running an automation.
Step 5: Test the Connection
Start with a read-only request.
Example: List the files available in my Reports folder.
Only after the read operation works correctly should you allow the workflow to create or modify files.
Step 6: Run a Complete Workflow
- Open Claude Cowork. You will notice a "Tools" icon indicating that it now has access to your File System.
- Once the connection is working, give Cowork a complete objective.
Example: Read the weekly sales CSV in my Reports folder, identify the three highest-performing regions, and create a Markdown summary in my Automations folder.
The workflow can then use the connected file tool to access the source data and create the requested output.
Building Custom MCP Interfaces
The MCP Apps Extension (SEP-1865) defines a way for MCP servers to provide interactive user interfaces that hosts can render alongside tool results. The proposal includes mechanisms for linking UI resources to tools and allowing communication between the interface and the MCP server.
Example: An internal project-management tool could expose a create_jira_ticket tool and provide a form containing fields such as:
- Title
- Description
- Priority
- Assignee
- Project
Note: MCP Apps is an extension of the MCP ecosystem, so implementation and client support can vary. Check the current MCP specification and client documentation before building against it.
Security Best Practices
Giving Cowork access to files and external tools requires careful permission management.
Restrict File Access
- Only expose folders required for the task.
- Avoid giving a filesystem MCP access to your entire system drive when the workflow needs only one project folder.
Use Minimum Permissions
A tool should have only the permissions necessary for its job.
For example, a reporting workflow may need to:
- Read source files.
- Create reports.
It may not need permission to delete files or modify unrelated directories.
Require Confirmation for Sensitive Actions
Use additional confirmation for operations such as:
- Deleting files.
- Modifying production data.
- Sending emails.
- Publishing content.
- Changing account settings.
- Executing destructive database operations.
Protect Credentials
- Do not place API keys or passwords directly in prompts or source files.
- Use the authentication and secret-management mechanisms provided by the relevant application or MCP server.
- Anthropic's Desktop Extension system, for example, supports storing sensitive configuration such as API keys in the operating system's secure keychain.
Test With Safe Data
Before connecting an automation to production systems, test it with:
- Sample files.
- Test databases.
- Non-production accounts.
- Read-only operations.
This makes it easier to identify incorrect tool behavior before real data is affected.
Practical MCP Projects
Once you have a working MCP setup, these projects provide useful ways to learn how tool-based workflows work.
1. Build an API Integration
Create an MCP server that connects to a public API.
Example: A weather API could expose a tool such as:
get_weather
This teaches you how to:
- Define MCP tools.
- Create input schemas.
- Make API requests.
- Return structured results.
- Connect the server to an AI client.
2. Build a Multi-System Workflow
Connect two MCP servers and use them together.
Example:
- Read an issue from GitHub.
- Analyze the issue.
- Generate a proposed solution.
- Save the solution to a local project folder.
This demonstrates how multiple tools can be combined into one workflow.
3. Add Human Approval
Create a test MCP server with two operations:
read_user
delete_user
Allow the read operation normally, but require explicit approval before deleting a record. This demonstrates an important principle for agentic systems: not every tool action should happen automatically.
4. Build a Code Review Workflow
Create an MCP tool that retrieves the current Git changes and prepares them for review.
A workflow could:
- Retrieve the Git diff.
- Analyze the modified files.
- Identify potential bugs and security issues.
- Generate a structured review.
- Save the results to a Markdown file.
This removes the need to manually copy large diffs into a chat.
5. Experiment With Browser Automation
A browser-enabled MCP server can support controlled research and testing workflows.
For example:
- Open a specified website.
- Search for a product.
- Collect selected information.
- Structure the results.
- Save the results to a file.
Browser automation should be tested carefully because websites can change and external content should not automatically be treated as trusted instructions.