AI for scientific discovery: How researchers use Claude

I’ll check what’s actually available on this topic before writing, so the facts land correctly.A scientist running a genomic analysis through Claude Code is likely to generate more tokens than to explain the biology—and the new usage data explains why. In one of the clearest pictures yet of how AI is entering laboratories, Claude sessions devoted to data analysis account for 33.7% of activity in the regular Claude product and 48.1% in Claude Code. Researchers, meanwhile, spend only 27.6% of their time on analysis.

That gap matters. It shows that the value of AI in science is not simply that a chatbot can answer scientific questions. Researchers are using it to inspect datasets, manipulate code, compare results, draft documentation, and move through increasingly technical workflows that used to consume hours of specialist attention.

The latest research-focused release from Anthropic is therefore less a new model announcement than a change in how the company describes Claude: from a general-purpose assistant into infrastructure for scientific work.

The announcement: Claude becomes a research workbench

Anthropic’s recent “AI for scientific discovery: How researchers use Claude” release examines how researchers are applying Claude across the research lifecycle. The significant finding is not that scientists have started prompting an LLM for help. They already did that. The shift is toward connected, tool-using workflows in which Claude works with code, data, documents, and external research systems.

The category breakdown is particularly revealing:

Data analysis is therefore 6.1 percentage points overrepresented in ordinary Claude sessions and 20.5 points overrepresented in Claude Code. Writing and communication also account for substantial use.

That split suggests two different modes of adoption:

• Claude is being used for interactive analysis, literature synthesis, figure preparation, and communication.
• Claude Code is used for longer-running technical tasks: exploring directories, modifying analysis scripts, running tests, interpreting errors, and working across an existing scientific codebase.

The practical lesson is that coding agents are not merely “Claude with a terminal attached.” In scientific settings, the terminal gives the model access to the actual pipeline. It can move from a natural-language request to inspecting a dataframe, correcting a plotting script, checking a test, and explaining what changed.

From answering questions to operating workflows

In practice, the useful unit of AI assistance is no longer a single prompt. It is a workflow with context, tools, and verification.

Consider a basic proteomics analysis. A researcher might ask for a model to:

1. Inspect a CSV containing protein measurements.
2. Remove records with missing values.
3. Normalize expression levels by sample.
4. Compare treated and control groups.
5. Generate a labeled volcano plot.
6. Export a summary suitable for a lab notebook.

A compact implementation could look like this:

import pandas as pd
from scipy import stats

df = pd.read_csv("proteomics_results.csv")

df = df.dropna(
    subset=["protein_id", "control_abundance", "treated_abundance"]
)

df["log2_fold_change"] = (
    df["treated_abundance"].clip(lower=1)
    / df["control_abundance"].clip(lower=1)
).apply(lambda value: pd.Series([value]).pipe(
    lambda series: __import__("numpy").log2(series)
)[0])

control = df["control_abundance"]
treated = df["treated_abundance"]

df["p_value"] = [
    stats.ttest_ind(
        control[df["protein_id"] == protein][0],
        treated[df["protein_id"] == protein][1],
        equal_var=False,
    ).pvalue
    if (
        (df["protein_id"] == protein).sum() >= 4
        and df.loc[df["protein_id"] == protein, "control_abundance"].nunique() > 1
        and df.loc[df["protein_id"] == protein, "treated_abundance"].nunique() > 1
    )
    else float("nan")
    for protein in df["protein_id"].unique()
]

df["minus_log10_p"] = -__import__("numpy").log10(df["p_value"].clip(lower=1e-300))
df.to_csv("proteomics_enriched.csv", index=False)

This is the kind of code that may be acceptable as a draft, but it is exactly where an AI agent can expose weaknesses. It may suggest inappropriate statistical tests, mishandle repeated observations, ignore batch effects, or produce a plot whose axis labeling implies stronger evidence than the data supports.

The gain is speed. The risk is a plausible-looking analysis that crosses the boundary from computational error into scientific error.

Scientific use therefore needs stricter controls than general coding. Generated transformations should be logged, generated code should run in a reproducible environment, and statistical assumptions should be reviewed by a domain expert. The model can accelerate the path to a hypothesis; it cannot validate the hypothesis.

Why developers should care

The direct API implication is that scientific AI applications are becoming workflow systems, not chatbots.

A robust design typically has four layers:

• A model that reasons over the research question and relevant context.
• Tools for searching databases, executing code, plotting, and reading files.
• A research log that captures every action and revision.
• Validation gates that route numerical, biological, and statistical decisions for review.

The request payload might contain a structured task rather than a paragraph of prose:

{
  "objective": "Identify proteins significantly changed after treatment",
  "input_files": [
    "data/proteomics_results.csv",
    "config/normalization.json"
  ],
  "allowed_tools": [
    "read_csv",
    "write_python",
    "run_python",
    "render_plot"
  ],
  "constraints": {
    "multiple_testing": "benjamini_hochberg",
    "fdr_threshold": 0.05,
    "minimum_replicates": 3,
    "do_not_modify_source_data": true
  },
  "deliverables": [
    "analysis.py",
    "protein_significance.csv",
    "volcano_plot.png",
    "methods_summary.md"
  ]
}

The constraints block is more important than the prose prompt. It lets the developer turn institutional requirements—FDR thresholds, replicate counts, forbidden transformations—into machine-checkable boundaries.

Tool calling must also be designed around bounded authority. Reading a local analysis directory and writing to a scratch folder have very different risk profiles. An agent should not be permitted to replace raw data, install arbitrary packages, or publish a result merely because it completed a script successfully.

A common gotcha is treating a tool result as truth. A successful shell command proves that the code ran, not that the science is sound. “No significant proteins found” might mean a real null result—or an indexing mistake.

Choosing the right model

Claude’s current family supports several distinct cost and capability tiers. The relevant choice is not simply “the smartest model.” It is the smallest model that can complete the task without compromising correctness.

The following are useful reference points for the Claude line:

For scientific workloads, Sonnet 5 is often the obvious starting point. Suppose one analysis consumes 80,000 input tokens and produces 6,000 output tokens. At Sonnet 5’s published rate, that run costs:

Input:  80,000 × $2 / 1,000,000  = $0.16
Output:  6,000 × $10 / 1,000,000 = $0.06
Total:                           $0.22

The same call on Fable 5.1 would cost:

Input:  80,000 × $10 / 1,000,000  = $0.80
Output:  6,000 × $50 / 1,000,000 = $0.30
Total:                           $1.10

Across 100 such runs, that is $22 with Sonnet 5 versus $110 with Fable 5.1, before considering caching, batch discounts, or provider-specific rates. This is why a portfolio approach matters: use a smaller model for classification, extraction, and routine chart interpretation; reserve stronger reasoning for ambiguous methods, conflicting evidence, and high-impact decisions.

The alternatives—GPT-6 Astra and GPT-6 Sol, along with Gemini 3—should be evaluated as parts of the same operational problem, not as model leaderboard entries. The decision depends on tool-calling reliability, context behavior, scientific-data handling, latency, regional availability, and total cost. In a multi-model application, route work by measured performance rather than brand reputation.

A practical evaluation set might contain 50 representative tasks scored on:

• Correctness of the scientific transformation.
• Tool-call validity.
• Recovery from errors.
• Citation or provenance discipline.
• Cost and latency.
• Performance on the lab’s actual data format.

For teams that want to compare multiple providers without building every integration from scratch, AI Prime Tech can provide cheaper access to Claude, GPT, and Gemini models through one API. That is useful for routing and controlled evaluation, although the routing layer still needs domain-specific tests and human review.

The real constraint is verification

The new usage pattern does not mean Claude has become an autonomous scientist. The opposite is true. As models become more capable of long-running analysis, verification becomes the bottleneck.

A reliable scientific agent should preserve raw inputs, record tool calls, emit machine-readable results, distinguish sourced facts from generated hypotheses, and expose intermediate state to the researcher. It should also support replay: given the same input snapshot, prompt, model version, and tool versions, the team should be able to reconstruct what happened.

Scientific AI will not succeed because a model produces an impressive summary. It will succeed when the surrounding system makes errors visible, assumptions explicit, and experiments reproducible.

Practical takeaways

• Design around workflows, not chat prompts. Give models tools, structured objectives, and explicit constraints.
• Keep provenance attached to every result. Raw data, code, logs, model version, and generated interpretation should remain connected.
• Route models by task difficulty. Sonnet 5 can handle much of routine scientific analysis; reserve premium models for genuinely ambiguous reasoning.
• Measure cost at the workflow level. A cheap model called 50 times may cost more than one expensive call—and may still be cheaper if it produces reviewable results.
• Test against real scientific failures. Wrong joins, invalid assumptions, and silent unit errors matter more than polished prose.
• Require human approval before irreversible actions. Data deletion, external submissions, and publication decisions should never be autonomous actions.
• Benchmark across Claude, GPT-6, and Gemini 3 using the same harness. The winning provider is the one that performs reliably on your workflow, under your constraints, at an acceptable price.

Claude’s growing role in scientific discovery is significant, but not because it has escaped the laboratory. Its significance comes from entering the messy middle layer between raw evidence and human expertise—the code, literature, transformations, and documentation that make research repeatable. Developers who build that layer well will get more than a faster chatbot. They will get a more capable laboratory instrument.