Intuition The One Core IdeaA code-generation agent is a machine that writes code, runs it, reads what went wrong, and tries again — a loop, not a one-shot guess. Everything in the parent note is bookkeeping for that loop: symbols to track what code exists now , what happened when we ran it , and how likely we are to eventually get it right .
Before you can read the parent note, you must own every letter it throws at you. The parent assumes you already know what t R C t H t P t A t o t e t p k ( c n ) why the topic can't live without it .
Everything in this topic happens inside one repeating cycle. Look at it once now; every symbol below is just a label on some arrow or box in this picture.
Intuition Read the loop like a storyThe agent stands in a state (what it knows and what code it has written). It perceives that state into a bundle of text called context . It plans and emits an action (usually "here is new code"). The environment executes the action and hands back output and possibly an error . That result becomes part of the new state , and the loop turns again.
Keep this figure in mind. Now we name each part.
t t counting number for loop turns : t = 0 t = 1
Picture: in the loop figure, imagine a small odometer that clicks up by one every time the arrow completes a full circle.
Why the topic needs it: the whole point of an agent is that it changes over time . Without a clock we could not talk about "the code as it was on attempt 2 versus attempt 3." Every other symbol wears t at which turn we mean it.
t t not measure real-world time in seconds. One loop turn might take the agent a fraction of a second or several minutes. t iterations of the loop .
R R task description in plain English (or a spec), like "write a function that checks if a number is prime." It never changes during the loop, so it carries no t
Picture: the sticky note pinned to the top of the whiteboard in the figure — always visible, never rewritten.
Why the topic needs it: the agent must be reminded, on every single turn, what it is trying to do . If R
We meet the action before the code state, because the action is what changes the code, so we cannot describe how code updates until we know what an action is.
A t A t t proposal , like a diff or a snippet the agent hands over. The parent writes how it is chosen as:
A t ∼ LLM ( P t )
∼ LLM ( P t ) distribution over possible next actions, and A t ∼ LLM ( P t ) "A t Run it twice, you might get two different actions. That randomness is exactly why multiple attempts help (Symbol 10).
Picture: the "Planning → Action" arrow in the loop figure; think of a bag of possible next moves, and A t
Common mistake An action is not yet a programA t instruction to change the code ("replace length with len"). It is not the finished program you run. Turning A t Apply
C t C t t C 0 C 1 C 2
Picture: the text file on the screen inside the "State" box. Each turn it may be edited.
C t
C t + 1 = Apply ( C t , A t )
Intuition What "Apply" means in wordsApply old code C t action A t new code C t + 1 A t length with len", then Apply C
c t t c t = C t + 1 = Apply ( C t , A t ) c t t after this turn's edit. Lowercase c "a specific snapshot that was executed" ; uppercase C "the evolving program state." They are the same text at that moment.
Why the topic needs it: an agent that solves whole problems must hold a growing artifact — the program — separate from any single message A t C t c t
This is three symbols that always travel together, so we meet them as a family.
c i o i e i i
c i code that was run on attempt i o i output it printed (what you'd see in the terminal, e.g. 3.0)e i error it threw, if any (e.g. NameError: name 'length' is not defined)
Picture: below shows one such triple as three coloured cards — the code card, the output card, and the error card — clipped together.
Intuition Why record the error, not just the output?A human debugger reads the error message to know what to fix. The agent is the same: e i e i
The subscript i t we use i past attempts ("for each earlier run i t current turn. They are the same kind of counter; i
H t H t collection of all past execution triples up to (but not including) turn t H t = {( c i , o i , e i ) } i < t
Let's decode that notation piece by piece, because it packs three ideas into little marks.
{ ⋯ } i < t
The curly braces { } "the set of."
Inside, ( c i , o i , e i ) one item shape — a triple.
The subscript i < t rule for which items to include : every i t
Read aloud: "the set of all triples ( c i , o i , e i ) i
Picture: in the figure, the logbook is a stack of the clipped cards from Symbol 5 — one card-stack per past attempt.
Intuition The update rule adds thecode that ran , not the raw action
Each turn we drop the fresh triple onto the stack:
H t + 1 = H t ∪ {( c t , o t , e t )} c t not the action A t ( c i , o i , e i ) runs , and a run needs the code that was executed. The raw edit A t c t Apply ∪ union symbol — "add this to the pile." This memory is what separates an agent from a stateless LLM that forgets after each call.
P t P t t P t = [ R , C t , H t , system instructions ]
Intuition The square brackets mean "stack these together"Here [ … ] concatenation — laying pieces of text end to end, like taping four pages into one long scroll. We include the goal R C t H t prompt engineering : deciding what to put in the scroll .
Definition "system instructions" — the standing rules that never changeThis slot holds the fixed policy text that is prepended on every turn, independent of the task. Concretely it is things like: "You are a coding assistant. Only output runnable Python. Never delete tests. If unsure, ask a question instead of guessing." It differs from R R specific job ("make a prime checker"), while system instructions are the house rules that apply to all jobs. Together with safety guardrails, they shape how the agent may act.
Picture: the "Perception → Context" arrow in the loop figure is the machine that packs these four things into the scroll P t
Why the topic needs it: the model can only react to what is in its prompt. P t "what does the agent know this turn?" — and building it well (which of H t retrieval .
o t , e t = Execute ( c t ) Execute runs the current program in a sandbox and returns two things: the output o t e t sandbox is a walled-off playground where running unknown code cannot damage anything real — the safety idea from AI safety .
Intuition The sandbox runs the whole programc t A t A t length for len") is not itself runnable — you cannot execute a diff. So the pipeline is:
A t c t = Apply ( C t , A t ) (Symbol 4) The full resulting program c t o t , e t = Execute ( c t )
The parent's shorthand "Execute ( A t ) A t c t
Picture: the "Action → Execution → State" arrow, drawn as a fenced box (the sandbox) that swallows the program c t o t e t
Why the topic needs it: this is the act half of sense–decide–act. It is what makes the loop grounded in reality instead of the model hallucinating success. It is the concrete use of tool use .
Now we reach the counting. The parent claims:
P ( success in ≤ k attempts ) = 1 − ( 1 − p ) k
Let's earn every letter.
p k P ( ⋯ )
p chance one single attempt works , a number between 0 and 1 (e.g. 0.4 k number of tries the agent is allowed.P ( event ) probability of that event."
The figure shows this curve climbing toward 1 as k reason agents iterate : even a mediocre single-shot rate becomes near-certain with a few tries.
Worked example The parent's numbers, checkedWith p = 0.4
k = 1 1 − 0. 6 1 = 0.40 = 40% k = 3 1 − 0. 6 3 = 1 − 0.216 = 0.784 = 78.4% k = 5 1 − 0. 6 5 = 1 − 0.07776 = 0.92224 ≈ 92.2%
Common mistake "Independent" is a hidden assumptionThe multiply-the-failures trick only works if attempts don't influence each other. Real agents do learn from e t better than p 1 − ( 1 − p ) k
The performance metric uses a new mark:
pass@ k = E [ 1 − ( k n ) ( k n − c ) ] ( valid for k ≤ n )
( k n ) ( k n ) k n ( 2 4 ) = 6
n c E [ ⋅ ]
n total code samples generated for one problem.c how many of them are correct .E [ ⋅ ] expected value , i.e. the average over all problems in the benchmark.
Intuition Why the fraction of "choose" counts?To fail pass@k, you must pick k all wrong . Wrong samples number n − c ( k n − c ) ( k n ) 1
Common mistake You must sample at leastk k ≤ n k ≤ n choose k n k > n ( k n ) = 0 n ≥ k k c ≥ n − k + 1 k ( k n − c ) = 0 1
E [ ⋅ ] each problem j s j = 1 − ( k n − c j ) / ( k n ) that problem's count of correct samples c j E [ ⋅ ] pass@ k = N 1 ∑ j = 1 N s j N "score every problem, then take the mean." That is all the expectation operator asks you to do here.
Why the topic needs it: pass@k benchmarks like HumanEval report agent skill — it rewards exactly the try-several-times behaviour that defines an agent. It links straight to program synthesis evaluation.
P_t assembled prompt plus system rules
Apply gives c_t full program
1 minus one minus p power k
Read top to bottom: the four state pieces feed the prompt, the prompt is sampled into an action A t c t
Test yourself — reveal only after answering aloud.
What does the subscript t The number of turns of the agent loop (turn 0, 1, 2, ...), not real seconds.
Why does R The requirements never change during the loop, so there is no "before/after" version to distinguish.
How is the action A t ∼ It is sampled from the model's distribution LLM ( P t )
What does Apply ( C t , A t ) c t It applies the edit A t C t + 1 c t
Does the sandbox run A t c t It runs the full program c t A t
In H t + 1 = H t ∪ {( c t , o t , e t )} c t A t History items have the shape (code, output, error); a run must record the executed code c t A t c t
What goes in the "system instructions" slot of P t Fixed house rules applied every turn, e.g. "You are a coding assistant, output only runnable Python, ask if unsure" — separate from the task R
Why is ( 1 − p ) k k All k k
Compute 1 − ( 1 − p ) k p = 0.4 k = 3 1 − 0. 6 3 = 1 − 0.216 = 0.784
What is the valid range of k You need k ≤ n k > n ( k n ) = 0 n ≥ k
What does E [ ⋅ ] Over all problems in the benchmark; score each problem separately, then take the plain mean N 1 ∑ j s j
