Latent Space: The AI Engineer Podcast

Episode: Why Anthropic Thinks AI Should Have Its Own Computer — Felix Rieseberg of Claude Cowork & Claude Code Desktop

Date: March 17, 2026
Guest: Felix Rieseberg (Member Technical Staff, Anthropic, product lead on Claude Cowork & Claude Code Desktop)
Hosts: Alessio and Swix

Episode Overview

This episode explores Anthropic’s vision for AI’s “own computer” through the journey of building Claude Cowork—a desktop app that wraps Claude Code in a secure, user-friendly virtual machine environment. Felix Rieseberg shares stories, design philosophies, and technical challenges behind enabling AI agents to execute knowledge work and code natively on a user’s machine. The discussion stretches from practical user cases, architectural decisions, and skills portability to future product directions and social impacts, all through the firsthand lens of Anthropic’s core builder culture.

Key Discussion Points & Insights

1. What is Claude Cowork? (02:17–07:43)

• Definition:
  Cowork is a user-friendly, desktop-based wrap for Claude Code, designed to let even non-technical users benefit from powerful AI code and task execution without terminal or installation hurdles. It runs Claude Code in a lightweight VM, providing “padding,” guardrails, and deeper OS integration.
• Use Cases:
  Surprisingly broad: users automate not only coding, but expenses, managing receipts, knowledge base organization, animating emojis, and more.

  “Every single person who’s most amazed is usually amazed about a thing I didn’t even expect Cowork would be good at.” — Felix, [01:20]

• Philosophy:
  Inspired by popularity growth of user-extendable platforms (e.g., Visual Studio Code), Felix argues Cowork is not a “dumbed-down” tool but a superset that power users and non-programmers both find compelling.

2. Design Decisions: Why a Desktop App? Why a VM? (04:54–14:27)

• Rapid Prototyping:
  Building Cowork in “10 days” was possible because of a prototyping-first culture and reuse of existing Claude Code infrastructure.

  “Don’t even write a memo. Just let’s build all the candidates very quickly… pick the best ones.” — Felix, [06:45]

• Local vs. Cloud Execution:
  A key fork: should the agent run on users’ local machines or purely in the cloud? Anthropic sees value in AI having access to local resources:
  • Security/safety: running in VM sandboxes AI actions.
  • Practicality: users often want agent access to local files, browser sessions, etc., without entrusting everything to the cloud.

  “There’s still value in having a local machine. … That entity [Claude] needs access to the same tools you have access to, otherwise it’s hamstrung.” — Felix, [16:58]

  • Cloud-only has permissions issues and creates friction, especially for high-trust, cross-application workflows.

3. Architecture Deep Dive: The Power of Giving AI Its Own Computer (11:57–16:43)

• How Cowork Works:
  • Core: Claude Code runs inside a lightweight, tightly sandboxed Linux VM.
  • Feature: Claude has broad autonomy—can install tools (Python, Node.js, etc.) within the VM, yet network and system access can be precisely guarded.
  • Analogy:

    “If you were a developer and your employer told you you don’t need a computer, they’ll just send code via email… that is not very effective.” — Felix, [12:43]

  • Modular: The system prompt and tool integration (including deep Chrome browser linkage) are customizable and adaptive.

4. Evolving User Models: Coding, Knowledge Work, and Planning (19:38–23:43)

• Optimization for Use Case:
  • Cloud Code is still optimized for coding; Cowork is oriented more toward broad, ambiguous knowledge work (finance, legal, personal management).
  • System prompts and tool availability differ based on product context, but architectural core remains identical.
• Long-Range Planning and User Interaction:
  • Cowork emphasizes long-horizon, ambiguous task planning—and leverages plan visualization and “Ask User” interactions more proactively for knowledge work.

5. On Skills, Plugins & User Empowerment (27:05–30:55)

• User Creation of Skills:
  • Cowork allows users to wrap repeatable workflows into custom “skills” (markdown/text-based plugins), enhancing reusability and personal automation.
  • Example: Automate video uploads, calendar management, desktop cleaning, and complex multi-step office tasks.

  “Anyone can make a skill. Like, a text message could be a skill, and they can be so hyper-personalized to you.” — Felix, [28:30]

• Skill Portability:
  • Skills are intentionally file-based (simple markdown/text) for portability and sharing across agents, but more UX polish is needed for enterprise/knowledge work adoption.

6. Local vs. Cloud: The Societal and Technical Balance (16:58–23:25, 58:09–60:08)

• Local-first Reasoning:
  • Silicon Valley is seen to undervalue the “local computer.” Most power users still prefer local execution for privacy/trust, and not all users will want to “clone their computer to the cloud.”
• Practical Challenges:
  • Security tradeoffs: e.g., websites may detect duplicate authentications, causing account locks.
  • Sandbox VMs let Cowork do powerful things with less risk than letting Claude free-run on the host.

7. Safety, Security & the Swiss Cheese Model (66:45–70:40)

• Security Philosophy:
  • Anthropic strives for a pragmatic balance between user convenience and agent power: “Approve every action” is not scalable, and new models (sandboxing, delegated trust) are needed.
  • Engineers are more risk-tolerant, but most users want (and need) stronger default safeguards.

8. Industry Impact & Social Considerations (43:53–51:03)

• Potential for Job Displacement:
  • Concerns that automating away “annoying” tasks risks reducing entry-level/junior opportunities, particularly in knowledge industries.
  • Possible future: fast-forwarded, simulation-based “learn by doing” tracks to condense job learning, especially for engineers, inspired by university co-op/internship models.

  “…We’re deeply worried about the impact that these tools are going to have on the labor market, especially for junior employees.” — Felix, [45:33]

9. Technical Underpinnings: VM Architecture (62:38–66:45)

• Why the VM Matters:
  • VM isolates and safely enables Claude to have everything it needs—languages, libraries, tools—without polluting or breaking the host or requiring every user to be an administrator.
  • On Mac, Anthropic uses Apple’s Virtualization Framework; on Windows, the Windows Host Compute System (WSL2 foundation).
  • There are tradeoffs: disk image size, launch latency, but the approach maximizes compatibility and limits risk.

10. Lessons from Electron and Cross-Platform App Building (75:26–79:04)

• Why Not Build Natively?
  • Electron, despite shipping a full Chromium engine, remains the most reliable cross-platform UI option for robust apps. OS-native webviews are inconsistent, slow to update, and problematic for users not on current hardware/OS.
  • The analogy: Chromium is the “super operating system” that works everywhere, and modern desktop apps leverage its reliability—even Unreal Engine uses Chromium for rendering.

  “The Unreal Engine… to render some text, [they] use Chromium.” — Felix, [78:54]

Memorable Quotes & Moments

• On Cowork being a step up, not down:

  “People say ‘user-friendly’ is the dumbed-down version, but no, actually this is the superset.” — Alessio, [03:40]

• On rapid prototyping vs. traditional product management:

  “Don’t even write a memo. Just let’s build all the candidates very quickly… pick the best ones.” — Felix, [06:45]

• On AI having its own machine:

  “It is quite powerful to give Claude its own computer. That is generally a good idea… it often is quite useful to anthropomorphize Claude aggressively and just be like, this is a person. What would you do if you had a person?” — Felix, [11:57]

• On future of knowledge work:

  “We’re starting to grapple more with what does ‘your computer’ mean? Does it have to be the one in front of you, or a VM, or a computer somewhere else?” — Felix, [70:45]

• On building for extensibility, not hyper-specialization:

  “… I think the hyper-specialized thing is very important. It keeps you general purpose… no point did we release… cloud code for Node JS applications that use React… and only those two things.” — Felix, [74:07]

Timestamps of Landmark Topics

• [02:17] — What is Claude Cowork? Target user and use cases
• [04:54] — Origin story: Design choices and rapid prototyping culture
• [11:57] — Technical architecture: Why run Claude Code in a VM?
• [16:58] — The local vs. cloud agent debate
• [19:38] — Difference in optimization and evaluation for Cowork vs. Cloud Code
• [23:43] — Skill creation and user empowerment stories
• [27:05] — Real-world “cowork as AGI assistant” stories from Alessio
• [43:53] — Discussion on workforce impact and “simulated” learning for juniors
• [58:09] — Deep dive: How many computers does Claude need? VM and privacy boundaries
• [62:38] — Windows support, virtualization, and security
• [66:45] — Security UX: Sandbox, permissions, and the “Swiss cheese” defense
• [75:26] — Why Electron, not native webviews?
• [79:04] — Chromium as the “super OS” of the app world

Future Directions & Closing Thoughts

• Cowork’s trajectory:
  More features shipped rapidly; continued deepening of local computer capabilities; iterating toward more independence (Claude running longer, broader tasks with less user oversight).
• Upcoming team focus areas:
  Making Cowork more general-purpose, even as hyper-specialization threatens startups. Agile, user-driven product cycles with strong feedback loops.
• Vision for “AI-native” knowledge work:
  Desktop tools that start by automating small tasks, but could ultimately orchestrate large swathes of personal or company workflows.
• Safety and trust as bedrock:
  Ongoing investment in sandbox, permissioning, and user transparency to make AI assistance trustworthy for all kinds of users—not just engineers.

“You start by automating something tiny, and once it clicks, you keep adding onto this automation empire… It’s a little bit like playing Factorio for your own life.” — Felix, [30:12]

For more, see: https://latent.space