The mystery model was Z.ai all along →
Learn one thing: Evaluating agents: trajectories, not answers
Every edition, preserved as published.
Formerly Signal & Sense.
Every public edition, preserved as it was published.
Learn one thing: Evaluating agents: trajectories, not answers
Learn one thing: LLM-as-judge and its pitfalls
Learn one thing: Evals 101: golden sets and regression tests
Learn one thing: Computer-use agents
Learn one thing: How coding agents work
Learn one thing: Human-in-the-loop approval gates
Learn one thing: Sub-agents and context isolation
Learn one thing: Multi-agent orchestration patterns
Learn one thing: Workflows vs agents
Learn one thing: Planning and task decomposition
Learn one thing: The agent harness: the scaffolding around the model
Learn one thing: Context compaction and summarization
Learn one thing: Agent memory architectures
Learn one thing: Agent skills
Learn one thing: Model Context Protocol
Learn one thing: Designing tools agents can actually use
Learn one thing: The ReAct pattern
Learn one thing: Grounding and citations
Learn one thing: Long context vs RAG: lost in the middle
Learn one thing: Retrieval vs agent memory
Learn one thing: Context engineering
Learn one thing: Hybrid search and rerankers
Learn one thing: Vector databases and approximate nearest-neighbor search
Learn one thing: Chunking strategies
Learn one thing: Retrieval-augmented generation
Learn one thing: Streaming and perceived latency
Learn one thing: Prompt caching economics
Learn one thing: Function calling: how tool use actually works
Learn one thing: Structured output and constrained decoding
Learn one thing: Chain-of-thought and reasoning traces
Learn one thing: In-context learning and few-shot prompting
Learn one thing: System prompts and message roles
Learn one thing: Quantization: running big models in small memory
Learn one thing: Base models vs instruction-tuned models
Learn one thing: The KV cache
Learn one thing: Temperature, top-p, and why the same prompt gives different answers
Learn one thing: Attention and the transformer, minus the math
Learn one thing: Embeddings and vector similarity
Learn one thing: Context windows
Learn one thing: Tokens and tokenization
Learn one thing: GRPO (Group Relative Policy Optimization)
Learn one thing: Tool permission boundaries
Learn one thing: LLM model routing
Learn one thing: Agent control loops
Learn one thing
A prerequisite-ordered walk through every explainer we've published.
Explain how text becomes tokens (BPE), and why tokens — not words — drive cost, limits, and odd model behavior.
What a context window is, what happens on overflow, and why "bigger" isn't automatically "better".
Builds on: Tokens and tokenization
Meaning-as-vectors, cosine similarity, and what embeddings are (and aren't) good for.
Builds on: Tokens and tokenization
An intuition for how attention mixes information across tokens and why this architecture won.
Builds on: Tokens and tokenization, Embeddings and vector similarity
How next-token sampling works and how the knobs trade determinism vs creativity.
Why long chats get slow and expensive, and how prefix reuse makes repeated context cheap.
Builds on: Attention and the transformer, minus the math, Context windows
What pretraining produces vs what post-training adds, and why "raw" models behave alien.
What 8-bit/4-bit quantization does, quality tradeoffs, and formats like GGUF.
Builds on: Base models vs instruction-tuned models
How system/user/assistant roles are actually assembled into one token stream, and what system prompts can/can't enforce.
Builds on: Context windows
Why examples in the prompt change behavior without training, and when few-shot beats instructions.
Builds on: System prompts and message roles
Why "thinking out loud" improves accuracy, and what reasoning traces are (and whether to trust them).
Builds on: In-context learning and few-shot prompting
How JSON mode / schema enforcement actually constrain sampling, and failure modes.
Builds on: Temperature, top-p, and why the same prompt gives different answers
The request/response loop behind "the model called a tool" — schemas in, arguments out, results back in-context.
Builds on: Structured output and constrained decoding
How providers price cache reads/writes, and how to structure prompts to exploit it.
Builds on: The KV cache
How token streaming works (SSE), and why time-to-first-token beats total time for UX.
Builds on: Temperature, top-p, and why the same prompt gives different answers
The retrieve-then-generate pattern, what it fixes (freshness, grounding) and what it doesn't.
Builds on: Embeddings and vector similarity, Context windows
Why document splitting quietly decides RAG quality; size/overlap/structure-aware tradeoffs.
Builds on: Retrieval-augmented generation
What an ANN index (e.g. HNSW) does, and when you need a vector DB vs a flat file.
Builds on: Embeddings and vector similarity, Retrieval-augmented generation
Why keyword+vector beats either alone, and what a cross-encoder reranker adds.
Builds on: Vector databases and approximate nearest-neighbor search
Assembling the right context (instructions, retrieval, memory, tools) under a token budget — the discipline replacing "prompt engineering".
Builds on: Retrieval-augmented generation, System prompts and message roles
Contrast querying knowledge with maintaining evolving state across sessions.
Builds on: Context engineering
What degrades in million-token contexts and when stuffing beats retrieving.
Builds on: Context windows, Retrieval-augmented generation
How systems tie claims to sources, and why citation ≠ correctness.
Builds on: Retrieval-augmented generation
Interleaving reasoning and acting, and why this simple pattern still underlies most agent frameworks.
Builds on: Chain-of-thought and reasoning traces, Function calling: how tool use actually works
What makes a tool schema learnable — naming, granularity, error messages as prompts.
What MCP standardizes (servers, tools, resources), and what it deliberately doesn't.
Builds on: Designing tools agents can actually use
Short-term vs long-term memory; files, vectors, and summaries as memory substrates.
Builds on: Retrieval vs agent memory
How agents compress transcript history — summarize-and-replace, tool-result clearing — to keep working past the context limit, and what quietly gets lost.
Builds on: Context engineering, Agent memory architectures
What actually surrounds a model in production — system prompt, tool surface, loop logic, compaction policy, permissions — and why the same model scores wildly differently in different harnesses.
Builds on: The ReAct pattern, Designing tools agents can actually use, Context compaction and summarization
How agents split goals into steps; plan-then-execute vs interleaved planning.
Builds on: The ReAct pattern
When a deterministic pipeline beats an autonomous loop, and the cost of unnecessary autonomy.
Builds on: Planning and task decomposition
Orchestrator-worker, handoffs, debate; what coordination actually buys vs costs.
Builds on: Workflows vs agents
Why spawning a fresh-context worker beats one long transcript; token hygiene.
Builds on: Multi-agent orchestration patterns, Context engineering
Where to put approvals in agent flows; reversible vs irreversible actions.
Builds on: Workflows vs agents
The edit-run-test loop, tests-as-reward, and why coding is agents' best-fit domain.
Builds on: The ReAct pattern, Designing tools agents can actually use
Screenshot-act loops, accessibility trees, and why GUI automation is much harder than API tool use.
Builds on: The ReAct pattern
Building a small labeled set and treating prompts/models like code under test.
Builds on: Structured output and constrained decoding
Using models to grade outputs; position bias, self-preference, calibration against humans.
Builds on: Evals 101: golden sets and regression tests