San Francisco, CA
Joined September 2014
Debstep retweeted
You wanna learn how do these AI kernels work? Start here
8
26
287
35,575
Google. Amazon. Microsoft. Netflix. 300+ real ML system design case studies from ~80 companies. I found a repo that breaks down how production ML systems are actually built, not the toy examples. The real ones. If you're serious about ML, data, or engineering leadership, studying why systems were designed a certain way is one of the highest-ROI skills you can develop. Save it. Learn. Repost. Link in next tweet. 🧵
4
40
2
247
9,974
Inference optimizations I’d study if I wanted sub-second LLM responses: Bookmark this. 1.KV-Caching 2.Speculative Decoding 3.FlashAttention 4.PagedAttention 5.Batch Inference 6.Early Exit Decoding 7.Parallel Decoding 8.Mixed Precision Inference 9.Quantized Kernels 10.Tensor Parallelism 11.Pipeline Parallelism 12.Sequence Parallelism 13.Graph Optimization (ONNX, TensorRT) 14.Dynamic Batching 15.Memory Offloading 16.Streaming Generation
22
185
6
1,366
51,994
11 sources to master AI agents and agentic reasoning ▪️ Agentic Reasoning for LLLMs ▪️ Agent Skills for LLMs: Architecture, Acquisition, Security, and the Path Forward ▪️ The Landscape of Agentic Reinforcement Learning for LLMs ▪️ Toward Efficient Agents: Memory, Tool learning, and Planning ▪️ Memory for Autonomous LLM Agents ▪️ A practical guide to building agents (by OpenAI) ▪️ AI Agent Systems: Architectures, Applications, and Evaluation ▪️ Making Sense of AI Agents Hype ▪️ Agent-as-a-Judge ▪️ Towards Trustworthy Agentic AI ▪️ The Attack and Defense Landscape of Agentic AI Save it for later and check out this reading list with all the links -> turingpost.com/p/sources-to-…
6
26
114
7,705
Hermes Mixture of Agents (MoA) explained. Every agent commits to a single model, and every model has blind spots the others would have caught. The usual workaround is to run the same prompt through a few models by hand and reconcile the answers. It works, but it lives outside the agent, so the tools, the memory, and the session are gone the moment that detour starts. Hermes Agent by Nous Research just shipped Mixture of Agents, which folds that whole process back inside the agent. The unit you work with is a preset. Think of it as a recipe that names a few models to consult and one model to write the final answer, saved under a label you can reuse. So a preset might list GPT-5.5 and DeepSeek as the models to consult, with Opus as the one that replies. You set it up once, give it a name, and pick it later like any other model. The models you consult run first and quietly hand their analysis to the one writing the answer. That final model is the one that actually replies and makes the tool calls, now informed by several perspectives instead of one. Here is the part that makes it click. The preset shows up as a model, not as a framework to wire together. So everything that already works in Hermes keeps working. Tool calls, follow-up iterations, memory, and the same session context behave exactly as they do with a single model, because to the agent loop it is a single model. The models can come from anywhere. One preset can mix OpenAI, Anthropic, DeepSeek, and Google, and it is not capped at two. A few things follow from that design. → It composes a model instead of choosing one. Several models covering each other's blind spots can beat the strongest one on its own. → It stays cheap to run. The models you consult see a stripped-down view of the conversation, so the extra calls stay light and the main context keeps its cache. → It reaches past any single frontier model. Combining the providers already on hand assembles a composite that can outscore the best one available alone. → It is a dial, not a default. It turns on for the hard ten percent of tasks where a second opinion matters, and stays off for routine work where speed wins. Nous reports the effect on its own benchmark. A preset running Opus-4.8 over a GPT-5.5 reference scored higher than either model alone, by roughly six points and eight to eleven percent. The lesson is not that one model has to win. It is that the best answer rarely comes from a single model, and the agent should make blending them as easy as picking one. That said, if you're looking to set up Hermes, I wrote a full deep dive covering the Hermes agent's architecture, memory system, self-evolving skills, GEPA optimization, and how to set up multiple specialized agents. The article is quoted below. You can also watch my YouTube crash course on the Hermes agent: youtube.com/watch?v=bNp6YcKB…
34
128
12
883
88,255
Debstep retweeted
Ex-Google engineer explained AI agent loops, harness, evals in 20 minutes - better than 500$ courses. trace every run → judge it with an LLM → diagnose → fix → ship. That loop is how agents self-improve over time. Agent loops + memory + harness + evals - thats the stack. Watch it, then save the framework below.
102
708
16
4,504
567,885
Debstep retweeted
Fascinating paper on self-improving agents. (bookmark it) If you are working on agentic loops, you will quickly realize that they are only as good as the effectiveness of the evaluator. Self-improvement loops tend to stall the moment the judge stops getting harder. The agent learns to satisfy a fixed evaluator rather than getting genuinely better. The Red Queen Gödel Machine, from Cambridge, co-evolves the agent and its evaluator together, so the bar keeps rising as the agent climbs. The name borrows the evolutionary arms race. Both sides have to keep running to stay in place. A frozen evaluator is where reward hacking creeps into self-improvement. Co-evolving the judge is a structural answer to that, and it keeps the loop honest over many rounds. Paper: arxiv.org/abs/2606.26294 Learn to build effective AI agents in our academy: academy.dair.ai/
39
68
9
544
53,384
Debstep retweeted
This might be the most dangerous 37 pages in AI right now. Cambridge and NVIDIA just dropped the blueprint for agents that improve themselves, with no human in the loop. This is the leap every lab is racing toward: an AI that rewrites itself and gets sharper every run. Bookmark it before it's everywhere. Loop engineering guide below.
29
158
5
923
93,513
Debstep retweeted
A senior Google engineer just dropped a 19-page PDF on "Loop Engineering" for LLM and agentic systems. Act -> Observe -> Learn -> Repeat Act: the LLM proposes a code transformation (tile this loop, parallelize that one). Observe: a compiler runs it and reports back - is it valid? faster? slower? by how much? Learn: the LLM reads that feedback and adjusts its next move. Repeat until it stops finding improvements. The agent gets smarter purely from grounded feedback inside its own context window. This 19-page PDF totally changed the way I’m building agentic systems today. Read it now, then explore the article below.
10
22
157
16,450
Stop wasting hours trying to learn AI. I have already done it for you. With one list. Zero confusion. And no fluff. 📹 Videos: 1. LLM Introduction: lnkd.in/dMqbaZdK 2. LLMs from Scratch: lnkd.in/dYYwEhYy 3. Agentic AI Overview (Stanford): lnkd.in/dArmMt2i 4. Building and Evaluating Agents: lnkd.in/dBWd2W8u 5. Building Effective Agents: lnkd.in/dHfdebqw 6. Building Agents with MCP: lnkd.in/dXuNHrRJ 7. Building an Agent from Scratch: lnkd.in/da3ANw3w 8. Philo Agents: lnkd.in/dq-BfZE5 🗂️ Repos 1. GenAI Agents: lnkd.in/d3UDtwwv 2. Microsoft's AI Agents for Beginners: lnkd.in/dHvTmJnv 3. Prompt Engineering Guide: lnkd.in/gJjGbxQr 4. Hands-On Large Language Models: lnkd.in/dxaVF86w 5. AI Agents for Beginners: lnkd.in/dHvTmJnv 6. GenAI Agents: lnkd.in/dEt72MEy 7. Made with ML: lnkd.in/d2dMACMj 8. Hands-On AI Engineering: lnkd.in/dgQtRyk7 9. Awesome Generative AI Guide: lnkd.in/dJ8gxp3a 10. Designing Machine Learning Systems: lnkd.in/dEx8sQJK 11. Machine Learning for Beginners from Microsoft: lnkd.in/dBj3BAEY 12. LLM Course: lnkd.in/diZgGACG 🗺️ Guides 1. Google's Agent Whitepaper: lnkd.in/gFvCfbSN 2. Google's Agent Companion: lnkd.in/gfmCrgAH 3. Building Effective Agents by Anthropic: lnkd.in/gRWKANS4 4. Claude Code Best Agentic Coding practices: lnkd.in/gs99zyCf 5. OpenAI's Practical Guide to Building Agents: lnkd.in/guRfXsFK 📚 Books: 1. Understanding Deep Learning: lnkd.in/dgcB68Qt 2. Building an LLM from Scratch: lnkd.in/g2YGbnWS 3. The LLM Engineering Handbook: lnkd.in/gWUT2EXe 4. AI Agents: The Definitive Guide - Nicole Koenigstein: lnkd.in/dJ9wFNMD 5. Building Applications with AI Agents - Michael Albada: lnkd.in/dSs8srk5 6. AI Agents with MCP - Kyle Stratis: lnkd.in/dR22bEiZ 7. AI Engineering: lnkd.in/gi-mQcXa 📜 Papers 1. ReAct: lnkd.in/gRBH3ZRq 2. Generative Agents: lnkd.in/gsDCUsWm 3. Toolformer: lnkd.in/gyzrege6 4. Chain-of-Thought Prompting: lnkd.in/gaK5CXzD 🧑🏫 Courses: 1. HuggingFace's Agent Course: lnkd.in/gmTftTXV 2. MCP with Anthropic: lnkd.in/geffcwdq 3. Building Vector Databases with Pinecone: lnkd.in/gCS4sd7Y 4. Vector Databases from Embeddings to Apps: lnkd.in/gm9HR6_2 5. Agent Memory: lnkd.in/gNFpC542 👇 Comment “AI” for more resources Repost for your network ♻️ Bookmark for future.
10
50
174
7,128
Debstep retweeted
A Architect Anthropic engineer just dropped a 22-page PDF on "Loop Design and Optimization" for LLMs and agentic systems. Paper that quietly changes how coding agents should optimize code. Instead of: Prompt → Code the paper proposes: Retrieve → Optimize → Verify → Benchmark → Repeat The model learns from previous optimization examples, compiler feedback, and performance measurements instead of generating everything from scratch. Research it now, then read the article below.
23
16
2
150
18,046
A senior engineer at Anthropic just published an 11-page paper on Loop Engineering—and it fundamentally changes how I think about building agentic systems. The core idea: Stop prompting agents. Start building systems that prompt agents. The most reliable autonomous systems aren't powered by better prompts. They're powered by better loops. The framework is surprisingly simple: Schedule → Discover → Build → Verify → Repeat Each cycle consists of five critical steps: 1. Discovery The agent finds its own work by inspecting project reality: failing CI runs, open issues, recent commits, test results, and repository state. No manually curated task queue required. 2. Handoff Every task receives its own isolated git worktree, allowing multiple agents to operate in parallel without interfering with one another. 3. Build The agent executes the task, makes changes, and records its work. 4. Verification A separate agent reviews the output with a deliberately adversarial mindset: "Assume the code is broken." This built-in skeptic becomes the system's quality control mechanism. 5. Persistence & Scheduling Results are written to durable storage, not trapped inside a context window. Automated scheduling continuously restarts the loop, turning a workflow into an autonomous system. The most important insight from the paper: Agents are notoriously poor judges of their own work. When an agent evaluates its own output, it tends to approve it. Reliability doesn't emerge from intelligence alone. It emerges from: • Feedback loops • Isolation • Independent verification • Persistent memory • Continuous execution That's the shift. The future of agentic software isn't smarter prompts. It's systems that can discover work, execute it, critique themselves through independent reviewers, remember what happened, and keep going. Read the paper first. Then read the article below. It might change how you think about autonomous software systems, too.
4
10
44
9,528
Very important Meta paper brings Autodata, an agentic data scientist to create high quality synthetic data. The main result is that agent-made data usually trained models better than standard synthetic data, and in legal tasks a trained 4B model beat a much larger 397B baseline. Treats synthetic data generation as a job for an agentic data scientist, not a prompt template. “Agentic Self-Instruct,” makes AI agents generate and meta-optimize synthetic training and evaluation data, improving performance over classical synthetic data methods across CS, legal, and math benchmarks. Autodata’s loop is simple: generate an example, let a weak model and a strong model try it, judge the results, then revise the recipe until the example sits in the useful zone. This is the best idea in the paper: difficulty is not a virtue by itself. A task should not just be “hard”; it should be hard in a way that teaches the weaker model something. If the weak model always gets it right, there is nothing to learn; if it always gets zero, there is also nothing to learn. --- The direction feels important because it reframes synthetic data from bulk imitation into curriculum design. The next frontier may not be models writing more examples, but models learning what makes an example worth learning from. ---- Link – arxiv. org/abs/2606.25996v1 Title: "Autodata: An agentic data scientist to create high quality synthetic data"
9
32
2
151
9,939
AI security goes far beyond AI. Adding an LLM call to a product puts security focus primarily on prompt filtering, output guardrails, and input validation. That is crucial, but it only covers the application layer, and an equally important infra layer needs its own controls. To understand this, trace a single model call. The prompt leaves the app, hits a provider endpoint, and depending on their retention policy, it sits in external logs for days. If that prompt carries any regulated/private data, it moves beyond the app's boundary. This isn't a failure of prompt filtering since it only governs what goes into the model, and it does not enforce where data can travel/who can store it. Beyond application-layer controls, two infrastructure-level concerns need their own coverage: 1) The first is per-request. Every model call moves data outside the app boundary. Who can access it in transit? Is it scoped to the right tenant? 2) The second is posture drift. Do providers retain the data, and for how long? Can one tenant's prompts reach another tenant's context through unintended disclosure? And do the AI outputs stay inside the compliance boundary that enterprise deals require? Teams typically solve both in the application code, where each new AI feature gets its: - own scoping logic - own encryption - own logging Ten features mean ten separate implementations of the same controls. Moving both to the infrastructure layer simplifies this. - If IAM policies control which services can call which endpoints, every new model call will inherit that boundary automatically. - VPC isolation keeps tenant traffic apart at the network level. - Encryption covers every data flow by default. Every API call, including model calls, gets logged without the feature code handling any of it. @awscloud builds this as the managed infra and they have partnered with me today to explain how it works. Model calls through Bedrock or SageMaker inherit the same IAM, VPC, encryption, and CloudTrail boundaries as every other service. For instance, IDEMIA runs this pattern in production. The company handles identity data for 45+ US government agencies. After moving to containers on Amazon EKS in AWS GovCloud, they cut costs by 30% and sped up delivery by 4x, with the security coming from the infrastructure, not the application code. You can read more on how AWS supports ISVs building this way → fandf.co/4d23iNH Also, I wrote a detailed breakdown of the 11 components in a production agent harness, the full software layer that wraps an LLM. This post covers what sits underneath it. The harness is only as secure as the layer it runs on. Read it below.
25
27
3
171
32,870
Debstep retweeted
Every family has its demons. Evil Dead Burn only in theaters July 10. Get Tickets Now!

608
2,293
196
26,453
59,910,216
Debstep retweeted
A senior Anthropic engineer just published the clearest blueprint on "How to give your AI agent a real memory" and it's a 15-page PDF. Write → Consolidate → Recall → Apply • Write: after every attempt, the agent records what it tried and what happened. • Consolidate: it distills those raw attempts into a few reusable lessons, not a transcript dump. • Recall: before the next task, it reads those lessons first. • Apply: it skips the dead ends it already learned, even on a brand new problem. This is exactly how engineers now build agent loops in Claude Code. Read the paper, then grab the setup below 👇
47
157
10
952
121,042
Debstep retweeted
Here is a condensed, high-impact version of the post: Discover -> Hand off -> Verify -> Persist -> Schedule This 12-page PDF completely changed how I build agentic systems. Here is the 5-step blueprint: Discovery: The loop reads CI, issues, and commits to find what's worth fixing. Handoff: Each finding gets an isolated git worktree so parallel agents never collide. Verification: A second agent - built to assume the code is broken, reviews the work. Persistence: Results land on disk, never in a temporary context window. Scheduling: Automation fires the entire process on a timer, making it a true loop. The key insight: An agent grading its own work always praises it. You need that second agent to say "no." Read it now, then explore the article below.
7
27
131
18,562
Debstep retweeted
A senior Anthropic engineer just dropped 11-page PDF on "Loop Engineering" for agentic systems. The shift: you stop prompting the agent. You build the system that prompts it instead. Schedule → Discover → Build → Verify → Repeat Every loop runs one turn, five moves: • Discovery: it finds its own work - failing CI, open issues, recent commits - instead of being handed a list. • Handoff: each task gets an isolated git worktree so parallel agents don't collide. • Verification: a second agent, told to assume the code is broken, reviews the first. The "thing that can say no." • Persistence: results get written to disk, never left in a context window that gets flushed. • Scheduling: an automation wakes it on a timer. That's what makes it a loop. The key insight: an agent grading its own work always praises it. This 11-page PDF changed how I'm building agentic systems today. Read it now, then explore the article below.
123
763
39
4,860
1,272,742