Claude Code & Cowork for Academic Research

01 What's Changed Since February

The February guide was written when Cowork was a two-week-old Max-only research preview. In the ten weeks since, it has shipped several meaningful features, expanded to all paid plans, and — as of April 9, 2026 — reached general availability on macOS and Windows. The core framework of that guide remains sound, but a number of its factual claims are out of date. This section catalogs the changes; subsequent sections are revised throughout.

02 The Premise (Revised)

The February guide framed the division of labor as: Claude Code for building, Cowork for managing. That framing holds. What's changed is Cowork's surface area. It is no longer purely a task-on-demand tool — with scheduled tasks, it is now capable of running autonomously in the background while you are working elsewhere, depositing finished outputs into your project folders on a cadence you define.

For an academic workflow, this opens a genuinely new use case: standing delegations. You describe a weekly task once — compile this week's new working papers in your field from your RSS-connected folder, extract abstracts, update the running literature spreadsheet — and Cowork handles it every Friday without prompting. The filesystem is still the handoff surface. Claude Code still handles everything that compiles or versions. But the temporal structure of the workflow can now be automated rather than manually initiated.

03 Two Tools, One Model

The February guide noted Cowork was "in research preview" and flagged stability concerns. That label no longer applies: on April 9, 2026, Cowork reached general availability on macOS and Windows across all paid plans (Pro, Max, Team, Enterprise). Claude Code remains labeled as a research preview, but Cowork is now a GA product. The GA release also introduced role-based access controls — Team and Enterprise admins can organize users into groups (manually or via SCIM) and assign custom roles that define which Cowork capabilities each group can use, enabling phased rollouts across a department. UPDATED · APR 9

04 The Division of Labor

Claude Code owns anything that compiles, renders, or versions

This has not changed. Quarto → knitr → XeLaTeX pipelines, TikZ diagram iteration, R estimation scripts, git operations — these all belong in Claude Code, which has direct access to your installed toolchain and can run the full edit → compile → inspect → fix cycle in a tight loop. Cowork still cannot access your TeX distribution, R installation, or any other locally installed tool.

Cowork owns the surrounding knowledge work — and now the calendar

Cowork's domain — literature organization, data preparation, document conversion, administrative tasks — is unchanged. What's new is the temporal dimension. Cowork can now own tasks that happen on a schedule, not just tasks you trigger manually. The distinction now has two axes: task type (build vs. manage) and task timing (on-demand vs. recurring).

What Cowork still cannot do

The February guide's core caveat stands: Cowork cannot compile LaTeX, run R scripts, use your Python virtual environments, or access any tool that requires installation on your local machine. Its built-in document skills (docx, xlsx, pptx, pdf) use Python-based generation, which is different from and less powerful than a full XeLaTeX or Quarto build. The Excel and PowerPoint cross-app orchestration is noteworthy but operates within Cowork's own output layer — it cannot read and reprocess an existing Beamer PDF, for instance.

05 Claude Code Workflows

Claude Code's core academic use cases are unchanged. Brief summary for reference; see the February guide for detailed examples.

Beamer Presentations via Quarto

Full Quarto → knitr → XeLaTeX pipeline with your custom Beamer themes, TikZ diagrams, and ggplot2 figures. Claude Code reads error logs, inspects intermediate files, and iterates until compilation succeeds.

R Scripts & Estimation

Writing, executing, and debugging R scripts against your installed packages. Iterating on modelsummary, stargazer, or kableExtra output until tables match journal requirements.

TikZ Diagrams

Iterative compilation of standalone TikZ figures — game trees, DAGs, mechanism diagrams. Claude Code compiles, inspects the PDF output, adjusts, and recompiles.

Git & Version Control

Branching for revisions, resolving coauthor merge conflicts, tagging submission versions, maintaining clean commit histories. Inherently terminal-native.

06 CLI vs Desktop Code Tab

The Claude Desktop app contains a Code tab that runs Claude Code through a graphical interface. The underlying engine is identical to the CLI — same model, same tool access, same CLAUDE.md and settings.json configuration files. The differences are entirely at the interface layer, but they matter for certain workflows.

The worktree parallelism case

The most practically useful Desktop-only capability for academic work is parallel sessions with Git worktrees. When you click "+ New session" in the sidebar, the Desktop app creates an isolated copy of your repository using git worktree, stored under .claude/worktrees/. Each session works on its own branch and cannot interfere with other sessions until you commit.

For a research paper this means you can run a "fix figures" session and a "revise tables" session simultaneously on the same project without manually managing branches. The CLI can achieve something similar, but requires you to set up worktrees yourself and open separate terminal windows.

What stays CLI-only

Scripting and automation remain exclusively CLI territory. The "infinite loop" pattern — while true; do claude "continue implementing..."; sleep 60; done — only works in the terminal. CI/CD pipeline integration, shell hooks, and anything that requires Claude Code to be invoked programmatically from another script are CLI-only. If your workflow involves automating Claude Code itself (rather than using Cowork's built-in scheduling), you need the CLI.

NEW · APR Two recent additions strengthen the scripting story. The --bare flag (v2.1.81) strips Claude Code to its essentials — no hooks, LSP, plugin sync, or skill directory walks — requiring only an API key, which is useful for embedding Claude Code in automated pipelines (claude -p 'summarise today's logs' --bare) without interactive-session overhead. v2.1.89 adds a "defer" permission decision for PreToolUse hooks: a headless session can pause at a sensitive tool call and resume later with --resume, giving scripted workflows finer-grained control over which operations proceed unattended and which wait for human review. A companion PermissionDenied hook fires when auto mode blocks a command and can trigger a retry, and denied commands are now collected under /permissions → Recent for easy re-authorization.

Browser bridging via /remote-control NEW · MARCH 18

A new /remote-control command (currently VSCode only) bridges a Claude Code session to claude.ai/code in the browser, letting you continue from a phone or another device. This partially blurs the CLI vs. Desktop distinction: a session started in the terminal can now be picked up in a browser-based GUI without restarting. For most academic workflows this is a niche feature, but it is useful if you start a long Claude Code task at the office and want to monitor progress from home. The command generates a URL you open in any browser — no additional authentication step beyond your existing Claude login.

Shared configuration

CLAUDE.md, ~/.claude.json, and ~/.claude/settings.json are read by both interfaces. Your permission rules, allowed tools, and project-specific settings carry over automatically. One caveat: MCP servers configured for the Claude Desktop chat app (in claude_desktop_config.json) are separate from Claude Code's MCP configuration — they don't automatically cross over.

Which to use

The cleanest heuristic: use the Desktop Code tab when you want to see what Claude is changing (visual diffs, parallel session overview, context meter) or when you want to run concurrent sessions on the same repo. Use the CLI when you need to script Claude Code, run it unattended, or integrate it into an external pipeline. For the Quarto/XeLaTeX compilation loop that dominates your workflow, either works — the CLI is marginally faster; the Desktop tab gives you better visibility into incremental changes.

07 Cowork Workflows

The following use cases are either new or substantially enhanced since February.

Literature & Source Management ENHANCED

Cowork can now be connected to Google Drive via the new connector, allowing it to pull papers from a shared Drive folder rather than only from local directories. You can set a scheduled task to check a designated Google Scholar Alerts folder weekly, sort new papers by topic, and update a running spreadsheet of relevant literature. The MCP connector for Google Drive covers read and write access.

Data Preparation

Unchanged from February: Cowork takes messy input files — spreadsheets from collaborators, CSVs with inconsistent formatting — and standardizes them into clean inputs for your R pipeline. Now with an added wrinkle: the Microsoft 365 connector means Cowork can read files from OneDrive or SharePoint directly, useful if collaborators are on an MS ecosystem.

Cross-App Excel ↔ PowerPoint Orchestration NEW

Cowork can now run a task that spans Excel and PowerPoint, passing context between them without restarting. Practically: ask Cowork to analyze summary statistics in a spreadsheet and then produce a formatted slide deck from those findings. This is Cowork's own output layer (not your local Office installation), but for producing polished handout-quality documents from numerical inputs, it is genuinely useful.

Document Conversion & Formatting

Still Cowork's strength: taking a compiled Beamer PDF and producing a Word-format handout, a student fill-in-the-blank version, or a PPTX for a seminar organizer. The cross-app feature now makes it easier to go from a Cowork-generated spreadsheet (e.g., summary stats) directly to a Cowork-generated presentation without an intermediate manual step.

Administrative Tasks

Processing course evaluations, organizing student submissions, creating grade spreadsheets. These are well-suited to Cowork's scheduled task feature — set a task to reorganize the submissions folder and update the grade tracker every Sunday, and it runs without prompting.

Gmail & Outlook Integration NEW

Cowork now has connectors for Gmail and Microsoft 365 (Outlook). Practically: you can set a scheduled task to compile all emails tagged with a specific label each week into a summary document — useful for tracking correspondence with coauthors, journal editors, or grant administrators. Review any task involving email carefully before deploying it; Anthropic's safety documentation recommends against giving Cowork broad email permissions.

Cowork Projects NEW · MARCH 20

Projects are Cowork's answer to the "every task starts fresh" limitation. A Project groups related tasks into a dedicated workspace with its own files, instructions, scheduled tasks, and — crucially — scoped memory. Claude retains context from previous tasks within a project and applies it to future tasks in that same project, so a Monday task that summarizes new literature is remembered when a Friday task updates the annotation spreadsheet.

Three ways to create a project: start from scratch, import an existing Claude Chat project, or point at a local folder and add instructions. Each project gets its own instruction set (tone, formatting, domain rules) independent of your global Cowork instructions. Scheduled tasks created inside a project inherit its context automatically.

The limitations are straightforward: projects are desktop-only and stored locally with no cloud sync, no team sharing, and no cross-project memory. Claude Code cannot access Cowork Projects (though Anthropic flags this as planned). For academic workflows, the natural mapping is one project per research paper, one per course, and perhaps one for administrative tasks.

Persistent Agent Thread (Mobile) NEW · MARCH 17

Pro and Max users can now access a persistent agent thread from the Claude mobile app (iOS and Android). This thread retains context across tasks and lets you assign Cowork work remotely — Claude executes on your desktop using local files, connectors, and plugins, then messages back the result. Practically: you can review conference papers on your phone during a flight, then message the persistent thread to reorganize your literature folder when you land, without opening your laptop. The desktop must be awake and the app must be open for execution. This is a research preview and currently limited to a single persistent thread.

08 Scheduled Tasks NEW

This is the most substantive new capability since February, and the one with the most direct implications for an academic workflow. Cowork can now maintain standing delegations — tasks that run on a cadence you define, using any connectors and plugins you have installed, without requiring you to trigger them manually.

How it works

Type /schedule inside any Cowork task. Claude walks you through setup: task name, description, frequency (hourly, daily, weekdays, weekly, custom), working folder, and model. Each scheduled task runs as its own independent Cowork session. Results are deposited to your filesystem when the task completes. You can review output in the task history.

Academic use cases for scheduled tasks

# In Cowork, type:
/schedule

# When prompted, describe the task:
Every Friday at 9am:
- Scan lit/incoming/ for new PDFs added this week
- For each new paper, extract: title, authors, year, abstract, 
  methodology keywords
- Rename files to AuthorYear_ShortTitle.pdf format
- Move to appropriate topic subfolder in lit/sorted/
- Append an entry to lit/literature-log.xlsx with extracted metadata
- Produce lit/weekly-digest.md summarizing new additions

# Set frequency: Weekly, Fridays
# Working folder: ~/research/trade-paper

09 The Plugin & Skills Ecosystem NEW

The February guide mentioned skills (docx, xlsx, pptx, pdf) as Cowork's built-in document creation layer. There is now a more structured ecosystem worth understanding.

Skills vs. Plugins vs. Connectors

Skills are reusable instruction sets that load when relevant — the docx skill, for instance, loads automatically when you ask Cowork to create a Word document. They work across Claude Desktop (Chat, Cowork, and Code tab). Plugins bundle skills, slash commands, and connector configurations into a portable, shareable package. Connectors are MCP integrations with external services (Google Drive, Gmail, etc.).

A new Customize section in Claude Desktop now groups all three in one place.

Plugin marketplace

A public plugin marketplace launched in late February with department-specific plugins (HR, finance, engineering, operations, design). For academic use, the most immediately relevant are plugins that bundle data analysis workflows, literature management patterns, and document formatting commands into a single install.

Slash commands in plugins now launch with structured forms — entering a /generate-report command walks you through a brief rather than requiring you to prompt from scratch. This is useful for standardizing how a lab or research group initiates common tasks.

Custom plugins for your lab

If you are on a Team plan (which now includes Claude Code), you can build a private plugin that encodes your lab's conventions — UGA style guide, file naming standards, data formatting requirements — and distribute it to all lab members. Team admins can auto-install plugins so everyone in the group has the same configuration without individual setup. This replaces the informal "copy my CLAUDE.md" approach with a more robust, version-controlled distribution mechanism.

uga-research-plugin/
├── manifest.json        # Name, description, version
├── skills/
│   ├── uga-beamer/      # Beamer conventions (for documentation)
│   └── data-clean/      # Data standardization workflow
├── commands/
│   └── weekly-digest.md # /weekly-digest slash command
└── connectors.json      # Pre-configured MCP connectors

MCP protocol advances NEW · MARCH 14–19

Two additions to the MCP protocol are worth noting for anyone building or evaluating connectors. First, MCP Channels (research preview, --channels flag in Claude Code) allow MCP servers to push messages into a session rather than waiting to be called. This extends MCP from pure request-response to event-driven patterns — a Google Drive connector could notify Claude when new files appear, rather than requiring a polling scheduled task. As of v2.1.81, the --channels flag also supports a permission relay: channel servers can forward tool-approval prompts to your phone, so you can authorize sensitive actions while away from your desk. This pairs naturally with the persistent agent thread for mobile task management described in §07 — and it deserves caution, since approving a destructive action from a phone screen during a commute is a different risk profile than approving it at your desk. Second, MCP Elicitation lets servers request structured input from users mid-task via interactive dialogs — useful for connectors that need authorization or disambiguation during execution. Both features are primarily relevant if you are building custom MCP integrations or evaluating third-party connectors.

Plugin persistent state NEW · MARCH 17

Plugins can now store persistent state that survives plugin updates via the ${CLAUDE_PLUGIN_DATA} variable. For academic use, this matters most for plugins that maintain cumulative data — a citation manager plugin that builds a database across sessions, or a grading plugin that tracks student progress. When uninstalling a plugin, Claude Code now prompts before deleting its stored data.

10 The Pairing Protocol (Revised)

The fundamental pairing logic from February is unchanged: Cowork prepares inputs and handles outputs; Claude Code handles compilation. What's new is a third mode — scheduled Cowork tasks that run in the background while you work in Claude Code.

Research presentation workflow

Research paper workflow

Course prep workflow

11 Context Management

Claude Code

Unchanged. Use CLAUDE.md for persistent context, /compact when context fills, and session chunking for large projects. The one addition: Claude Code sessions now benefit from context window compaction, which summarizes earlier messages automatically when a conversation approaches limits rather than throwing a hard error.

BUG FIX · APR If you ran long coding sessions on earlier versions and saw unexplained context exhaustion, note that v2.1.89 fixed a bug where nested CLAUDE.md files could be re-injected dozens of times over the course of a session, silently consuming context. Update to the current version and the issue resolves.

Cowork

The February guide recommended folder-specific instructions and global instructions. That remains correct. Two additions:

First, the new Customize section consolidates where you configure these. Skills, plugins, and connectors are now in one place rather than scattered across settings.

Second, Sonnet 4.6 is now the default model for Cowork sessions, which means a 1M token context window is available in beta. For large literature organization tasks — scanning a folder of 200 PDFs and producing a structured database — this is a meaningful capacity increase over the previous default. Switch to Opus 4.6 manually when you need maximum reasoning depth (complex extraction, nuanced synthesis). Note that Opus 4.6 output limits have been raised to 64k tokens default (128k upper bound) — relevant for long-form generation tasks like literature reviews or chapter drafts.

Third, Cowork Projects provide scoped memory. NEW Tasks within the same project share context — Claude remembers what it found and produced in earlier tasks. This changes how you think about context management in Cowork: rather than encoding everything in task instructions, you can rely on accumulated project memory for recurring workflows. Memory does not cross project boundaries, so keep distinct workstreams in separate projects.

For Claude Code, the new /effort command (low / medium / high) gives you per-turn control over how deeply the model thinks. NEW Use low effort for routine operations (file moves, simple reformatting) and high effort when you need careful reasoning (complex R debugging, synthesizing conflicting empirical findings). /effort auto returns to the default.

12 Setup & Configuration

Claude Code (unchanged)

# Install
npm install -g @anthropic-ai/claude-code

# Run in a project directory
cd ~/research/trade-paper
claude

# With explicit model selection
claude --model claude-opus-4-6

Cowork (updated)

Download the Claude Desktop app from claude.com/download. Cowork is now available on both macOS and Windows (x86-64; arm64 Windows not supported). Open the app and click the Cowork tab (labeled "Tasks") next to the Chat tab.

Configure in the new Customize section: global instructions (your identity, role, preferences), folder-specific instructions (project conventions), and any connectors (Google Drive, Gmail, Microsoft 365). Install relevant plugins from the marketplace or upload custom ones.

For scheduled tasks: in the Cowork tab, click "+ New task," type /schedule, and follow the prompts.

Projects (new): In Cowork, create a Project for each major workstream — one per research paper, one per course. You can start from scratch, import a Claude Chat project, or point at an existing local folder. Add project-specific instructions (style, conventions, domain context) and any scheduled tasks. Claude will retain memory across tasks within each project, building cumulative context as your work progresses. NEW

Recommended folder structure (revised)

project/
├── CLAUDE.md              # Claude Code context (build instructions)
├── .cowork-instructions   # Folder instructions for Cowork (style/org)
├── data/
│   ├── raw/               # Original data — Cowork monitors for new files
│   └── clean/             # Processed by Cowork or R
├── R/
│   ├── estimation.R       # Claude Code territory
│   └── style.R            # Shared ggplot2 theme
├── tex/
│   ├── theme.sty          # Custom Beamer theme
│   └── tikz-defs.tex      # TikZ library
├── figures/               # Output from R scripts
├── slides/                # Beamer source + PDF
├── paper/                 # Quarto source + PDF
├── handouts/              # Produced by Cowork (on-demand)
├── lit/
│   ├── incoming/          # Drop zone — Cowork scheduled task monitors this
│   ├── sorted/            # Organized by Cowork
│   └── literature-log.xlsx # Updated by scheduled task
└── weekly-digest.md       # Produced by scheduled task every Friday

MCP Connectors

Connectors are now managed in the Customize section. The new enterprise connectors (Google Drive, Gmail, DocuSign, FactSet, Microsoft 365) require OAuth authorization on first use. For Team and Enterprise plans, admins control which connectors are available to team members — individual users may need to request access.

13 Limitations & Caveats (Updated)

The toolchain wall remains. Cowork still cannot compile LaTeX, run R scripts, or access locally installed tools. This has not changed and is unlikely to change — it is an architectural boundary, not a missing feature. Everything that requires your specific toolchain belongs in Claude Code.

Scheduled tasks require the app to be open. This is a meaningful constraint. Cowork is not a cloud-hosted service — it runs on your machine. If your MacBook is asleep, the task skips. Design scheduled tasks with tolerance for timing slippage; do not depend on them running at exactly 9:00am.

Cross-session memory is now scoped to Projects. REVISED The original guide stated that each Cowork task starts fresh. That is no longer entirely true. If you organize work into a Cowork Project (see §07), Claude retains context from previous tasks within that project and applies it to future tasks in the same project. Memory does not transfer between projects, however, and tasks launched outside of any project still start with a blank slate. Scheduled tasks within a project benefit from this memory automatically. The literature-log.xlsx pattern remains a good belt-and-suspenders approach — explicit output files are more auditable than implicit memory.

Sonnet 4.6 vs. Opus 4.6 default. Cowork now defaults to Sonnet 4.6. For routine file organization and document production, this is fine or better (faster, 1M token context window in beta). For tasks requiring deep reasoning — complex extraction from dense academic papers, nuanced synthesis of conflicting sources — manually switch to Opus 4.6 in the task settings.

Claude Code can hallucinate package APIs. Unchanged from February. Always review generated R or Python code before running consequential analyses. This is a property of LLMs generally, not specific to either tool.

Limited cross-device access; no sharing or cloud sync. REVISED Cowork Projects are stored locally with no cloud sync, no team sharing, and no artifact sharing. However, the persistent agent thread feature (still in research preview on Pro and Max plans as of this update) lets you manage Cowork tasks from the Claude mobile app on iOS and Android — you can assign work from your phone, and Claude executes it on your desktop using local files, connectors, and plugins, then messages back the result. Your desktop must be awake and the Claude Desktop app must be open for execution. This is not full cross-device sync — it is remote delegation to a single machine — but it does address the original limitation of needing to be at your desk to interact with a running task.