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 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".
[...]
E's are at positions 2, 4, 7, 8. That's 4 e's.
[...]
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/4619f291cd7e7f7906407aa9cc682717

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: a class project, a paper submission.

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.

Where are you on this chart today?

Locate yourself. Moving right is not progress.

ASK COLLABORATE DELEGATE ORCHESTRATE

The appropriate mode depends on the task, the stakes, your experience, and how much control you want to keep.

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.

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 like First Proof's

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 my research, for the mathematics community (you might know me from researchseminars.org or LMFDB.org), and for mathematical libraries at large.

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

Skills: a written procedure for one kind of work, loaded when that work comes up

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 submitting a paper, refereeing one, or filing a reimbursement.

Without a procedure, the agent invents how to work

I asked ChatGPT to prepare this talk.

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)

Skill: ten lines of prose tell the agent how to work, not what to know

---
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, explore the codebase instead.

A task describes an outcome, not the procedure. This is the procedure.

With grill-me

Same model, same prompt, plus grill-me

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 same site;
  • 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

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.

Noah Snyder, "An experiment with AI-assisted writing", Secret Blogging Seminar, July 29, 2026.

When you write a new skill, test it on a cheap, fast model. It stands in for a frontier model near the end of its context; the skill must work there.

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: four of my 66 standing rules

From my global CLAUDE.md = AGENTS.md (4 of 66 lines)

- Bug fixes require a regression test that distinguishes fixed from broken code.
- Check for existing helpers before reimplementing.
- Announce the size, then hold to it. Say what you are about to write.
- Do not commit plans, PR bodies, investigation notes, findings, logs, or other working documents.

Standing instructions earn their place by recurring across tasks.

I arrived at my rules after many failures.

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

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, 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, no height given

claude-sonnet-5, 2026-09-03. Without the rule: 13 s, 25k tokens. With the rule: 72 s, 292k tokens.

The cost: five times the time, twelve times the tokens, and a reference list. On the tides question the answer itself was lost.

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

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.

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.

Noah Snyder, "An experiment with AI-assisted writing", Secret Blogging Seminar, July 29, 2026.

As work grows, the agent may lose sight of the objective, the plan, earlier constraints, completed tasks, discoveries, or the next action.
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

Slide 34 of "Slop is a Skill Issue: The Engineering around AI Agents", MIT EECS/CSAIL Agentic Coding in Practice Seminar Series, talk 2. Chart source as printed: OpenAI GPT-5.4 eval table, MRCR v2 8-needle, March 5, 2026. people.csail.mit.edu/saman/acpss/talk-2/talk-slides.pdf

Give plans, decisions, and evidence a durable home

Where

  • GitHub issues or another tracker;
  • plan or task files;
  • source and result files;
  • decision logs.

Goal, current state, plan and checks, open tasks, facts and sources, decisions and rationale, open questions, next action.

When

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

Once the state is durable, a fresh agent can resume without inheriting every tangent and failed attempt.

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.

Fresh contexts: a new context that knows only its brief

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 context should not carry the whole project

Main context

  • user decisions;
  • decomposition;
  • synthesis;
  • final communication.

Fresh contexts

  • context-heavy work;
  • trial-and-error loops;
  • parallel subtasks;
  • bounded production;
  • independent checks.
Exploration, trial and error, long outputs, stale assumptions, drafting, implementation, and final decisions compete inside one context.
Brief fully. Verify on return. Do not confuse delegation with verification.

Subagents are not primarily fictional personalities. They are context isolation.

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 checking from production

PRODUCE ARTIFACTplus evidence FRESH CHECK ADJUDICATE acceptreviseescalatestop
Fluent work can hide unsupported facts, missing premises, unforced inferences, and decisions presented as discoveries. Generation and review may share the same blind spot.

Checks

  • deterministic tools;
  • tests;
  • source verification;
  • independent computations;
  • a fresh reviewer;
  • another model family: different models have different strengths and blind spots;
  • human judgment.

Labels

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

Five agents agreeing is not five independent proofs.

Budgets and stopping rules: how much effort, and when to stop, restart, or escalate

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.

Back to the advanced harness: every box answers a failure you saw

The same math-solve diagram, with numbered callouts 1 2 3 4 5 6 7 8

Reproduced from Mohammed Abouzaid, "How do AI systems prove math theorems? First Proof and open-source tools," ICARM 2026, PDF page 19 (printed slide 14/41); annotations added. Code: github.com/1stproof/math-solve-skill-FP.

  1. Mastermind owns dag.json, state.json, log.jsonl: durable state, not a context window
  2. CAS probe and fetchers: exact tools and fetched evidence, not recall
  3. Dreamers and Solver, separate roles: context isolation
  4. Checker and Referee, then verdict: production separated from checking, two independent judges
  5. root correct, proof.md: a stopping condition with an inspectable artifact
  6. Patcher, at most 3: corrective iteration with a budget
  7. strategic-failure back to Dreamer: a restart rule, not endless patching
  8. The skill itself, 2000 lines: an on-demand procedure, written once

Close: there is no one true harness, so start where you are and try one thing

ASK COLLABORATE DELEGATE ORCHESTRATE

There is no preferred position.

Different tasks have different failure modes, stakes, and acceptable levels of control.

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

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

Backup: the reply, top of the page, by GPT 5.6 Pro

The prompt, then ChatGPT's reply: Worked for 12m, Strategic read, and the department calendar listing the speaker's own talk

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

Backup: where each kind of instruction lives

On-demand procedureskill
Standing project ruleAGENTS.md or CLAUDE.md
Changing project stateissue, bead, plan, or artifact
Evidence for a claimsource, computation, test, or result file