Foundation Models & Agentic Science

Your Toolkit

Everything you've built this semester

The Methods You Now Know

The Question

You've learned to build models from data.

What if the model could build itself?

Part I: Foundation Models

Self-supervision, scaling, and emergent capabilities

Self-Supervised Learning

No labels. The data is the supervision.

$p(x_t \mid x_{t-1}, x_{t-2}, \ldots, x_1)$

Training objective: maximize

$\mathcal{L} = \sum_{t=1}^{T} \log p(x_t \mid x_{<t}; \theta)$

Like PCA finds structure without labels, self-supervision discovers patterns in language through prediction alone.

Next-token prediction: each token predicts the next
S. Raschka, "Build an LLM from Scratch"

Pre-training at Scale

Hoffmann et al. (2022) arxiv:2203.15556 · Brown et al. (2020) arxiv:2005.14165

The Transformer

Self-attention: every token attends to every other token.

$\text{Attention}(Q, K, V) = \text{softmax}\!\left(\frac{QK^T}{\sqrt{d_k}}\right)V$

Stack $N$ layers of attention + feed-forward.
Multiple heads learn different relationships in parallel.

Vaswani et al. (2017) "Attention Is All You Need"

Vaswani et al. (2017) arxiv:1706.03762 · 3Blue1Brown: "Attention in transformers, visually explained"

Query, Key, Value

Each input embedding $\mathbf{x}_i \in \mathbb{R}^d$ is projected through three learned matrices:

3Blue1Brown: "Attention in transformers, visually explained" · "How might LLMs store facts"

Scaling Laws

Performance follows power laws in compute, data, and parameters:

$L(C) \propto C^{-\alpha}$

Loss decreases predictably over 7 orders of magnitude of compute.

3 scaling axes:
1. More parameters
2. More data
3. More inference compute (chain-of-thought)

Kaplan et al. (2020) --smooth power laws across 7 orders of magnitude

Kaplan et al. (2020) arxiv:2001.08361 · Hoffmann et al. (2022) arxiv:2203.15556

Adaptation: From Raw Model to Useful Assistant

Brown et al. (2020) arxiv:2005.14165 · Taylor et al. (2022) arxiv:2211.09085

Emergent Capabilities

Wei et al. (2022) arxiv:2206.07682 · Schaeffer et al. (2023) arxiv:2304.15004

Check Your Understanding

Part II: Foundation Models in Science

Proteins, weather, mathematics, and cautionary tales

AlphaFold: Protein Structure Solved

Predicting 3D protein structure from amino acid sequence --a 50-year grand challenge.

AlphaFold 2 (2021): atomic-level accuracy, dominated CASP14.
Nobel Prize in Chemistry 2024.

AlphaFold 3 (2024): diffusion-based. Predicts protein + DNA + RNA + ligand complexes. 50% more accurate than physics-based methods.

AlphaFold 2 architecture (Wikimedia, CC BY-SA)

Jumper et al. (2021) Nature · Abramson et al. (2024) Nature

ESM-3: Generating New Proteins

Hayes et al. (2025) Science · 98B params, Meta FAIR

AI Weather Forecasting

Model	Architecture	Key Result
GraphCast	GNN on mesh	Beats ECMWF at all lead times
GenCast	Diffusion	Beats ENS on 97.2% of targets
Pangu	3D Transformer	First to beat HRES (2023)

GenCast: 15-day global forecast in 8 minutes vs. hours on supercomputers.

Caveat: numerical models still win for record-breaking extremes outside training distribution.

GenCast vs ECMWF ENS scorecard (Price et al. 2024)

Lam et al. (2023) Science · Price et al. (2024) Nature

FunSearch: Provable Mathematical Discovery

Romera-Paredes et al. (2024) Nature · DeepMind

Galactica: A Cautionary Tale

Taylor et al. (2022) arxiv:2211.09085 · Meta AI

The Scorecard

Si et al. (2024) ICLR 2025 · Asai et al. (2024) OpenScholar, Nature · Wang et al. (2023) SciBench, ICLR 2024

Part III: What Is an Agent?

From chatbots to autonomous systems

From Chatbot to Agent

Yang et al. (2025) "From Automation to Autonomy," EMNLP 2025

Agent = LLM + Tools + Memory + Planning

Weng, L. (2023) "LLM Powered Autonomous Agents"

The ReAct Loop

Interleave reasoning and acting:

Thought

→

Action

→

Observation

↑ repeat until task is done

Grounding reasoning in observations prevents hallucination --the model checks its own work.

Yao et al. (2023): Standard vs CoT vs Act vs ReAct

Yao et al. (2023) ICLR 2023

Code: Defining Tools

An agent's tools are just function descriptions the LLM can call:

tools = [
    {
        "name": "run_sindy",
        "description": "Discover governing equations from time-series data",
        "parameters": {
            "data": "array of shape (n_timesteps, n_vars)",
            "library": "polynomial | fourier | custom",
            "threshold": "sparsity cutoff (float)"
        }
    },
    {
        "name": "solve_pinn",
        "description": "Solve a PDE using a physics-informed neural network",
        "parameters": {
            "pde": "equation string, e.g. 'u_t + u*u_x = nu*u_xx'",
            "domain": {"x": [0, 1], "t": [0, 1]},
            "boundary_conditions": "dict of BC specifications"
        }
    }
]
        

Code: The Agent Loop

An agent is just a while loop with an LLM deciding what to do next:

import anthropic
client = anthropic.Anthropic()

memory = []
while not done:
    # 1. Think: LLM reasons about the current state
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        tools=tools,
        messages=memory
    )

    # 2. Act: execute the tool the LLM chose
    tool_call = response.tool_use
    result = execute(tool_call.name, tool_call.input)

    # 3. Observe: feed result back into memory
    memory.append({"role": "assistant", "content": response})
    memory.append({"role": "user", "content": result})
        

From Tool Description to Function Call

The JSON tool definition maps to a real function the agent executes:

{
  "name": "run_sindy",
  "description": "Discover governing
    equations from time-series",
  "parameters": {
    "data": "(n_timesteps, n_vars)",
    "library": "polynomial",
    "threshold": 0.1
  }
}
                

import pysindy as ps

def run_sindy(data, library, threshold):
    lib = ps.PolynomialLibrary(degree=3)
    optimizer = ps.STLSQ(threshold=threshold)
    model = ps.SINDy(
        feature_library=lib,
        optimizer=optimizer
    )
    model.fit(data, t=dt)
    model.print()
    return model.coefficients()
                

Inside a Real Agent: Claude Code

The leaked system prompt reveals how modern coding agents actually work:

# Tools available to the agent:
- Read(file_path)       # read any file
- Edit(file, old, new)  # surgical edits
- Bash(command)          # run shell commands
- Grep(pattern)          # search codebase
- Write(file, content)   # create files
- Agent(prompt)          # spawn sub-agents

# Rules:
- Read before editing
- Don't add features beyond what was asked
- Break work into tasks
- Use the simplest approach first
- Verify your work
                

Prompt Engineering = System Design

What the Claude Code leak teaches us about building agents:

Part IV: From Code to Lab

Mapping coding agents to scientific discovery

Coding Agent → Science Agent

The Shift

Part V: Agentic Science in Practice

From robot scientists to autonomous drug discovery

Timeline of Autonomous Discovery

King et al. (2009) Science · Boiko et al. (2023) Nature · Lu et al. (2024) Nature

ChemCrow: 18 Tools, One Agent

ChemCrow architecture (Bran et al. 2024)

Tools include: molecular search, reaction planning, safety checks, patent lookup, property prediction, retrosynthesis.

Results: autonomously synthesized an insect repellent, 3 organocatalysts, and discovered a novel chromophore.

The LLM is the orchestrator. Domain expertise is in the tools.

Bran et al. (2024) Nature Machine Intelligence

Robin: Multi-Agent Drug Discovery

FutureHouse (2025) arxiv:2505.13400

GPT-5 in the Wet Lab

OpenAI (2025) "Early experiments in accelerating science with GPT-5"

The AI Scientist

Lu et al. (2024) Nature · Porsdam Mann et al. (2025) ACM SIGIR Forum

Check Your Understanding

Part VI: The Scientific Method Is an Agent Loop

And your course is the prompt

The Mapping

Wang et al. (2025) "Exploring the role of LLMs in the scientific method," npj AI

Your Course as a Prompt

If you were designing a science agent's tool kit, you'd give it exactly what you learned:

Part VII: Critical Analysis

What agents can't do, and why it matters

The Hallucination Problem

Asai et al. (2024) Nature · Wang et al. (2023) SciBench, ICLR 2024

"Why LLMs Aren't Scientists Yet"

Trehan (2025): four end-to-end attempts at autonomous ML research. Six failure modes:

Trehan (2025) "Why LLMs Aren't Scientists Yet," Agents4Science

Do LLMs Have "Emotions"?

Anthropic (2026) "Emotion concepts and their function in a large language model" · Full paper

Automatable vs. Needs Human Judgment

Case study: Anthropic supervised Claude through a QCD physics paper in 2 weeks (vs. ~1 year). Expert guidance was essential throughout. "Vibe physics," Anthropic (2025)

Check Your Understanding

Part VIII: Your Role

Domain knowledge is the bottleneck

The Human Edge

What you bring that agents can't (yet):

The Punchline

In the agentic era, everything you learned this semester
becomes more important, not less.

Understanding SINDy, PINNs, neural operators, scaling laws,
failure modes, and inductive biases
is what makes you an effective scientific agent designer.

Key References