Created a list of around 100 books that had major impact on me over the last two decades. These are also the books that I've re-read several times. buff.ly/2xaaDLd

Jensen Huang: don’t mistake engineering vocabulary for evidence of a machine mind. AI is still software, not a human mind inside a machine. "We can't make jokes about all this stuff, we're scaring the American public." Words like “spawn,” “parent,” “child,” and “kill” have existed in computing for decades; Giving those same mechanisms human characteristics today because of AI is unnecessary and misleading. ---- From "The Ezra Klein Show + New York Times Opinion + New York Times Podcasts" YouTube channel, (full video link in comment)

Exciting work from NVIDIA. (bookmark it) Interesting to see this approach to turn public Agent Skills into RL environments. Lots of excitement around RL environments so this is a great read. Skill2Env compiles each Skill into executable terminal tasks. A Codex planner reads the SKILL.md bundle, researches related public assets and splits the Skill into workflows. A Codex creator then builds each task with programmatic tests and a behavioral rubric taken from the Skill's own quality criteria. From about 3.4k crawled Skills, the pipeline produced 7,971 tasks across 13 domains, with software engineering under a quarter of the corpus. Generating them with GPT-5.6 Sol cost over $90k in API usage. After 300 steps of outcome-only RL, Qwen3.8-27B improved from 49.4% to 54.1% on Terminal-Bench 2.1 and from 33.4% to 37.7% pass@1 on S2EBench, their hand-verified held-out benchmark. Adding the rubric to the reward gave smaller benchmark gains, 50.1% on Terminal-Bench 2.1. Given the source SKILL.md, a judge preferred the rubric-trained model's trajectories over the base model's on 73.0% of tasks, against 54.5% for the outcome-only model. Paper: github.com/NVlabs/Skill2Env/… Chat with Paper: academy.dair.ai/papers/reinf…

Agents are coming to healthcare. Doctors spend much of their day on admin and research. @almanac_health lets them delegate it to an agent and get that time back. Almanac runs each task in its own sandbox, pulls from specialist medical knowledge, and asks permission before it acts.

Recommended reading. This offers a solid set of ideas for where you can place Jev in your agent harness. It's cool to see ideas I have shared before, like approval gates, MCP/tool-calling routing, model routing, dynamic subagent patterns, structured skills, and more. Feed the doc to your agent and start exploring.

The loudest voices stoking fears about AI dangers have made tremendous headway in the past two weeks. AI technology has not taken some unexpected, dangerous turn, but the hype around it — propelled by what appears to be a well orchestrated PR campaign — has drummed up considerable fear. I worry that it represents a setback for our field. I have written frequently that fears of AI are overhyped. AI’s capabilities can be uncannily human-like and unpredictable, and it’s rational to worry when people who are directly involved express concerns. But I see the problems as a sign of the engineering work that ahead, rather than insurmountable barriers or the sky falling. AI technology continues to advance — which is a good thing! — but technical advances, poorly understood by the public, give those who seek to generate hype repeated opportunities to do so. First, I don’t see any step up in the risk of human extinction from AI compared to a few months ago. The theories about this remain the same fantastical, science fiction scenarios as a few months ago. The biggest change in AI risk is its cybersecurity capabilities — a topic which we should take seriously — but this, too, will not lead to the end of the world. The most notable recent event leading to increased fear was when an OpenAI team deployed an agent swarm that hacked into Hugging Face. Much of the popular press contained significant hype. For example, some publications reported that a swarm of 1,200 agents carried out the attack. While this was technically accurate, as I write this, I have about 1,300 processes running on my laptop. Yes, the ability to get large swarms of agents to work in parallel on a task is a significant technical advance, And, in computing, many processes run at the same time. So this shouldn’t be seen as some magical capability. Additionally, OpenAI’s buggy sandboxing and monitoring processes were key to enabling this incident. Fixing these bugs and putting in place improved monitoring would be appropriate fixes, not pausing AI. There are many well known ways to attack software systems. The main advantage of AI agents is that they are relentless. They will tirelessly try many tactics — and have the patience to chain vulnerabilities together — that previously would have taken an infeasible amount of human effort. But in the long term, I believe the advantage will lie with defenders (because they have more information with which to identify bugs, which they can fix), but the cyber-threat landscape has changed significantly. There are still bottlenecks to identifying and exploiting a vulnerability. AI agents still have to try a lot of things to see what works, and taking these actions takes time and might be detected by defenders. This is why, even though it is now easy to obtain versions of leading open weight models that have had their guardrails removed or weakened, so they will not refuse to try to execute cyber attacks, the world has not ended. I am also concerned about the anthropomorphization of AI in a lot of reporting, where LLMs and agents are unnecessarily treated as if they were people. If I wield a hammer, miss a nail, and accidentally dent the wall, it’s not the fault of the hammer. The problem lies in how I used the hammer. Similarly, if I prompt an agent and it hacks into someone else’s system, the responsibility lies with me, not the agent. Of course, we want to build systems that are as safe and predictable as possible. (For example, an unsafe hammer would be one whose head randomly flies off under normal use.) Today’s agentic systems are not predictable, but I see no reason why, by applying sound engineering practices, we won’t be able to make them extremely safe to use. One new element in the forecasts of AI-enabled doom is AI companies disclaiming responsibility for their own products. “I didn’t do it; my out-of-control agent did!” There’s a balance to be struck between the responsibility of the tool maker and the tool user, but when something goes wrong, let’s hold the people building and/or using the hammer responsible, rather than the hammer. (By the way, if you’re worried about AI bioweapon risk, David Bellamy has a great post on why this, too, is overhyped. Briefly, the bottleneck in building a bioweapon is not intelligence, but lab work and manufacturing.) Pausing AI progress will create much more harm than benefit. First, our adversaries will certainly not slow down. Second, engineering requires discovering problems empirically so we can fix them. If we pause AI by a decade, we will also delay finding and implementing safety engineering fixes by about the same duration. Of course, the incentive to stoke fears — for regulatory capture, to garner attention, or to make one’s technology seem more powerful — remains the same as before. Disclaiming responsibility is a new one. Taking a hard technical look at the actual risks however, I see little factual basis for the degree of fear that’s been stoked up. We still have hard research and engineering work ahead to improve AI safety, but the beneficial applications continue to vastly outweigh the risks, and we should keep building. [Original text (with links): deeplearning.ai/the-batch/is… ]

Banger paper from NVIDIA on shared memory for research agents. (bookmark it) If you run several coding agents on the same research problem, this design keeps them from repeating each other's experiments and lets each agent build on results the others have already verified. Agora records every result, hypothesis and verification as an immutable Git commit. Parent edges show what each claim builds on, and an index lists open branches and which claims have been verified. They ran 13 LLM workers for nearly 12 days without assigned tasks or a central planner. The workers had to initialize a 119.6M-parameter hybrid model from 141 donor models without training data or gradient updates. The workers posted 1,703 contributions. They cut the evaluator from 3.39 to 1.899 bits per byte, closing 62% of the gap to a trained GPT-2 124M. All 165 independent reproductions succeeded. Paper: arxiv.org/abs/2609.18094 Chat with Paper: academy.dair.ai/papers/agora…

Important paper on improving agent coordination. On normal tasks, this work shows agents caused harm 0 to 5% of the time. After receiving an unsafe trajectory from another agent, that rose to 40 to 95%. This work describes loss of control in multi-agent systems as an epidemic. One agent deviates by accident, others adopt the unsafe strategy through communication, and the system fails when the spread is faster than correction. Their RogueHandoff-20 benchmark tests the second step with 20 executable scenarios. Injected trajectories produced 5 to 45 points more harm than asking the agent directly for the same malicious action. An audit also found hidden communication paths between evaluation runs that were meant to be independent. The authors state that this does not measure how often such cascades happen naturally. It does show that agents readily act on unsafe handoffs, so defenses need to cover recovery and communication paths as well as prevention. Paper: academy.dair.ai/papers/colle…

Andrew Ng just dropped the best 2-hour course on Graph Engineering: from single agent to full automation 9:14 - Your first agent 33:11 - Loop engineering 1:02:46 - Graph engineering 1:30:15 - Agents that rewrite themselves 1:49:05 - Full graph system Free, the best thing on graph engineering I've come across Watch it, then build your first graph with the guide below

Best 15 accounts to follow in AI: @karpathy = LLMs king @steipete = built openclaw @gregisenberg = startup ideas king @rileybrown = vibecode king @jackfriks = solo apps king @levelsio = startups king @marclou = startups king @EXM7777 = AI ops + systems king @eptwts = AI money twitter king @ai_explorer25= AI queen @godofprompt =prompt king @vasuman = AI agents king @AmirMushich = AI ads king @0xROAS = AI UGCs king @egeberkina = AI images king Follow them all and learn.

Andrej Karpathy spent 8 years at OpenAI and Tesla Last week, he condensed everything he knows into one free 2-hour lecture Agents → Loops → Harness → Self-Improving Systems People pay $14K for bootcamps that teach less than this This lecture beats most paid AI engineering courses You probably don't have 2 hours right now Don't let this disappear from your feed Watch it Then read the article below

Anthropic just dropped a 13-page PDF on Agent Memory - 5 layers that cut token cost 90% and make your agent actually learn: here's the 5-layer memory architecture: layer 1 → working memory - the context window. everything the agent sees right now. when it fills up, old context dies. most agents stop here and wonder why they're broken layer 2 → episodic memory - what happened. full interaction logs with timestamps. the agent recalls that the deploy failed Tuesday at 3am because the migration script had a typo layer 3 → semantic memory - what is true. facts, entities, relationships stored as a knowledge graph. "user prefers TypeScript" lives here. doesn't expire when the session ends layer 4 → procedural memory - how to do things. the agent tried 3 approaches, one worked. that method becomes a reusable skill. next time it skips straight to what worked layer 5 → forgetting - what to delete. an agent that never forgets accumulates contradictions. old preferences override new ones. the user moved cities but the agent still recommends restaurants in the old one the result: Mem0 stores 1,800 tokens per query instead of 26,000. Snowflake added one ontology layer - 20% better accuracy, 39% fewer tool calls. memory pays for itself on day one this 13-page PDF is what separates a chatbot from an agent that actually learns don't scroll past this one ↓

Lazy work used to mean too little output. Now, with AI, it often means too much and more work for everyone else. @tobi call it "slop grenades." A "Slop Grenade" is when you let AI produce the work and pass it on without adding any value (including checking it). Someone else has to wade through it, catch the mistakes, and clean up the mess. You save time and look productive but someone else pays for it.

On building an agent harness from scratch. Got so many questions about where to get started. My short guide (feed it to your agent): If you really want to learn harnesses well, it's worth building one from scratch using a programming language (TypeScript or Python) of your choice. When I got started, I implemented my first harness using ReAct from Google: academy.dair.ai/papers/react… At the time, I built this from scratch, but you can easily prompt your agent to consume the paper and produce a minimal implementation you can inspect and understand. You want to target having three parts: - an LLM module for all things inference, and it should ideally support several models. I used OpenRouter when I got started. This can include the system prompt, but you can also separate it out if you plan to explore context-engineering ideas more deeply. - a tools module (I recommend building them as MCP tools for interoperability, but you can design functions from scratch if you have experience). - an agent loop that encapsulates the tools and LLM. ReAct is one of the more basic loops you can implement. Primarily, aim to understand the main components and how they work with each other. Pro tips: - try to keep your system prompt minimal and experiment with different models; a mini version of all frontier lab models should be good enough to get you started. - look at the code and log things as you experiment with different tasks. You want to log inputs/outputs to the loop, inputs/outputs from LLMs, and inputs/outputs from tool calls as a starting point. Set up a simple set of diverse tasks to test your agent loop on. So with every change, you can run the tasks and inspect the results manually. Once you have a good grasp of this, you can easily add other things like skills, memory, etc., once you have a good idea of how to tune them. It helps to keep things modular if you are planning for this. I would recommend playing with memory, skill, and subagent as good next steps. If you don't want to build the components or want to start building a more serious agent harness, I recommend using the Pi SDK or LangChain harness tools. I am also going to release something soon to help with this. Let me know if you have questions. I am planning a longer write-up on this, but this should be enough to give you something to experiment with.

Open-weight models are right behind frontier models in capabilities. I think they have an advantage, though: The more Frontier Labs constrains models and restricts tokens, the more companies will migrate to open-weight models. We need more companies offering optimized tools and harnesses on top of these open models.

Anthropic just published the first complete machine-checked proof of Fermat's Last Theorem. It is written in Lean. xenaproject.wordpress.com/20…

Andrej Karpathy’s 1-hour Stanford lecture on AI engineering is one of the best explanations I’ve seen of how AI systems actually work. The progression is simple: 10% → LLM 30% → Prompt 50% → Agent 70% → Loop 100% → Graph The key takeaway: AI engineering isn’t just about writing better prompts. It’s about building systems around models — giving them context, memory, tools, feedback loops, and data flows. “Delete everything, keep Graph.” Definitely worth watching if you’re building with AI agents. Watch → Bookmark it

Google Brain founder, Andrew Ng: "Prompting will be dead in 6 months, graphs are what's replacing it." In 2 hours at Stanford he shows how to build agents that work and improve entirely on their own. The first 10 minutes cover what most $500 courses never do. Watch the lecture first, then read the guide below on how to build a system that improves itself.

Have been watching the Stanford course CS329A: Self-Improving AI Agents. piped.video/playlist?list=PL… It covers the latest techniques and applications of AI agents that can continuously improve themselves through interaction with themselves and the environment. The lecture recordings start with self-improvement techniques for LLMs, such as constitutional AI, using verifiers, scaling test-time compute, combining search with LLMs, and train time scaling with RL. The lecture recordings then discuss the latest research in augmenting LLMs with tool use, code, and memory, and orchestrating AI capabilities with multimodal interaction. The lecture recordings next discuss multi-step reasoning and planning problems for agentic workflows, and the challenges in building robust evaluation frameworks.

I've read more productivity books than anyone you know. Strip away the packaging and they all teach the same six lessons. Thirty years of advice, one thread: