Anthropic’s Felix Rieseberg on AI Coworkers, Local-First Agents, and the Future of Knowledge Work
Summary
The episode’s core agent thesis is that a useful Claude needs access to the tools surrounding the user, making the local computer a strategic substrate rather than a legacy endpoint. swyx argues that Silicon Valley undervalues local machines—“how come we’re all using MacBooks and not like an iPad or a Chromebook?”—while the discussion highlights connector fatigue, missing tools, data-transfer discomfort, and authentication systems that may lock accounts accessed from two locations.
Claude Cowork is a guarded desktop superset of Claude Code, not merely its simplified edition. It places the existing agent harness inside a lightweight Linux VM, adds knowledge-work steering, Claude in Chrome, and a friendlier planning-and-questioning experience, while preserving the ability to install Python, Node.js, and whatever tools a task requires. The reported 10-day build rested on roughly 1.5 years of prototypes and reusable components—the relevant moat is the platform beneath cheap code generation.
Cheap execution is collapsing the distance between product hypothesis and working prototype, but Felix rejects the idea that this eliminates shared software platforms. Anthropic increasingly follows “don’t even write a memo, just build”: create plausible candidates, test them with users, and keep the best. Yet hyper-personalized software creates interoperability problems, while reusable models, harnesses, skills, and applications become more valuable as recombination gets cheaper.
The VM and sandbox are enabling infrastructure for autonomy, because an agent cannot be useful if every action requires approval. Cowork separates Claude’s computer from the user’s, controls its network and filesystem boundaries, and works atop Apple’s virtualization framework and the Windows Host Compute System used by WSL 2. Felix favors layered risk reduction—the industry’s “Swiss cheese model”—rather than endless permission prompts or an unrestricted host machine.
Skills are emerging as the durable abstraction above bespoke APIs and MCP integrations. A skill can be little more than a Markdown file explaining an endpoint or workflow; Cowork can turn a one-off, supervised task into reusable skills and orchestrate them. File-based plugins make portability technically simple, but the unresolved product problem is combining shared instructions with private preferences without losing the “just text” simplicity.
General agents create duration risk for narrow AI applications while placing immediate pressure on junior knowledge-work roles. Felix expects some highly specialized products to look impressive until general models absorb their planning and domain behavior, even as Anthropic invests directly in finance, enterprise, and other vertical workflows. He says Anthropic is “deeply worried” about the impact on entry-level work; accelerated simulations and Waterloo-style work experience may compress training, but they do not answer how many junior jobs remain.
Cowork’s roadmap discussion moves from answering questions toward acting independently for longer across more of the user’s working environment. Expect frequent releases, deeper use of the computer, and remote control “coming soon.” The unresolved endpoint is whether Claude inhabits the user’s machine, its own local or cloud computer, or ordinary organizational identities such as Gmail and Slack accounts through which agents coordinate.
Deep dive
1. Cowork is Claude Code with a safer computer and a broader job description
Felix’s concise definition: Claude Cowork is “a user-friendly version of Claude Code,” running the Claude Code agent harness inside a virtual machine with additional padding, guardrails, and convenience for people who are neither terminal-native nor interested in installing software before beginning knowledge work.
swyx’s pushback was that Cowork feels more powerful, not dumbed down: its Chrome integration and visible task machinery make it look like “the superset.” Felix accepted the analogy to Visual Studio Code, whose initial accessibility framing obscured the more consequential qualities—hackability, extensibility, and the ability to map onto almost any workflow.
The much-repeated 10-day build needs qualification. Anthropic had spent easily 1.5 years prototyping ways to move users from question-answer chat toward task execution, and its demo-first culture had accumulated many internal components. Cowork emerged by selecting and assembling “the right pieces,” much as a website built quickly still inherits React and its surrounding ecosystem.
2. Cheap execution changes product discovery without abolishing platforms
Felix described a sharp process change: “execution is actually quite cheap.” Instead of interviewing customers through a low-bandwidth process, drafting a specification, choosing one architecture, and discovering whether it works only later, Anthropic can build several candidates and expose each to a small focus group.
His strongest formulation was “don’t even write a memo, just build.” Decisions once treated as expensive commitments—technology A versus B, one interface versus another—can now be tested as functioning products. Felix believes this shift became materially stronger only recently, not as a gradual restatement of familiar prototyping advice.
swyx supplied the literal example: after encountering Electron and SQLite friction, he had the application recreated in Swift despite not knowing Swift. He said the valuable artifact was the application’s logic, not its bindings; for complex or high-performance systems, he still wants an architectural view, but joked that “you can use Markdown for that.”
Felix nevertheless rejects the fully personalized-software thesis. Everyone maintaining a private chat product would make collaboration harder, while shared primitives retain value. Cowork therefore started from “this should be Claude Code,” not from rebuilding its agent harness; cheap execution mainly lowers the cost of arranging models, MCPs, skills, and interfaces into a useful product.
3. Giving Claude its own computer removes an artificial capability ceiling
The VM is Cowork’s most consequential primitive. Felix’s design heuristic is to anthropomorphize aggressively: “This is a person.” An employer would not make a developer receive code by email and email changes back; a worker needs a computer, and an agent becomes similarly hamstrung when every tool must be mediated through chat.
Cowork’s lightweight Linux environment gives Claude room to install Python, Node.js, and task-specific utilities. Network ingress and egress remain controlled, and users can express boundaries in ordinary language, but a lawyer or marketer never has to interpret the implications of approving Homebrew installation on their actual machine.
swyx’s broader claim was deliberately contrarian: “Silicon Valley overall is undervaluing the local computer.” His default test is why its own builders still choose MacBooks over iPads or Chromebooks. If Claude is meant to be tremendously useful, placing it where the user’s files, applications, and authenticated workflows already live avoids a long tail of missing capabilities.
Cloud-first execution remains useful: swyx has Claude inspect a crash dashboard, separate likely application bugs from operating-system failures, write one Markdown prompt per fixable bug, and launch Claude Code remote tasks before his next meeting. The answer is therefore hybrid—not that local execution replaces remote work, but that cloud convenience does not erase the local machine’s privileged context.
4. Moving the whole desktop into the cloud creates social problems before technical ones
swyx has little patience for granting and maintaining permissions to every cloud service, but his deeper uncertainty is whether people want a provider to “slurp up your entire work.” Cloning an entire computer into the cloud could be technically straightforward; whether users, employers, and institutions accept that transfer is a separate and upstream question.
His sharpest example involved browser cookies. A desktop application could, with permission, read and move Chrome cookies into the cloud, making remote tasks appear seamless. Yet banks and other sites may interpret the same authentication appearing in two locations as account compromise, force a lockout, and require the customer to visit a branch with a passport.
The conclusion was hedged rather than absolute: swyx does not know which architecture ultimately wins, and acknowledged that parts of the ecosystem are slowly adapting to agents. Until authentication and institutional processes catch up, his practical way to make Claude effective is “to put it where you’re working.”
This local emphasis also explains why downloading an arbitrary file and dropping it into Cowork is an unlock. A connector-by-connector cloud strategy must anticipate every tool and permission combination; a local agent begins inside the heterogeneous environment users already assembled for themselves.
5. Cowork’s distinct behavior comes mostly from steering, tools, and evaluation
Claude Code is optimized and evaluated around coding, while Cowork is tested against knowledge work in finance, legal offices, personal mortgage administration, and family wealth planning. Felix said the resulting differences often come from system-prompt details, tool selection, and what the product can infer about the work—not from an entirely different planning engine.
swyx’s pushback—worth keeping—was that Cowork qualitatively feels more long-range: it presents a nine-step plan, invites edits and questions, then visibly executes. Felix’s answer was “kind of both”: Claude Code already has planning, but Cowork receives larger, more ambiguous tasks and is explicitly told to use planning and ask-user-question tools rather than disappear for four hours and return with the wrong result.
“Eval” here means replaying the entire transcript with all available tools, changing the surrounding system, and measuring both token responses and created files. Anthropic uses that machinery in training and in the scaffolding around the model; Cowork primarily occupies the latter, although Felix said it also influences training “a little bit.”
Whether the Code-versus-Cowork optimization gap survives future model generations is unclear. Felix sees “model overhang”: models can do substantially more than current users or harnesses elicit, while carefully engineered corrections may depreciate when the next model generalizes over the behavior without needing elaborate steering.
6. Anthropic increasingly bets on capabilities that survive the next model
Felix’s current inclination is to give Claude as many capabilities as possible, make their failure modes safer, and then “wait a second for the next model drop.” He questions heavy investment in scaffolding that exists only because today’s model fails to infer one desired behavior.
That creates a warning for highly specialized AI applications. Some may deliver striking near-term results because every prompt, tool, and workflow has been tuned to one use case; Felix is unsure how durable that advantage remains once general models handle the same work without such intensive guidance.
Skills illustrate the abstraction shift. A prototype data-analysis interface needed access to Anthropic’s warehouse, but instead of building a custom integration, the team gave Claude a file effectively saying: “Dear Claude, if you want to get data, here’s the endpoint, here’s what the API looks like, you figure it out.”
The Markdown-instruction pattern worked well enough to become a product concept. Rather than prescribing a CLI or MCP interface shape, the team moved one layer higher and described the objective and available access. Skills emerged because the model could take control of the implementation details more reliably than expected.
7. swyx turned a browser chore into a reusable automation system
swyx began cautiously with a laborious Zoom-to-YouTube workflow: manually download recordings, then let Cowork perform the repetitive uploads. Once that worked, he expanded the boundary to include downloading from Zoom, examining video frames, generating titles and show notes, and completing the YouTube submission—“this replaces my job as a YouTuber.”
He then asked Cowork to package the successful process as a skill. When some stages proved useful independently or capable of failing separately, he had it split one skill into three and create a parent skill that orchestrated them. A supervised one-off thereby became a modular, reusable setup without swyx manually authoring the implementation.
The next escalation removed more clicking: Cowork read Google Cloud documentation through Chrome, configured what was needed for programmatic YouTube uploads, and incorporated the resulting script into the skill. The same pattern handled Figma MCP setup and a one-shot attempt at swyx’s conference website.
Felix compared the trust curve to “playing Factorio but for your own life.” Users begin with one tiny automation, observe it working, and add pieces until they have an “automation empire.” Seeing swyx use Claude Opus 4.6, he increasingly advised: “Don’t worry about it anymore. Just tell it what you want it to do.”
8. Small, reversible chores teach users how to delegate larger ones
swyx’s favorite personal routine has Cowork check his calendar each morning for newly created conflicts. Its instructions encode genuinely personal judgment: if Dario schedules over another meeting, prioritize Dario; distinguish meetings worth moving from those worth protecting; and respect swyx’s preferred working hours.
Desktop cleanup became a viral demonstration precisely because it looked trivial. During the live test, Cowork requested folder access, proposed categories, exposed progress, asked how to treat ambiguous files, and kept deletion reversible. swyx’s Downloads folder surfaced multiple term sheets and eight copies of an office lease—prompting, “All right, don’t yell at me.”
The value was not that folder sorting requires frontier intelligence. It gave users a legible, low-risk encounter with planning, questions, corrections, and execution. swyx could say “don’t do that” before approval, see whether the system understood his intent, then widen the assignment once confidence accumulated.
The hosts’ more ambitious examples—signing up for PG&E, navigating Google Cloud, or eventually arranging phone calls through outside providers—followed the same ladder. Cowork’s product task is to move people from asking questions toward assigning increasingly broad work while preserving sensible intervention points.
9. Seeing the application is more important than owning it
Cowork’s tight Claude in Chrome integration avoids asking users to configure “25 MCP connectors” whose permissions and write capabilities vary. Claude can instead work through the same authenticated browser surface, read documentation, operate interfaces, and delegate browser actions to a Chrome sub-agent.
Claude Code’s desktop application offers a built-in browser with similar advantages: Claude can see the rendered product, inspect the DOM, and debug what it created. Felix’s through-line was simple: “Claude is better if it can see what it’s working on,” whether those eyes belong to the user’s Chrome or an embedded browser.
swyx therefore ranks integration with existing browsers above rebuilding one from scratch, and Felix agreed that Anthropic wants to “meet you wherever you are” rather than shrink its market to people willing to switch browsers. When asked why existing Claude Code sessions do not automatically appear in the desktop experience, Felix’s answer was candid: “Excellent question. I don’t have a good answer.”
10. Portable skills are technically just files but socially a documentation problem
Anthropic deliberately made skills file-based: “It’s all just files and folders.” Cowork and Claude Code share a plugin container format, and a GitHub repository can act as a plugin or skills marketplace. That provides real portability today, though Felix acknowledged that explaining GitHub repositories immediately loses much of the nontechnical knowledge-worker audience.
swyx’s counterexample was a visitor-check-in skill living inside another agent harness, Zoe. Changes must be copied back into Cowork, even though he wants personal memory to remain product-specific while skills travel across agents. The hosts’ current answer is essentially shared folders, copying, or symlinks—the mechanics are easy, discovery and synchronization are not.
The unsolved design question is how to combine portable instructions with private context. String interpolation could insert names, phone numbers, preferred folders, employers, or travel policies, but Felix called that clunky. A successful format must preserve the defining advantages: plain text, almost no structure, and instructions written as one would explain the job to a colleague.
Flight booking exposed the distinction. swyx said, “I don’t actually think AI should be booking flights,” and Felix agreed while criticizing flight-booking demos as a default showcase. Price preferences are broadly portable; timing, seats, airports, and work-versus-personal policies are intimate. A neutral “Dropbox of skills” sounds useful, though Felix was unsure it constitutes a viable standalone business.
11. General agents pressure narrow software and the junior labor market
The discussion framed enterprise search as an exposed category: if Cowork performs the work, retrieval from products such as Glean becomes a small intermediate step rather than the purchased outcome. Specialized agents often create value through domain planning and task-specific tools, but improving general harnesses could absorb more of that last mile.
Felix declined to predict which industries disappear, yet his model-overhang argument is directionally clear. Narrow products may be effective today and lose differentiation as models generalize; a startup remains defensible where the customer trusts it to own the task result, not merely where it wraps one temporary planning advantage.
On labor, Felix was less equivocal: Anthropic is “deeply worried” about entry-level employees. The annoying, automatable work senior staff delegate is often exactly the work that gives a junior employee a first job, so celebrating its removal without confronting that pipeline would be dishonest.
Alessio’s half-joking proposal was simulated apprenticeship: compress a distributed-systems lesson that might arise over three months into a one-week project, then repeat until one year carries three years of experience. The exchange recognized that faster training could help, but left unresolved how many junior roles employers would retain.
12. Society may face gradual releases followed by a discontinuous takeoff
Felix offered the pro-young-worker case: newer engineers may have more neuroplasticity, fewer established habits, and more AI-native ways of using coding agents than experienced staff. He then returned to scale: greater adaptability does not determine how many entry-level positions organizations will offer.
Anthropic’s stated concern is that labor-market effects could be sizable and that “people overall are not ready.” Felix did not claim expertise over legal, marketing, or finance employment; he argued economists, governments, and society need a more serious conversation than individual product builders can supply.
swyx suggested that frequent product releases may help users adapt incrementally, but the hosts then questioned whether gradualism lasts. A self-reinforcing “big bang moment” could begin when systems accelerate their own development; the concrete marker was Cowork inspecting TensorBoard, weights and biases, and training models rather than merely supporting human researchers.
swyx would not pin down the timing—perhaps ten years, perhaps one—but argued that the distinction between four and five years matters less than confidence that the transition is coming. If a discontinuity is plausible on either horizon, preparation should begin before the exact date is knowable.
13. Isolation turns agent security from approval theater into engineering
Cowork’s VM has visible costs. swyx cited reports of roughly 12–15 GB, while Felix said macOS’s display is misleading because empty image space is collapsed on disk. Startup is still slower than running Claude Code directly, and Felix readily conceded that the trade-offs are real.
On macOS, Cowork uses Apple’s virtualization framework; on Windows, it uses the Windows Host Compute System underlying WSL 2. Felix praised both, especially Apple’s initially startlingly small API surface, while noting that production code accumulates edge cases around startup, connectivity, and corporate restrictions.
Anthropic is also building networking services and drivers to survive packet inspection and other enterprise configurations. Controlling the network and filesystem lets IT isolate data-loss and exfiltration risks while allowing Claude to write Python freely inside its own computer—even when the employee’s host machine forbids installing Python or Node.js.
The alternative produces “approval exhaustion.” A computer-use system is not meaningfully automated if the user approves every typed character—“it’s not automation if you don’t delegate.” Felix favors layered safeguards, the familiar Swiss cheese model, over products that are “super safe as long as it doesn’t do anything”; engineers already tolerate risks such as npm packages reading
.sshwith full user permissions.
14. Electron, multiplayer agents, and Cowork share one infrastructure bet
Felix’s Windows 95 project emerged from a debate about Electron’s performance: using the v86 emulator, he could run Windows 95 and Excel through JavaScript and WebAssembly faster than many SaaS interactions. He stressed that Fabian, v86’s author, did the difficult emulator work; Felix built the surrounding project in one night.
His defense of bundling Chromium is operational rather than ideological. Native operating-system webviews can only be fixed by upgrading the OS, leaving a Slack-like vendor unable to repair customer-specific rendering failures. Chromium ships its own GPU workarounds, handles broken drivers and video negotiation, and is, in Felix’s words, “one of the marvels of engineering.”
The future test is whether models make Electron unnecessary by generating genuinely native applications. Today they can translate an Electron app into Swift, but Felix does not trust them to preserve correctness while also improving performance and memory use. “We’re not quite there yet” on reproducing the years of hyper-optimization embedded in mature platforms.
Cowork’s roadmap follows the same general-purpose preference: weekly improvements, more computer access, longer independent work, and remote control “coming soon.” For multiplayer, Felix wonders whether agents need a bespoke protocol at all—perhaps they should receive Gmail and Slack identities, leave Google Docs comments, and ask one another for skills. Anthropic Labs remains the place for wilder ideas that are intentionally “quite improbable” and “probably half broken.”