AI Exec Assistant Stack Analysis

Cowork is Anthropic's agentic desktop product - think "Claude Code but for knowledge work." It runs in the Claude Desktop app (macOS/Windows), executes tasks in an isolated local VM, and can read/write/create files, browse the web via Chrome, and pull context from connected tools. Currently in Research Preview.

Core Architecture

• Local VM sandbox: Tasks run isolated on your machine. You grant folder + connector access explicitly.
• Agentic execution: You describe an outcome, Claude breaks it into steps, executes them, and loops you in before major actions.
• Scheduled tasks: Set up recurring work (daily briefings, weekly reports) that auto-execute on cadence.
• Sub-agents: Claude coordinates multiple sub-agents and tool calls for complex work.

Plugins System

Plugins bundle skills, connectors, and sub-agents into a single install. Think of them as "role packages" - install one and Claude becomes a specialist for finance, legal, sales, etc. Plugin examples from Anthropic: brand voice analysis, contract review/NDA triage, financial statement workflows. This is where the consulting opportunity lives - building custom plugins for clients.

Current Limitations

• No Projects integration (yet)
• No Memory across sessions (each session is fresh - but can be solved with local files, see Section 06)
• No Artifacts
• Sessions don't sync across devices
• Enterprise audit logs don't capture Cowork activity yet
• Not approved for HIPAA, FedRAMP, or FSI workloads

Key cost consideration: Agentic tasks consume significantly more capacity than chat. For heavy daily use, you're looking at $100-200/mo per person. For client rollouts, Team at $20/seat is the sweet spot for small businesses.

Cowork ships with native connectors that require zero setup beyond OAuth authentication:

What's Still Missing Natively

• Microsoft 365 - No native Outlook, Teams, SharePoint, or OneDrive connector (see Section 04)
• CRM systems - No native HubSpot, Salesforce, Pipedrive, etc.
• Accounting - No native QuickBooks, Xero, etc.
• Project management - No native Asana, Monday, Linear (Jira is Enterprise only)

All of these gaps are fillable via MCP servers or Claude in Chrome (see Section 05).

Many of your enterprise clients run Microsoft 365 (Outlook, Teams, SharePoint, OneDrive, Planner, To Do). Cowork has no native M365 connector. This is your biggest integration challenge - and your biggest consulting opportunity.

Solution: MCP Server for Microsoft 365

The open-source ecosystem has already solved this. The leading MCP server for M365:

What It Covers

Setup for Clients

One-liner install into Claude Desktop config:

The --org-mode flag enables enterprise features (Teams, SharePoint, shared mailboxes). Auth is via Microsoft's standard OAuth flow through the browser - the user signs in with their M365 credentials once.

Additional M365 MCP Options

• pnp/cli-microsoft365-mcp-server (88 stars) - From the Microsoft PnP community, wraps the CLI for M365
• outlook-mcp (16 stars) - Focused Outlook email + calendar + SharePoint
• office-365-mcp-server (12 stars) - 24 consolidated tools for email, calendar, Teams, Planner

Option 1: MCP Servers (Model Context Protocol)

MCP is an open standard (created by Anthropic) for connecting AI to external systems. Claude Desktop natively supports MCP servers. You configure them in the desktop app settings, and Cowork can use any tools/resources they expose.

• How it works: Build or use pre-built MCP servers that expose your APIs, databases, or SaaS tools as "tools" Claude can call.
• Pre-built servers exist for: Google Drive, GitHub, Slack, PostgreSQL, filesystem, M365, and hundreds more.
• Custom MCP servers: You can build one for any API. Python/TypeScript SDKs available. This is the recommended path for custom business data.
• Limitation: MCP servers run locally (stdio) or via HTTP. Client still needs to install/configure them - but this is where your service comes in.

Option 2: Claude Code as the Custom Backbone

Claude Code (the CLI tool) can do anything on a machine - hit APIs, run scripts, manipulate files. For custom integrations that are too complex for MCP, you can:

• Use Claude Code to build MCP servers that Cowork then consumes (build once, install everywhere)
• Build scripts/tools with Claude Code, save outputs to local folders that Cowork reads
• Run Claude Code headlessly as a "backend agent" that syncs external data to local files on a schedule

Option 3: Claude in Chrome (Browser Automation)

For SaaS tools without MCP servers or APIs, Cowork's Chrome connector lets Claude browse and interact with any web app the client uses. This is the "last resort" integration - slower but works with literally anything that has a web UI.

Option 4: Files as the Integration Layer

Cowork's simplest integration: dump data into a local folder. Any ETL pipeline, cron job, or n8n flow can write CSVs/JSONs/markdown to a folder Cowork watches. This is crude but effective and zero-friction for clients who already have data pipelines.

The community has discovered that Cowork can function much like an OpenClaw agent by leveraging local files as persistent memory and instructions. Since Cowork can read/write to granted folders, you create a structured workspace that gives Claude continuity and business context across sessions.

The Pattern: Local File-Based Agent Architecture

How It Works in Practice

• Session start: Cowork reads INSTRUCTIONS.md + CONTEXT.md + MEMORY.md to "wake up" with full context. You can instruct it to do this automatically at the start of every session.
• During work: Claude follows the instructions/skills, references business context, and makes decisions informed by past memory.
• Session end: Claude writes session notes to memory/YYYY-MM-DD.md and updates MEMORY.md with anything worth remembering.
• Scheduled tasks: Cowork's recurring task feature auto-reads these files on schedule (daily briefing, weekly report, etc.)

Cowork File Agent vs. OpenClaw - Honest Comparison

• Always-on messaging: WhatsApp, Telegram, Discord, Signal, iMessage - the agent lives in your chat apps. No desktop app required. Clients can text their AI assistant.
• Persistent memory & context: SOUL.md, MEMORY.md, daily memory files, heartbeats. The agent has deep continuity across sessions.
• Proactive behavior: Heartbeats check email/calendar/tasks on schedule. Cron jobs fire without human initiation. The agent can reach out to you.
• Multi-agent routing: Multiple agents, isolated sessions, workspace separation. Route different people to different agents.
• Deep customization: Skills, cron jobs, tool access, voice pipeline, browser control - anything you can code, the agent can do.
• API/tool integration: Direct API calls, exec commands, MCP support, browser automation - no connector ecosystem dependency.
• Self-hosted control: Your data, your rules, your infrastructure.

Honest Limitations for Productization

• Setup complexity: Requires Node.js, config files, API keys, channel setup. Not a "sign up and go" product.
• Maintenance burden: Self-hosted means you (or the client) are the ops team. Updates, monitoring, restarts.
• No GUI for non-technical users: Config is JSON files and CLI. The Control UI helps but it's not Cowork's polish.
• Hard to standardize: Every deployment is custom. Skills, tools, memory, persona - all handcrafted per client.
• Hidden cost: Backend rollout for a client (provisioning server, installing Node.js, configuring channels, building skills, setting up monitoring) is 4-16+ hours of billable engineering time. Ongoing maintenance adds more.

Layer 1: Custom Integration (Claude Code + MCP + APIs)

This is the foundation. Claude Code builds MCP servers, scripts, and integrations. MCP servers standardize access to client systems. Direct API calls handle the rest. You build this once per client type, then reuse.

Layer 2: Orchestration (OpenClaw + n8n)

OpenClaw agents act as the intelligent brain - they have memory, context, personality, and can make decisions. n8n handles the deterministic "if this then that" automations (webhook fires, data transforms, multi-step sequences). The agent decides WHAT to do; n8n handles HOW to do the linear parts.

Layer 3: User Interface (Cowork + Chat Apps)

Cowork is the desktop power-user interface for knowledge workers who want to hand off document work, research, and analysis. Chat apps (via OpenClaw) are the mobile-first, always-available assistant for quick questions, scheduling, and async tasks. Different surfaces for different use cases - not competing, complementary.

Both tools read and write to the same folder. OpenClaw populates inbox/ and daily/ with real-time data. Cowork processes it during scheduled tasks and writes outputs to outbox/. OpenClaw picks up outbox items and executes them (sends emails, posts messages, updates CRMs). The folder is just markdown files - no database, no API, version-controllable with git.

Why this needs both: OpenClaw handles the always-on scraping and instant mobile notifications. Cowork handles the deep research, cross-referencing, and quality email drafting that would burn through OpenClaw's context window. Neither tool alone covers the full pipeline.

The value: The exec wakes up to a curated briefing delivered to their phone - not a raw dump of notifications, but a synthesized "here's what matters today" document. Cowork does the thinking; OpenClaw does the delivering.

The bridge pattern is your premium tier offering. Pricing structure:

The bridge folder itself is trivial - it's just markdown files in a shared directory. The value is in knowing what to monitor, how to structure the data, and what workflows to automate. That's your IP. The folder structure is a template you replicate per client; the crons and scheduled tasks are customized to their business.

Here's how a client onboarding looks end-to-end using Cowork as the primary surface, with OpenClaw/n8n for deeper automations when needed:

Not every client needs the full stack. Here's the decision tree:

• Client just needs a desktop knowledge work assistant? - Cowork only. Done.
• Client needs mobile/text access? - Add OpenClaw with a chat channel (WhatsApp/Telegram).
• Client needs proactive alerts/monitoring? - Add OpenClaw heartbeats or cron jobs.
• Client needs linear automations (data sync, webhook triggers)? - Add n8n.
• Client needs a fully custom AI system (like BW FM)? - Full stack: OpenClaw + n8n + custom skills + Claude Code for building.

Start with Cowork. Layer up only when the use case demands it. This keeps your delivery fast and your margins high.

Claude Enterprise Admin Features

Based on the Enterprise plan documentation, admin capabilities include:

• SSO (Single Sign-On) and domain capture - centralized identity management
• SCIM provisioning - automated user lifecycle management
• Role-based access with fine-grained permissioning
• Audit logs (note: Cowork activity not captured yet)
• Compliance API and data retention controls
• Usage analytics and spend controls
• Self-serve seat management
• Admin can toggle Cowork on/off for the organization

The MSP (Managed Service Provider) Question

Can Fulcrum act as a managed admin for client Claude accounts? Here's the realistic picture:

What Admin Access Gets You

• Toggle Cowork on/off per org
• Manage seats (add/remove users)
• Configure SSO and domain capture
• Set spend controls and usage limits
• View usage analytics (which team members are using it, how much)
• Manage data retention policies

What You CAN'T Do Yet (Admin Gaps)

• Can't push MCP server configs to all users centrally (each user configures locally)
• Can't push Cowork workspace folders centrally (need MDM or manual copy)
• Cowork audit logs not available yet (can't see what Cowork did for compliance)
• No "template library" feature to share pre-built skills/prompts org-wide

Workaround for the config distribution problem: Use a shared cloud folder (Google Drive, OneDrive, Dropbox) as the workspace that all users' Cowork instances point to. Updates to INSTRUCTIONS.md or skills/ propagate to everyone automatically. MCP configs still need per-machine setup, but a simple installer script solves that.

1. AI Exec Assistant Rollouts (Cowork + MCP) - Recurring Revenue

• Offer: "We'll set up an AI executive assistant for your team that knows your business, connects to your tools, and works 24/7."
• Delivery: AI audit + pre-built workspace + MCP configs + training
• Pricing: $2,500-5,000 setup + $500-1,500/mo managed service
• Scalability: HIGH. Workspace templates per vertical. MCP servers reuse across clients. 2-week delivery cycle.
• Client friction: LOW. They get a Claude Team plan, download the desktop app, you do the rest.
• Margin: After the first 3-4 clients in a vertical, setup drops to ~8 hours. At $5K setup that's $625/hr effective rate.

2. Custom Generative Automations (OpenClaw + n8n) - Project Revenue

• Offer: "We'll build an AI system that [does specific thing] and saves you [X hours/dollars]."
• Delivery: OpenClaw agent + n8n flows + custom integrations
• Pricing: $5,000-25,000 per project + $500-2,000/mo maintenance
• Scalability: MEDIUM. Each project is somewhat custom, but skills/flows compound.
• Example: BW Facilities Management - lead scraping, work order automation, reporting

3. Education & Training - Leverage Revenue

• Offer: "Learn to build AI exec assistant workflows for your company/clients."
• Delivery: Workshop/course on Cowork plugins, MCP servers, the local files pattern, automation architecture
• Pricing: $500-2,000 per seat for workshops, $200-500 for courses
• Scalability: HIGHEST. Build once, sell many times.
• Key insight: Teaching Cowork + MCP is easier than teaching OpenClaw. Start here for volume.

For Yourselves (Internal Exec Assistant)

• Primary interface: OpenClaw (WALL-E) via Signal/Telegram for always-on async. You already have this running with deep memory, calendar, email, etc. Don't replace it.
• Add Cowork for desktop knowledge work - report generation, document processing, research tasks, client deliverable production. Use Max 5x ($100/mo) for heavy usage.
• Connect Cowork to OpenClaw's workspace via shared folders. Cowork outputs go where WALL-E can read them and vice versa.
• n8n for linear automations: Webhooks, data syncs, lead pipelines. Have the OpenClaw agent build and manage n8n flows.
• Claude Code for building: Use it to rapidly create MCP servers, skills, and integrations for clients.

For Client Deployments

• Tier 1 (Standard - $2-5K + $500-1.5K/mo): Cowork + pre-built workspace + MCP servers. Google Workspace or M365 clients. 2-week delivery. This is 80% of your clients.
• Tier 2 (Premium - $10-25K + $1-2K/mo): Cowork + OpenClaw agent + n8n automations. For clients who need always-on automation, not just desktop assistance. Mobile text access. Proactive alerts. BW-type deployments.
• Tier 3 (Enterprise - custom): Full stack. Cowork for knowledge workers, OpenClaw for automation backbone, n8n for orchestration, custom MCP servers everywhere. Multi-department rollout.

1. Both of you: Get Cowork Max 5x ($100/mo each). Use it for a week. Try the local files pattern. Feel the edges. What works? What's missing? You need hands-on data, not just research.
2. Build an M365 demo. Install the Softeria MCP server, connect it to a test M365 account, and show it working in Cowork. This becomes your demo for enterprise clients.
3. Create a template workspace for a generic "small business owner" exec assistant. INSTRUCTIONS.md, CONTEXT.md, skills/, templates/. This is your reusable IP.
4. Draft the "AI Executive Assistant" offer for Cowork rollouts. Price it, scope it, build a one-pager. This is Stream 1.
5. Keep BW FM on OpenClaw + n8n. It's custom, always-on, multi-system. That's the premium tier. Don't force it into Cowork.
6. Investigate Claude Enterprise partner/reseller program. If Anthropic has an MSP or partner program, that's how you get admin access to manage multiple client orgs and possibly earn referral revenue on seats.