AI Agents Newsletters and Short Courses for 2026

Once you have finished the courses and want a steady feed of what is actually shipping, this is the list of AI agents newsletters and short courses to bookmark. The newsletters cover the pace of the field week to week, the papers, the frameworks, and the engineering postmortems that no course has time for. The short courses cover the narrow skills a working agent builder needs, from retrieval and memory to evaluation and multi-agent orchestration. Together they are the two halves of staying current: a feed you read on the train and a lab you finish in an afternoon.

The list is split into two groups. Six newsletters first, for the ongoing signal. Then thirteen short courses, all of them free, hands-on labs from DeepLearning.AI, ordered roughly by where they fit in an agent stack. It is the companion to the 12-post Learn AI Agents series on this site, where the longer courses are walked through in depth. The Hugging Face Agents Course, which is the flagship of that series, is linked at the end rather than repeated here, since it already has its own full post.

Newsletters: the AI agents newsletters worth a weekly read

Newsletters are how most practitioners keep up, because the field moves faster than any book or course can track. These six are written by people who build, not by content farms. Read them to catch the papers, the framework releases, and the production lessons in near real time, then dig into whatever catches your eye during the week.

• Gradient Ascent (Art of Saience). A weekly newsletter that distills the flood of ML and AI developments into a tight, readable digest without the hype framing. It is the one to subscribe to if you want the week’s signal in the time it takes to drink a coffee, with enough context on each item to know whether it matters to you. Read Gradient Ascent.
• DecodingML (by Paul Iusztin, Substack). A hands-on ML and AI engineering newsletter that walks through real system designs, data pipelines, and LLM application patterns with code, not just opinion. Subscribe when you are past the beginner stage and want to see how production-grade ML systems are actually assembled end to end. Read DecodingML on Substack.
• Deep (Learning) Focus (by Cameron R. Wolfe, Substack). Long-form deep dives into the foundational ML and AI research, written by a practitioner who takes the time to explain the math and the intuition behind a paper rather than summarizing the abstract. It is the newsletter to read when a topic is worth an hour, not a paragraph, and it pairs naturally with the papers roundup in this series. Read Deep (Learning) Focus on Substack.
• NeoSage (by Shivani, blog.neosage.io). A newsletter and blog focused on AI, agents, and the applied ML engineering that sits between research and product. Subscribe for clear, practical writing on agent architecture and the trade-offs you actually face when shipping, written for engineers rather than executives. Read NeoSage.
• Jam with AI (by Shirin and Shantanu, Substack). A newsletter built around building with AI, with a bias toward trying the tools, the models, and the frameworks yourself rather than reading about them. It is a good fit if you learn by doing and want short, actionable posts you can turn into a weekend project. Read Jam with AI on Substack.
• Data Hustle (by Sai, Substack). A newsletter covering data engineering, MLOps, and the data side of building AI systems, the layer that every retrieval-augmented and memory-heavy agent depends on. Read it for the plumbing that the agent loop sits on top of, which most AI content skips entirely. Read Data Hustle on Substack.

Short courses: free, hands-on labs on DeepLearning.AI

The thirteen courses below are all short, free, instructor-led labs from DeepLearning.AI, most of them built with the company whose tool the course teaches. They assume you can write Python and have seen an LLM API call before, and they focus on one skill at a time rather than a full curriculum. Work through them in the order they appear here if you want to build the components of an agent, retrieval and memory first, then evaluation, then multi-agent and tool-use patterns. None of them takes more than a few hours, and all of them leave you with working code.

• MCP with Anthropic (DeepLearning.AI). The course that introduces the Model Context Protocol, the open standard for connecting models to tools and data sources, taught with Anthropic who drive the spec. Take it to understand how the tool-and-context layer is standardizing, which is the piece most agent code is currently rewriting by hand. Take MCP with Anthropic on DeepLearning.AI.
• Building Vector Databases with Pinecone (DeepLearning.AI). A hands-on intro to building applications on a managed vector database, taught with the Pinecone team. It is the practical companion to the RAG survey in the papers roundup, showing how the indexing and retrieval layer is actually wired in code. Take Building Vector Databases with Pinecone.
• Vector Databases from Embeddings to Apps (DeepLearning.AI). Goes deeper than the Pinecone course into how embeddings are produced, stored, and searched, and how to build an application layer on top. Pair it with the Pinecone course if you want the full retrieval picture before tackling RAG. Take Vector Databases from Embeddings to Apps.
• Agent Memory (DeepLearning.AI). Explores treating an LLM as an operating system with a persistent memory, the architecture that lets an agent remember across turns and sessions. It is the course to take once you understand a single agent loop and want it to stop forgetting what it just did. Take the Agent Memory course.
• Building and Evaluating RAG apps (DeepLearning.AI). The advanced retrieval-augmented generation course, covering the techniques that go beyond naive chunk-and-search and, importantly, how to evaluate whether your RAG is actually working. Take it after the two vector database courses, because the evaluation half is what separates a demo from a system you can ship. Take Building and Evaluating RAG apps.
• Building Browser Agents (DeepLearning.AI). A focused course on agents that drive a web browser, the category that turns an LLM into something that can fill a form, scrape a page, or run through a UI flow. It is a good next step once you have tool use down and want agents that act in the messy real world of live websites. Take Building Browser Agents.
• LLMOps (DeepLearning.AI). Covers the operational side of shipping LLM applications, the logging, monitoring, versioning, and deployment practices that production systems need. Take it when your prototype works and you have to keep it working, which is where most agent projects quietly fail. Take the LLMOps short course.
• Evaluating AI Agents (DeepLearning.AI). A course specifically on how to measure whether an agent is doing the right thing, from task-level success rates to the trace and step-level metrics that debug a failing run. It is the single most underrated skill on this list, because an agent you cannot evaluate is an agent you cannot trust. Take Evaluating AI Agents.
• Computer Use with Anthropic (DeepLearning.AI). Walks through building toward agents that use a computer the way a human does, clicking and typing across desktop applications, taught with Anthropic. Take it for the most general form of tool use, where the tool is the whole operating system. Take Computer Use with Anthropic.
• Multi-Agent Use with CrewAI (DeepLearning.AI). A practical course on orchestrating multiple agents that collaborate on a task, built with the CrewAI framework. Take it when a single agent is not enough and you want to split a job across roles, a researcher plus a writer plus a reviewer. Take Multi-Agent Use with CrewAI.
• Improving LLM Accuracy (DeepLearning.AI). Covers the techniques that raise a single model’s accuracy on a task, from better prompting and structured outputs to fine-tuning and guardrails. It is the course to reach for when your agent is shaped right but its individual answers are not reliable enough. Take Improving LLM Accuracy.
• Agent Design Patterns (DeepLearning.AI). Surveys the recurring patterns for building agentic systems, taught with the AutoGen framework. Take it to build a vocabulary for the architectures you keep reinventing, and to see how the patterns from the design-patterns deep dive in this series translate into another framework. Take Agent Design Patterns with AutoGen.
• Multi Agent Systems (DeepLearning.AI). A second CrewAI-taught course, this one focused on the systems-thinking side of running several agents together, with patterns for coordination, handoffs, and shared state. Take it after the first CrewAI course when you are ready to move from two agents talking to a small fleet working as a system. Take Multi Agent Systems with CrewAI.

How to read AI agents newsletters without getting overwhelmed

The fastest way to ruin a good reading habit is to subscribe to all six AI agents newsletters at once and let them pile up. A crowded inbox turns every issue into guilt, and guilt is a poor motivator. The better pattern is to pick two newsletters that cover different rhythms and commit to them for a month. Gradient Ascent and DecodingML are the natural weekly pair if you want a steady cadence and a mix of news and how-to. Deep (Learning) Focus and NeoSage are the natural pair if you would rather read one deep piece a week and skip the chatter. The other AI agents newsletters on this list are still there when you want breadth, but a deliberate two-newsletter starter set keeps the habit intact.

Triage matters as much as selection. Most of these AI agents newsletters publish on a fixed day, so block fifteen minutes on that day, skim the issue, and save one link for a deeper weekend read. The goal is not to absorb every item, it is to notice the patterns that repeat across issues, because those are the patterns worth acting on. If a topic shows up in three different AI agents newsletters over a month, it is probably worth a deeper look. If it shows up once and disappears, it was probably a launch announcement dressed up as a trend.

One caution specific to this format. Newsletters compress and reframe primary sources, and that compression can flatten a nuanced result into a confident headline. When an issue makes a claim that would change how you build, trace it back to the underlying paper or post before you act on it. The best AI agents newsletters link their sources, which makes that trace trivial. The worst hide them behind a summary, which is a sign to read with more skepticism.

Pairing AI agents newsletters with short courses: a 30-day plan

The two formats on this page work best when you interleave them. Newsletters keep your sense of the field current, and short courses force you to actually implement what the newsletters describe. A thirty-day plan that pairs them turns passive reading into a build streak without asking for more than a few hours a week. The structure below assumes roughly three newsletters a week and one short course running in parallel, which is sustainable for most working developers.

• Week 1, read and orient. Subscribe to two of the AI agents newsletters and skim every issue. Pick the one short course that matches what kept appearing in the issues, most likely Evaluating AI Agents or Building and Evaluating RAG apps if you are early in a build.
• Week 2, build the first notebook. Finish the first module of the short course and reproduce it in your own notebook. Keep one AI agents newsletter open in a side tab so you can fact-check any claim the course makes against a current source.
• Week 3, add evaluation. Whatever you built in week 2, wrap it in the evaluation harness from the Evaluating AI Agents course. This is the step most builders skip and most agent projects need.
• Week 4, ship or shelf. Either turn the notebook into a small demo you can show a teammate, or make a deliberate decision to shelve it and start the next course. Either outcome beats an open tab you never return to.

The reason this plan works is that it pairs a low-friction input, the newsletters, with a high-friction output, a working notebook, and it forces the output to happen on a fixed cadence. The AI agents newsletters alone give you a broad sense of the field but no skill. The short courses alone give you a skill but no sense of whether it still matters. Together, over thirty days, they compound into something closer to judgment than either provides on its own.

A note on pacing if thirty days feels tight. The plan above is forgiving by design, because the short courses on DeepLearning.AI are self-paced and run from one to three hours each, and the newsletters arrive whether you read them or not. If a work week blows up, the newsletter backlog is the cheapest thing to defer, just do not let it cross two weeks or it becomes a pile you avoid. The course is the harder thing to pause, because a half-finished notebook loses its context fast, so protect at least one focused session a week for the build. Treat the AI agents newsletters as the warm-up and the short course as the workout, and the plan holds together even on a rough week. The goal across the month is not completion, it is one shipped demo and one habit that survives past day thirty, and those two outcomes are what turn a reading list into actual agent-building capability.

One last note on how to fold this into the wider Iqraa AI Agents track. The newsletters and short courses on this page are the steady input layer, but they sit alongside the longer tutorial posts in the main series, where the same patterns get built out end to end across a full framework like LangGraph or smolagents. A good rhythm is to let the newsletters tell you what is new, let the short courses give you a quick win on a single technique, and then drop into a full series post when you want to ship something real in a specific framework. That three-layer loop, weekly scan, quick lab, deep build, is what keeps the AI agents newsletters from becoming background noise and keeps the longer tutorials grounded in what the field actually cares about this month. Used that way, this whole page becomes the connective tissue of your learning path rather than a list you skim once and forget.

If you only have time to act on part of this list, subscribe to two of the AI agents newsletters, Gradient Ascent for the weekly digest and Deep (Learning) Focus for the deep dives, and take two of the short courses, Evaluating AI Agents and Building and Evaluating RAG apps. Those two courses cover the two skills that most agent builders skip and most agent projects need, how to know the retrieval is right and how to know the agent is right. Everything else on the list fills in around that core.