« Phase 00 README · Warmup · Deep Dive · Principal Deep Dive · Core Contributor · Staff Notes
Phase 00 — Hitchhiker's Guide
The compressed practitioner tour. Read the WARMUP for the derivations; this is the stuff you say in the meeting.
30-second mental model
An agent is an LLM in a loop with tools and memory, where the model picks the next action
at runtime. The model only writes text (proposes); your code does everything real
(executes). That boundary is where all safety and correctness live. Reliability
compounds (0.95^n), so you can only afford a few unverified steps; cost and latency are
engineered, not observed; and the senior move is to use the least-agentic thing that
works — usually a workflow.
The numbers to tattoo on your arm
| Number | Meaning |
|---|---|
0.95 ^ 10 ≈ 0.60 | ten 95%-reliable steps ≈ a 60% agent |
0.90 ^ 7 ≈ 0.48 | at 90%/step you're a coin flip by step 7 |
n_max = ⌊log T / log p⌋ | reliable step budget for target T |
1 - (1-p)^(r+1) | reliability of a retried step (idempotent only) |
ReAct input ≈ (t+o)·n²/2 | quadratic — scratchpad resent every step |
ReWOO input ≈ O(n) | linear — plan once, solve once |
| output tokens | 3–5× the price of input tokens |
$/resolved = $/attempt ÷ success_rate | the real cost |
| design to p95/p99 | the mean is a liar; users live in the tail |
Framework one-liners
- LangGraph = the loop as a
StateGraph(nodes + edges + a persisted state); lets you mix ReAct-style interleaving and plan-execute per node. - OpenAI Agents SDK =
Agent+Runner(the built-in loop) +handoffs+guardrails. - Google ADK =
LlmAgent+Sequential/Parallel/Loopworkflow agents + runners. - All of them are elaborations of
while not done: proposal = model(scratchpad); execute.
War stories
- The 30-step research agent that cost $4/run. Nobody profiled tokens. It was spending 80% of them re-reading its own scratchpad (ReAct quadratic). Switching the gather phase to a plan-execute fan-out cut it 6×.
- The "reliable" invoice agent that failed a quarter-end close. Eight steps at ~0.94 → ~0.61 end-to-end. It was a workflow wearing an agent costume; hard-coding the known path and keeping one LLM call for PDF parsing took it to ~0.98.
- The p50 dashboard that lied. Mean latency 0.7s, everyone happy; p99 was 6s and the biggest customer's requests always hit a cold tool cache. SLOs are set at the tail for a reason.
Vocabulary
Agent (model chooses next action) · Workflow (path fixed in code) · Trust boundary
(propose vs execute) · Scratchpad / transcript (running memory) · Step budget (max_steps)
· ReAct (interleaved reason+act) · ReWOO (plan → execute → solve) · Idempotent
(safe to retry) · p95/p99 (tail latency) · $/resolved task (cost ÷ success).
Beginner mistakes
- Reaching for an autonomous agent when a workflow would do.
- Treating 95%/step as "reliable" and chaining 15 of them.
- Quoting mean latency in a capacity review.
- Assuming the prompt will enforce safety/format/authz.
- Setting
max_stepshigh "just in case" — that just lets a confused agent burn more tokens. - Comparing agents on
$/attemptinstead of$/resolved-task.