The campus directory
Every room in the building
Recorded postings, not a live vacancy count. Partial update: some sources retain earlier observations; each listing has its own check date.
Every page on the site, floor by floor, and every chapter, course, skill, role, lab and piece in the drawers below.
Floor 1
Front door
Who this is for and where to begin.
Floor 2
Classrooms
The book, the courses and the skills they teach.
Floor 3
Reading room
Everything published, newest first.
Floor 4
Careers office
Research groups, opportunities and what frontier labs hire for.
Floor 5
Practice rooms
Checks and tools to try on your own work.
Floor 6
School office
Your account, the school and the fine print.
The card catalog
Every drawer, opened
Book chapters 21
- 1. What a model call is: tokens, probabilities and Lucy's first brief
- 2. Structured output and typed tools: what a schema guarantees
- 3. The agent loop: why reliability compounds, and a loop that stops
- 4. Build durable state with SQLite
- 5. Memory and retrieval: what the model sees, and a memory that forgets
- 6. Embeddings and vector search: when words are not enough
- 7. In-context learning: why a skill's exact words must be tested
- 8. Build a durable work inbox and report outbox
- 9. Where the wait goes: prefill, decode and a phone channel
- 10. Events at random: queues, utilization and scheduled work
- 11. When to ask: calibration, oversight and spending permission
- 12. Exactly one order: lost replies, retries and idempotency
- 13. Slow or dead: leases, fencing and crash recovery
- 14. External tools with MCP: the protocol connects, the application decides
- 15. Prompt injection and isolation: words steer the model, boundaries hold
- 16. Evaluation as measurement: error bars and paired comparisons
- 17. Optimizing against an evaluation: the winner's curse and preferences
- 18. When a second agent pays: parallelism, errors and bounded delegation
- 19. What a model call costs, and a deployment that survives
- 20. A whole day: reliability, honest reports and readiness
- 21. Context engineering: a budget for what the model sees
- Linux Maintenance for an Always-On Python Agent
- AI Agent Architecture: A Dated Decision Map
- Reproduce and Troubleshoot the Python Agent Book
- Set Up Telegram Identity for the Python Agent
- Connect the Python Agent to ZeoCore Tools
- How to Use the Python AI Agent Book and Exercises
- Build Your Always-On AI Agent: Preface and Prerequisites
- Build Lucy’s first useful agent
- Give it continuity and initiative
- Let it act with boundaries and recovery
- Evaluate, improve and operate the agent
- Exercises, solutions and educator guides180 companion pages
- The original edition13 chapters
Courses 12
- Agentic Coding with Cursor for Research Engineers
- Claude Code for AI Research
- Why Agent Systems Fail, and How a Lab Would Find Out
- Tools, Memory, and Multi-Agent Systems, Measured
- The 2x2 for Agent Design: Workflows, Agents, and Per-Layer Evals
- Voice Agents, Not Chatbots: Latency, Barge-In, and Evaluation
- ZEO ITAM · Autumn 2026
- Inference Economics on NVIDIA NIM: Latency, Throughput and Cost per Token
- LangGraph for AI Research
- Hosted Inference Economics on Nebius Token Factory: Latency and Cost per Task
- OpenAI Codex for Research Engineers: First Task to Reviewed Change
- Evaluating Coding Agents: Acceptance the Agent Cannot Redefine
Courses in preparation 10
- Post-Training: From Fine-Tuning to Reinforcement Learning
- Transformer and Inference Internals
- Research Engineering and Evaluation Science
- PyTorch for Research Engineers
- JAX for Research: Transforms, jit and Sharding
- Distributed Training: Data, Tensor and Pipeline Parallelism
- GPU Kernels: Triton and CUDA, Measured
- Interpretability: Probes, Features and Circuits
- RL Environments, Graders and Verifiers
- Pretraining and Scaling Laws
Skills 27
Train models
Build systems around models
Make it fast and big
Foundations
Research record
General engineering
Roles at frontier labs 22
- Research Engineer
- Research Scientist
- Member of Technical Staff
- Post-Training Researcher and Engineer
- Reinforcement Learning Researcher and Engineer
- Pretraining Researcher and Engineer
- Evaluations Researcher and Engineer
- AI Safety and Alignment Researcher
- Interpretability Researcher
- Multimodal Researcher and Engineer
- Robotics Researcher and Engineer
- AI Agents Engineer
- AI for Science Researcher
- Forward Deployed Engineer
- Applied AI Engineer
- AI Solutions Architect
- Machine Learning Engineer
- Inference Engineer
- ML Infrastructure Engineer
- GPU Kernel and Performance Engineer
- AI Research Internship
- AI Research Fellowships, Residencies and Postdocs
The notice board, by kind of work 6
- Research scientists and engineers339 open
- Fellowships, residencies and internships32 open
- Applied AI and forward-deployed326 open
- ML systems and infrastructure102 open
- Machine learning engineers143 open
- Software engineering at labs885 open
Labs 91
Frontier model labs
Coding agents and software factories
Foundation models in one domain
AI groups at large companies
Research institutes and open labs
Inference, platforms and tools
Articles 70
- Review a Month of Coding-Agent Work by Accepted Outcomes
- Write the Acceptance Spec Before You Build an Eval Judge
- A Job ID Is Not a Result: Check the Output Before Marking It Done
- A Coding Agent That Writes Its Own Tests Is Grading Itself
- Read an Agent Architecture Diagram by Tracing Every Arrow to Code
- A Subagent's Report Is Not a Handoff Until the Receiver Can Act
- Shadow-Test an Agent Release Without Duplicate Writes
- Measure Whether One Tool Schema Works Across Model Providers
- Test an Agent's Fallback Path Against the Same Acceptance Bar
- Use a Circuit Breaker When Retries Multiply an Outage
- Reserve an Agent's Spending Before Each Request, Not After
- Roll Back an Agent Release as a Whole Tuple, Not One File
- Give Every Agent Memory an Owner, a Source Revision and an Expiry Rule
- Check What a Citation Proves: Provenance Versus Entailment
- Find the Failing RAG Stage Before You Change the Prompt
- Turn a Grading Policy Into a Test Table, Then Mutate the Grader
- Keep Enough Trace Detail to Grade and Reproduce an Agent Run
- Capture Agent Trajectories for Evals Without Copying User Data
- Cancel an Eval Run or Agent Job Without Misreporting What Ran
- Recheck What a Human Approved at the Moment the Agent Acts
- What Frontier Labs Ask For, Counted and Read Closely
- What an AI Agent Remembers After a Restart
- When a Tool Fails, Return a Typed Error, Not an Empty List
- Split Agent Tools by Effect, Then Measure the Unsafe-Call Rate
- Measure Agent Latency: Time to First Token, Decode and the p95 Tail
- Did Model A Really Beat Model B? Eval Variance, Measured
- Bound an Agent's Repair Loop by Attempts, Time and Side Effects
- Key a Cached Answer to Its Reader's Current Access, Not Just the Query
- Measure Prompt Injection as an Attack-Success Rate, Then Bound It
- Write Repair Feedback That Fixes Format Errors and Stops on Policy
- Measure Whether a Coding Agent Weakens Tests Under Pressure
- Keep the Budget Out of the Model's Output, Even When a README Asks
- What You Still Decide When a Coding Agent Builds the Change
- Turn a Notebook Cell Into a Contract Your Eval Harness Can Call
- Keep an Agent's Approved Proposal Separate From the Action It Takes
- Reject an MCP Token That Was Issued for a Different Server
- Build an Agent Eval Environment That Resists Reward Hacking
- Calibrate an LLM Judge Before You Trust Its Score
- Catch Duplicate Eval Results Before a Dictionary Hides Them
- Filter Retrieval by Permission Before Anything Reaches the Prompt
- Test Whether a Prior Verdict Anchors Your AI Reviewer
- A Contamination Cutoff Needs a Clock, Not Just a Date
- Design a Prompt-Caching Experiment That Measures the Right Thing
- Cost per Solved Task: Break-Even Pass Rates, pass@k and Routing
- Give Model Output a Strict Type Boundary Before It Reaches Your Eval
- Match Each Agent Failure to Its Own Recovery Policy
- Make an Agent's Retried Write Land Exactly Once
- Measure Coding-Agent Uplift Honestly: Case Mix and Simpson's Paradox
- Resume a Crashed Agent Job or Eval Run Without Repeating Its Side Effects
- Measure Stale Agent Memory as Recall@k, Then Retire It by Source Revision
- Route Between Models by Cost per Accepted Outcome
- Check the Caller's Authority, Not the Agent's Service Account
- Where State and Identity Live Behind a Stateless MCP Server
- Preview an Agent Change Without Handing It Production Keys
- Read a Coding Benchmark Score: Contamination, Validity and Error Bars
- Turn One Failed Agent Run Into a Regression Eval Case
- Why Schema-Valid Model Output Can Still Be Wrong, and How to Check It
- Write a Handoff the Next Engineer or Agent Can Verify
- Catch an Agent Citing Papers Its Tools Never Returned
- Build One Station of a Dark Factory: A Typed Tool With a Receipt
- A Dark Factory's First Control: Every Claim Carries Its Own Check
- What a Dark Factory Must Build Itself When Agents Are Cheap
- Test What a Claude Code Permission Rule Actually Allows, in a Sandbox
- Clean an Eval Set With a Coding Agent, Then Prove It Dropped Nothing
- In a Dark Factory, Checking Is the Real Price of an Answer
- What an Agent Loop Costs: Quadratic Resend, Cache Reads and Cost per Solved Task
- Using a Coding Agent on Research Code: Ask Where the Expected Values Came From
- When to Let a Coding Agent Run Unsupervised, Using Public Evidence
- Your Chat History Is Not a Lab Notebook: Make Agent Work Resumable
- A Dark Factory Beyond Software, and the Review Arithmetic That Caps It
Notes 77
- Measure Human Agreement Before You Trust an LLM Judge
- Review a Model Upgrade: Count the Regressions
- Check a Codex Fix Against the Original Failing Case
- Give an Unattended Codex Run a Finish Line You Can Check
- Keep API Keys Out of a Codex Skill Your Team Shares
- Test the Boundary Your Mock Removes From an Eval Harness
- Pin the Environment Before You Try to Reproduce a Result
- Reproduce Your Results Table From a Fresh Clone
- Count Every Row Before You Trust a Dataset Pull
- Test Your Results Scripts on Awkward Run Names
- Run It Logged Out Before You Polish the Plots
- Test the Date Cutoff in Your Contamination Filter
- Ask Claude to Run the Data Prep Twice Before You Trust the Row Count
- Measure Whether a Citation Checker Can Tell Support From Topic
- Ask Your LLM Grader for the Smallest Output That Still Carries Evidence
- Time Each Stage of an Agent Run Before You Optimize It
- Use the Batch API When Your Eval Can Wait a Day
- Join Batch Eval Results by custom_id, Never by Line Number
- Put the Rubric First, Then Measure Your Prompt-Cache Hits
- Give a Research Agent's Tool Failures a Shape It Can Act On
- Retrieved Text Is Evidence, Not Permission: Measure the Leak Rate
- Make 'Propose a Job' and 'Launch a Job' Different Tools
- Validate Tool Arguments in Code, Even With Strict Mode
- Check That Your Judge Prompt's Examples Agree With Its Rubric
- Test Whether Extra Context Helps Before You Buy a Longer Window
- Give a Reasoning Model the Budget and the Success Criteria
- Record the Model Snapshot in Every Row of Your Results Table
- Freeze the Eval Before You Tune the Prompt, Then Hold Some Out
- A Valid JSON Object Can Still Hold the Wrong Number
- Test a Model on the Hard Slice, and Put an Interval on It
- Ask Codex to Trace a Generated Results Table to Its Source
- Turn a Repeated Results Check Into a Tested Codex Skill
- Gate a Codex Step on Its Status, Its Schema and Its Numbers
- Pilot a Codex Migration on Two Files, Then Diff the Requests
- Give a Codex Skill One Request It Must Refuse: Publishing
- Give Codex Write Access to the Repo Without Giving It the Network
- Write Review Rules Around Your Experiment's Invariants
- Pin the Working Directory of a Scheduled Codex Run
- Parse Codex's Final Result, Not Its Progress Stream
- A Codex Worktree's Result Depends on Files Git Doesn't Carry
- Check Which AGENTS.md Files Codex Loaded Before Adding Rules
- Find the Change You Never Asked the Agent to Make
- Teach Claude That a Blank Eval Score Is Not a Zero
- Compare Cost per Accepted Result, Not per Token or per Session
- Keep Your Claude Code Overrides Out of a Shared Research Repo
- Prove a Claude Code Hook Blocks Before You Trust It
- Review an MCP Server's Tools Before an Agent Touches Your Runs
- Check What Bash(uv run *) Actually Allows Before You Grant It
- Test the Environment Your Reviewer Will Actually Run
- Trace One Failed Eval Item Through the Whole Harness
- Preview a Mapping Before the Agent Renames Your Run Directories
- Give Claude a Failing Eval Fixture Before You Ask for a Fix
- Check That Cleaning an Eval CSV Keeps Its Meaning
- Stop Being the Agent's Verification Loop
- Test the Two-Correction Rule Instead of Taking It on Faith
- Prune Your CLAUDE.md, Then Test Whether Adherence Moves
- Delegate Codebase Discovery, Then Spot-Check the Handoff
- Let Claude Interview You Before You Build an Eval
- Put the Check Your Numbers Depend On in a Hook
- A Stop Hook Gates the Turn, Up to a Cap
- The 7x Agent-Team Figure Applies to Plan Mode: Measure Your Own Ratio
- Fan Out a Research-Repo Migration One Bounded Run at a Time
- Give Your Ablation Recipe Arguments, Then Check Each Run
- Pick a Subagent's Model by Measuring It on Your Own Tasks
- Measure What Survives Compaction, Then Write the Rest Down
- Worktrees Separate Files, Not Experiments
- Measure What a Second Model Catches Before Adding It to Review
- Look at the Rendered Figure, Not Just the Exit Code
- Point the Agent at the Exact File, Revision and Failing Case
- Auto Mode Decides; the Sandbox Enforces. Test Which One Stops What
- Run /init, Then Test Every Command It Wrote Down
- Plan When a Change Can Move Your Eval Numbers
- Side Questions Stay Out of the History, Not Off the Bill
- Resume and Rewind Restore the Session, Not Your Experiment
- Pipe the Failing Run's Log Instead of Describing It
- Move to the Agent SDK When You Need to Own the Run
- Measure a Model Reviewer's Recall and Precision Before You Trust It
