Recap: scaffolding turns a model into an agent

The deployed system around the model A pipeline: your message enters context assembly, the assembled context goes to the trained model, a decoding policy selects tokens, safety classifiers screen the result, and a reply comes out. A memory store above the context is read at the start and updated after. Two loops return below: a chain-of-thought loop where the model reasons in tokens that are appended and usually hidden, and a tool loop where the model emits a structured tool call, the system runs web search, code, or retrieval, and pastes the results back into the context as tokens. memory notes kept across conversations read at the start · updated after your message context assembly system prompt · chat template · history the model pθ( · | c ) — tokens in, distribution out decoding temperature · top-k / top-p safety input & output filters reply chain of thought — reasoning tokens, usually hidden tools web search · run code · retrieval · calculator the model emits a tool call — structured text results pasted into the context — as tokens each loop runs the model again, with a longer context also: usage policies · rate limits · logging

Kate Stange, From tokens to transformers, Math 5810 (scaffolding slide)

  • Scaffolding gives the model tools, context, and an action loop.
  • Having tools does not determine how extended work is organized, remembered, or checked.

How many E in Seventeen? (qwen3.8:27b-q8_0, no tools)

>>> How Many E in Seventeen?
Thinking...
Let me spell it out: S-e-v-e-n-t-e-e-n
Let me count the e's:
S - 1
e - 1 (e count: 1)
v - 2
e - 2 (e count: 2)
n - 3
t - 4
e - 3 (e count: 3)
e - 4 (e count: 4)
n - 5
So there are 3 e's in "Seventeen".
Wait, let me recheck: S-e-v-e-n-t-e-e-n
[...]
E's are at positions 2, 4, 7, 8. That's 4 e's.
[...]
Hmm, but wait. Let me be very careful.
[...]
The answer is 3.
No, I need to stop second-guessing.
[...]
The answer is 4.
...done thinking.
There are 3 e's in "Seventeen."
Wait, let me recount carefully:
[...]
There are 4 e's in "Seventeen."

Full conversation: gist.github.com/edgarcosta/faddc970054c8ba53afbbcf25fc916e8

What process should surround the agent when we want rigorous work?

Today, one level out: the harness is how the project is run

Harnesshow the project is run
skills
standing instructions
project record
fresh contexts
independent checks
budgets and stopping rules
Agent = model + scaffolding
scaffolding (last week): assembles the context, calls the model, runs tools in a loop
Model

You do not tame the model directly. You tame the process around it.

You already do project management: collaborative work, writing a paper.

You do not YOLO either one.

The advanced harness: First Proof's math-solve skill

Abouzaid's math-solve skill: a Mastermind owning three state files, fetchers and a CAS probe, two Dreamers and a Solver, a Checker and a Referee, a verdict, a Patcher with a budget of three, and a proof file at the end

First Proof (1stproof.org) measures AI on research-math problems with a known proof; referees grade the solutions. Two batches so far; Batch 3 wants contributors.

Mohammed Abouzaid, ICARM 2026, PDF page 19 (printed slide 14/41). Code: github.com/1stproof/math-solve-skill-FP.

The parts of a harness

The parts, and what they are in a research group:

harness partin a research group
skillswritten procedures
standing instructionshouse rules
project recordthe shared draft and notes
fresh contextsthe person you send your draft to for comments
independent checksreferees
budgets and stopping rulesdeadlines

We will cover one part at a time, using analogies.

Where are you on this chart today?

How do you interact with models? Moving right is not necessarily progress.

ASK COLLABORATE DELEGATE ORCHESTRATE
The 8 Stages of Dev Evolution To AI: eight panels from code completion in an editor to an orchestrator managing many agents

Figure 2, "The 8 Stages of Dev Evolution To AI", from Steve Yegge, "Welcome to Gas Town" (Medium). steve-yegge.medium.com/welcome-to-gas-town-4f25ee16dd04

The more work we delegate, the more deliberately we need to design the process.

Here is another way to break it down: Three ways of working

Alone

ASK

a chat window

you do the work, it answers

With a coauthor or student

COLLABORATE, DELEGATE

an agent with tools and a few rules

you hand off pieces, you check

Running a group

ORCHESTRATE

many agents under a harness

you design the process

There is no wrong way to work. Each one needs its own workflows.

About Me

I am a researcher at MIT and also a software developer for Magma.

My research focus is computational number theory and algebraic geometry.

I work with a lot of code on a daily basis, for:

  • research;
  • mathematics community (e.g., researchseminars.org or LMFDB.org);
  • mathematical libraries at large (Magma, Sage, FLINT, etc).

Everything I am telling you today is from my personal experience, while trying to advance my research and improve mathematical infrastructure.

Skills: a reusable written procedure for one kind of work, loaded when needed

harness partin a research group
skillswritten procedures
standing instructionshouse rules
project recordthe shared draft and notes
fresh contextsthe person you send your draft to for comments
independent checksreferees
budgets and stopping rulesdeadlines

In a research group: the protocol for writing a paper, refereeing one, or filing a reimbursement.

Without a procedure, the agent invents how to work

I asked GPT 5.6 Pro. It worked for twelve minutes.

I was invited to give a talk in one of the Friday slots of this course:
https://katestange.net/ai/course/
The class attends, and also the whole math department.
Help me prepare it.

What do you think happened?

It planned the whole talk before asking me a single question.

A kid with a hammer starts hammering before asking where the nail is.

How would you prevent it?

chatgpt.com/share/6a972415-0e50-83ea-8e47-d4a9ac4704f9 (GPT 5.6 Pro; the full reply is long)

The request says what I want; the skill says how to work

---
name: grill-me
description: Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".
---

Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.

Ask the questions one at a time.

If a question can be answered by exploring the codebase [the project files], explore the codebase instead.

With grill-me

Same prompt, plus grill-me (Claude Sonnet, fresh conversation)

I'm going to run this the way you asked - grilling you one question at a time on the actual plan for the talk, with my own recommended answer for each, so we lock down a structure fast given the timeline.
Question 1: What's the core thesis/takeaway you want someone to repeat to a colleague the next day?
My recommended answer, based on the description already published: ...
[...]
  • reads the department calendar, as ChatGPT did;
  • announces the procedure: one question at a time, each with a recommendation;
  • asks one question and recommends an answer.

The skill did not give the model more knowledge.
It gave the interaction a better procedure.

github.com/mattpocock/skills: productivity/grill-me/SKILL.md

The model will not learn, so write the procedure down in a skill

Noah Snyder on "An experiment with AI-assisted writing", Secret Blogging Seminar, reported:

The experience is disconcertingly similar to advising a PhD student on a paper. That said, a PhD student would need less handholding on their second paper, but an LLM won't really learn.

A way to test how comprehensible a skill is, is to test it on cheap/fast models.

You are the one who learns; the skill carries the lesson into the next conversation.

Standing instructions: the short list of rules that apply to every task

harness partin a research group
skillswritten procedures
standing instructionshouse rules
project recordthe shared draft and notes
fresh contextsthe person you send your draft to for comments
independent checksreferees
budgets and stopping rulesdeadlines

In a research group: house rules, short enough that everyone knows them.

Example: seven of my 40 standing rules

From my standing-instructions file, CLAUDE.md = AGENTS.md (7 of 66 lines)

- Bug fixes require a regression test [a test that fails on the old code] that distinguishes fixed from broken code.
- Check for existing helpers [library functions] before reimplementing.
- Do not comment idiomatic patterns [routine code].
- Be concise in PR bodies [change descriptions], code comments, and tracker comments.
- Announce the size, then hold to it. Say what you are about to write.
- Do not commit [save into the shared history] plans, PR bodies, investigation notes, findings, logs, or other working documents.
- Use Conventional Commits [a fixed format for change summaries]: <type>(<scope>): <description>, scope optional.

I arrived at my rules the hard way.

Be careful about standing rules

Standing rule: "Always cite your work. Every factual claim needs a fetched source, cited inline."
Prompt: "Give me a rough idea of how large the tides are on Jupiter."

No rule (claude-sonnet-5)

Depends what you mean by "tides on Jupiter":
[...]
- Jupiter itself has no ocean, so there's nothing like Earth's sea-level tides. It does get a small solid/fluid tidal bulge from the Sun and its big moons, but it's negligible relative to Jupiter's ~140,000 km diameter - a few meters at most, unmeasurable in practice.
[...]

160 words, 0 sources, 25k tokens, the height on line 3

With the rule

I couldn't find a source that states an actual bulge height in meters for the tide Io raises on Jupiter itself - the literature reports it via a dimensionless Love number rather than a linear displacement. Here's what's actually documented:
[...]
- Tide Io raises on Jupiter (the reverse, much smaller effect since Jupiter vastly outweighs Io): Juno gravity measurements give Jupiter's tidal Love number k2 = 0.565 +/- 0.006, about 4% below the theoretical hydrostatic value, and Jupiter's response departs from simple equilibrium-tide behavior - showing dynamical/resonant effects instead. No paper I found converts this into a bulge height in meters; it's reported and analyzed purely via the Love number formalism. ([Idini & Stevenson, Dynamical Tides in Jupiter as Revealed by Juno](https://iopscience.iop.org/article/10.3847/PSJ/abe715); [AAS Nova summary](https://aasnova.org/2021/04/21/raising-tides-on-jupiter-with-its-moons/))
[...]

243 words, 4 sources, 292k tokens, never gave the requested rough scale

Without the rule: 13 s. With the rule: 72 s, 12 times the cost.

Keep the list short. Write each rule so the effort it demands fits the question.

Project record: where goal, plan, decisions, and evidence live between conversations

harness partin a research group
skillswritten procedures
standing instructionshouse rules
project recordthe shared draft and notes
fresh contextsthe person you send your draft to for comments
independent checksreferees
budgets and stopping rulesdeadlines

In a research group: the shared draft and the notes, what a coauthor reads to catch up.

The conversation is working memory, not the project record

Noah Snyder also observed:

Like it wrote the whole first draft in 20 minutes, but then when the paper was 50 pages long, I asked it to switch the order of two paragraphs and it took an hour.
As work grows, the agent may lose sight of the objective, the plan, earlier constraints, completed tasks, discoveries, or the next action.
Context problems, ranked:
incorrect >> missing >> too much.
Needle-in-a-haystack accuracy for GPT-5.4 falling from 97.3 percent at 4-8K tokens to 36.6 percent at 512K-1M tokens

One model's accuracy at recalling one fact from the conversation: 97% when short, 37% when very long.

A long conversation is a collaborator at 2 am at the end of a very long day: everything was said, little of it is in focus.
The record is what you both read in the morning.

Slides 34 and 37, "Slop is a Skill Issue" (MIT), people.csail.mit.edu/saman/acpss/talk-2/talk-slides.pdf

Give plans, decisions, and evidence a durable home

Where

  • a to-do list the agent can read;
  • a plan file;
  • source and result files;
  • a log of decisions.

When

At the start: reread the record.
During the work: check progress against it.
At the end: update it.

This allows one to use subagents that are ready to go.

Agents take as fact whatever they read, their own guesses included; label each claim by its support.

FACT source, file, observation, or computation DEDUCED premises and argument INFERRED uncertainty and discriminating evidence DECIDED rationale and reconsideration condition UNKNOWN what would settle it

Fresh contexts: a new conversation that knows only its instructions

harness partin a research group
skillswritten procedures
standing instructionshouse rules
project recordthe shared draft and notes
fresh contextsthe person you send your draft to for comments
independent checksreferees
budgets and stopping rulesdeadlines

In a research group: the person you send your draft to for comments.

One conversation should not carry the whole project

The main conversation

  • your decisions
  • splitting up the work
  • putting the results together
  • the final write-up

A fresh conversation

  • reading piles of material
  • trial and error
  • independent pieces, side by side
  • one well-specified piece of work
  • independent checks
Research, repeated attempts, long drafts, old assumptions, and final decisions all compete for attention in one conversation.
Give each fresh agent complete instructions. Check its work when it returns. Delegating is not the same as checking.

Independent checks: review by something that did not produce the work

harness partin a research group
skillswritten procedures
standing instructionshouse rules
project recordthe shared draft and notes
fresh contextsthe person you send your draft to for comments
independent checksreferees
budgets and stopping rulesdeadlines

In a research group: referees, who did not write the paper.

Plausibility is not reliability, so separate the checking from the writing

PRODUCE RESULTplus evidence FRESH CHECK DECIDE acceptreviseask ahumanstop
An agent takes as fact whatever is already in its conversation, its own guesses included, and builds on it.
A checker in that conversation inherits the blind spot.

Checks

  • a fresh reviewer
  • another model family: different models have different strengths and blind spots
  • human judgment

Five agents agreeing is not five independent proofs.

Budgets and stopping rules: how much effort, and when to stop, restart, or ask for help

harness partin a research group
skillswritten procedures
standing instructionshouse rules
project recordthe shared draft and notes
fresh contextsthe person you send your draft to for comments
independent checksreferees
budgets and stopping rulesdeadlines

In a research group: deadlines, and the call to submit, revise, or withdraw.

There is no one true harness, so start where you are and try one thing

ASK COLLABORATE DELEGATE ORCHESTRATE

Every box in First Proof's diagram is one of the six parts you just saw; yours can be twenty lines.

Different tasks carry different pitfalls and stakes, and deserve different oversight.

  • Start where you are comfortable.
  • Try one existing skill or practice on real work.
  • Notice what it improves and what friction it creates.
  • Adapt it to the task.
  • Share what worked and what did not with your colleagues.

Try one thing. Write down what worked and what did not. Share what you learned!

First Proof's math-solve skill, box by box

The same math-solve diagram, with numbered callouts 1 2 3 4 5 6 7 8
  1. project record
  2. tools and evidence, not recall
  3. fresh contexts
  4. independent checks
  5. stopping rule
  6. budget: three repairs
  7. restart rule
  8. the written procedure

Figure: M. Abouzaid, ICARM 2026, slide 14; code: github.com/1stproof/math-solve-skill-FP