Debstep

| Prev @nvidia @tesla @visa @amazon also a @kp_fellows

[Yarchi @undefinedKi]

Meta just shared the AI agent setup it uses internally to cut a 3–4 day task to under 1 hour. Here's how to copy it

Meta first gave one agent all the knowledge. It got confused and started making things up

So they split it in two layers

The boss agent. It does zero real work. It reads the request, checks for duplicates, collects what's needed, runs safety checks and hands the job to the right expert. 6 of its 7 steps are fixed rules, no AI guessing

14 expert agents. Each knows only its own area and sees nothing else, so it can't mix up rules

How to copy it:

Keep your main agent as a router. If it's making real decisions, it's doing too much

Give every expert the same structure: what it knows, what it needs, its steps, common errors and fixes

Store knowledge in separate files that load only when needed. Update a file and every agent uses it next run

For a new task, reorder existing agents before building a new one. Meta shipped a whole new use case with zero new agent code

Result: under 1 hour instead of 3–4 days, and about 2/3 of changes land without major human edits

[elvis @omarsar0]

Learn to build evals, folks.

Highly recommended reading on using decision models for evals.

From our internal evals, System One models like Jev are a great fit for LLM Judges.

If you want to go beyond Hamel's great write-up, I've also put together a few resources on applying decision models to LLM judges.

(bookmark it)

1) Jev-as-a-Judge for Agent Evaluations - https://t.co/SkXGd4uA2J

2) Jev-as-a-Judge: Evaluating Agents with a Decision Model - https://t.co/SqGSzlMFut

Bonus paper I would recommend, with a few other ideas that combine System One and System Two models: Jev-as-a-Judge paper - https://t.co/8Oi6oBEt2A

[Ahmad @TheAhmadOsman]

You wanna learn how do these AI kernels work? Start here

[Akshay 🚀 @akshay_pachaar]

https://t.co/mKhY6lnVIQ

[Avi Chawla @_avichawla]

https://t.co/8j9ZSvQfU1

[Tech with Mak @techNmak]

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. 🧵

[Ashutosh Maheshwari @asmah2107]

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

[Turing Post (Ksenia Se) @TheTuringPost]

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 -> https://t.co/0Zx8M5tZzG

[Akshay 🚀 @akshay_pachaar]

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: https://t.co/9AEZ7DRn68

[Movez @0xMovez]

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.

[elvis @omarsar0]

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: https://t.co/HuR9YWSTPr

Learn to build effective AI agents in our academy: https://t.co/1e8RZKs4uX

[Phosphen @phosphenq]

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.

[h100envy @h100envy]

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.

[Tanay Harinkhede @Tanaypawar27]

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: https://t.co/OBfDwz7W0O
2. LLMs from Scratch: https://t.co/oeOci6NERy
3. Agentic AI Overview (Stanford): https://t.co/5POKytu6ID
4. Building and Evaluating Agents: https://t.co/E5FFlGUDAy
5. Building Effective Agents: https://t.co/kusHO3dLyf
6. Building Agents with MCP: https://t.co/cCEsddKbou
7. Building an Agent from Scratch: https://t.co/8xWp3CmFch
8. Philo Agents: https://t.co/D4CENugUBX

🗂️ Repos

1. GenAI Agents: https://t.co/4KZ9sJmLCs
2. Microsoft's AI Agents for Beginners: https://t.co/vPvgZwjrED
3. Prompt Engineering Guide: https://t.co/ZJPx57nwFP
4. Hands-On Large Language Models: https://t.co/awbIDVAhWe
5. AI Agents for Beginners: https://t.co/vPvgZwjrED
6. GenAI Agents: https://t.co/A7aZkomCyY
7. Made with ML: https://t.co/rvYry8ZDvF
8. Hands-On AI Engineering: https://t.co/HjMTW5nvW1
9. Awesome Generative AI Guide: https://t.co/qGocn6df1V
10. Designing Machine Learning Systems: https://t.co/zZC31InA1q
11. Machine Learning for Beginners from Microsoft: https://t.co/SBVf1FPH6f
12. LLM Course: https://t.co/OCAvim3jah

🗺️ Guides

1. Google's Agent Whitepaper: https://t.co/VYeTNLRPE9
2. Google's Agent Companion: https://t.co/4gy8NGQe53
3. Building Effective Agents by Anthropic: https://t.co/WcMyxPSiN0
4. Claude Code Best Agentic Coding practices: https://t.co/d01rxIEmrH
5. OpenAI's Practical Guide to Building Agents: https://t.co/fsQrbj1QUQ

📚 Books:

1. Understanding Deep Learning: https://t.co/zf0RZ1gaO4
2. Building an LLM from Scratch: https://t.co/rCEkYCd7ei
3. The LLM Engineering Handbook: https://t.co/cHxt9qbfnL
4. AI Agents: The Definitive Guide - Nicole Koenigstein: https://t.co/No7GopeCi9
5. Building Applications with AI Agents - Michael Albada: https://t.co/KxDWj7p8Dm
6. AI Agents with MCP - Kyle Stratis: https://t.co/Pdaw6hnlNh
7. AI Engineering: https://t.co/kqEMbAXVDO

📜 Papers

1. ReAct: https://t.co/gU23m8z2Iw
2. Generative Agents: https://t.co/5CCFoHUMT3
3. Toolformer: https://t.co/ux2vgBLQJW
4. Chain-of-Thought Prompting: https://t.co/v6iOKX28QT

🧑🏫 Courses:

1. HuggingFace's Agent Course: https://t.co/njL6khzCWz
2. MCP with Anthropic: https://t.co/TWp2H7ltsz
3. Building Vector Databases with Pinecone: https://t.co/bPCar16QJu
4. Vector Databases from Embeddings to Apps: https://t.co/6AwTQ3Y0nf
5. Agent Memory: https://t.co/EZSaCFaHDE

👇 Comment “AI” for more resources

Repost for your network ♻️

Bookmark for future.

[Morty @0xMortyx]

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.

[Vikas gupta @vicky_grok]

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.

[Rohan Paul @rohanpaul_ai]

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"

[Akshay 🚀 @akshay_pachaar]

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 → https://t.co/1QlubZ8YpR

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.

[Evil Dead @EvilDead]

Every family has its demons. Evil Dead Burn only in theaters July 10. Get Tickets Now!

[darkzodchi @zodchiii]

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 👇