• Artificial Intelligence: A Modern Approach: The broad reference for classical AI, including search, reasoning, planning, learning, and robotics.
• Reinforcement Learning: An Introduction: Sutton and Barto's foundational treatment of reinforcement learning concepts and algorithms.
• Machine Learning Bookcamp: A project-based introduction to building and deploying machine learning systems by Alexey Grigorev.
• Designing Machine Learning Systems: Scalable, maintainable machine learning systems by Chip Huyen.
• AI Engineering: Building applications with foundation models by Chip Huyen.
• Build a Large Language Model from Scratch: Implement transformers in PyTorch with Sebastian Raschka.
• Hands-On Large Language Models: A visual and practical guide by Jay Alammar and Maarten Grootendorst.
• LLM Engineer's Handbook: LLMOps, fine-tuning, serving, and production workflows.
• The 100-Page Language Models Book: A concise, technical introduction by Andriy Burkov.
• Deep Learning: Mathematical foundations by Ian Goodfellow, Yoshua Bengio, and Aaron Courville.
• Deep Learning: Foundations and Concepts: A probability-grounded treatment by Christopher and Hugh Bishop.
• Understanding Deep Learning: Theory, intuition, and practical notebooks by Simon Prince.
• Speech and Language Processing: The continuously updated NLP reference by Dan Jurafsky and James Martin.

• Hugging Face LLM Course: Transformers, fine-tuning, datasets, and modern NLP tooling.
• Full Stack Deep Learning: The full lifecycle of building and shipping AI products.
• Fast.ai Practical Deep Learning: A code-first introduction to deep learning.
• Karpathy's Neural Networks: Zero to Hero: Build neural networks and language models from first principles.
• Stanford CS336: Language Modeling from Scratch: Build language models from data preparation through evaluation and deployment.
• MIT 6.S191: Introduction to Deep Learning: Deep learning foundations and applications.
• Google Generative AI Learning Path: An introductory path through generative AI concepts and Google Cloud tooling.
• DeepLearning.AI Short Courses: Focused courses on current generative AI engineering techniques.
• Made With ML: An open course on designing, developing, deploying, and iterating on production ML systems.

• Attention Is All You Need: Introduced the Transformer architecture.
• Scaling Laws for Neural Language Models: Explored relationships between model performance, data, and compute.
• Training Compute-Optimal Large Language Models: Showed how model size and training data should scale together under a compute budget.
• Language Models are Few-Shot Learners: Demonstrated in-context learning at scale.
• Retrieval-Augmented Generation: Combined parametric language models with external retrieval for knowledge-intensive tasks.
• LoRA: Introduced low-rank adaptation for parameter-efficient model fine-tuning.
• Training Language Models to Follow Instructions with Human Feedback: Established the instruction tuning and RLHF recipe used by InstructGPT.
• ReAct: Combined reasoning traces with actions for tool-using language-model agents.
• Constitutional AI: A method for training helpful and harmless AI assistants using written principles.
• Direct Preference Optimization: Reframed preference alignment as a simple classification objective without explicit reward modelling.

• Building Effective Agents: Anthropic's practical patterns and tradeoffs for agentic systems.
• A Practical Guide to Building Agents: OpenAI's guide to models, tools, instructions, orchestration, and guardrails.

• OpenAI Cookbook: Code examples for structured outputs, tool use, retrieval, evals, and other LLM application patterns.
• Anthropic Prompt Engineering: Techniques for defining success criteria, testing prompts, and improving model behaviour.
• Effective Context Engineering for AI Agents: How to select, structure, and manage the context available to long-running agents.
• 12-Factor Agents: Practical principles for building controllable LLM applications around deterministic software.
• OWASP Top 10 for LLM Applications: Risks and mitigations for developing and deploying generative AI applications.

• Model Context Protocol: The open specification for connecting AI applications to external tools, data sources, prompts, and interactive apps.
• Agent2Agent Protocol: A vendor-neutral specification for agent discovery, task delegation, streaming, asynchronous updates, and cross-platform communication.

• Pydantic AI: Typed agent development built around Pydantic.
• LangGraph: Low-level orchestration for long-running, stateful agents.
• OpenAI Agents SDK: A small SDK for tools, handoffs, guardrails, tracing, and agent orchestration.
• Google Agent Development Kit: Google's framework for developing and evaluating agents.
• Microsoft Agent Framework: Microsoft's successor to AutoGen and Semantic Kernel for agents and graph-based workflows.

• Effective Harnesses for Long-Running Agents: Patterns for agents that make progress across multiple context windows and recover from failure.
• Running Agents: Lifecycle, session, exception, and durable-execution patterns in the OpenAI Agents SDK.
• Human-in-the-Loop: Pause, inspect, approve, reject, and resume tool calls without losing agent state.
• Gemini and Temporal Durable Agent: A concrete implementation of durable execution, retries, and human approval for an agent workflow.

• LlamaIndex: Data ingestion, indexing, retrieval, and agent workflows.
• Haystack: Modular pipelines for retrieval and generative AI applications.
• Docling: Document parsing and conversion for AI applications.

• Demystifying Evals for AI Agents: A practical method for building task suites, graders, transcripts, and evaluation harnesses.
• OpenAI Evals: An open-source framework and registry for evaluating language models and systems.
• Promptfoo: Test cases, assertions, model comparisons, and red-team checks for LLM applications.
• Ragas: Evaluation and experimentation for retrieval and generative AI applications.

• Langfuse: Tracing, evaluation, prompt management, and metrics for LLM applications.
• vLLM: An inference and serving engine for language models.
• LiteLLM: A model gateway and unified interface for multiple model providers.

• FunASR: Speech recognition toolkit with streaming ASR, VAD, punctuation, speaker diarization, and OpenAI-compatible serving for voice AI applications.

Coding agents help developers plan, implement, review, test, and debug software. For independent capability comparisons, see SWE-bench and Terminal-Bench.

• Claude Code: A terminal agent with hooks, subagents, skills, and repository-level instructions.
• Codex CLI: An open-source terminal agent with sandbox and approval controls.
• Gemini CLI: An open-source terminal agent built around Gemini and extensible tools.
• Cursor CLI: A terminal agent connected to Cursor's editor and cloud workflows.
• GitHub Copilot coding agent: An asynchronous agent that works from GitHub issues and opens pull requests.
• Aider: An open-source pair programmer with Git integration and broad model support.
• OpenCode: An open-source, provider-independent terminal agent with a client-server architecture.
• OpenHands: An open-source platform for running software development agents locally or in the cloud.
• Cline: An open-source coding agent available as an editor extension, CLI, and SDK.
• Continue: Open-source coding agents for IDE and CI workflows with source-controlled configuration.

• Harness Engineering: OpenAI's field report on building software with coding agents, repository constraints, automated checks, and human steering.
• Codex Orchestration with Symphony: A reference architecture that turns project work into isolated, observable coding-agent runs.
• How We Built Our Multi-Agent Research System: Production lessons on orchestrator-worker agents, parallel search, evaluation, and operational reliability.