Jean Marie Cimula

[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"

[Mnimiy @Mnilax]

Google and Stanford engineers just dropped a 39-page PDF on what actually makes an AI agent self-improve.

input → output → feedback → update → repeat

the number it opens with: only 9% of agents run a real loop.

the other 91% is a human typing the next prompt by hand.

their case: a loop isn't a vibe, it's three hidden choices
- starting artifact
- credit horizon
- experience batching

i spent weeks getting these three right.

now my loop runs while i sleep and rewrites its own skill file so it never asks me twice.

the paper says why 91% of loops quietly die. the article is the one that didn't.

[Codez @0xCodez]

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.

[Claude @claudeai]

Introducing Claude Fable 5: a Mythos-class model that we’ve made safe for general use.

Its capabilities exceed those of any model we’ve ever made generally available.

[Claude @claudeai]

Fable 5 is state-of-the-art on nearly all tested benchmarks, with exceptional performance in software engineering, knowledge work, scientific research, and vision.

The longer and more complex the task, the larger Fable 5’s lead over our other models.

[Sawyer Merritt @SawyerMerritt]

SpaceX has just announced that they have entered into a $920 million per month agreement with Google to provide compute capacity, according to a new filing.

"On June 5, 2026, we entered into a Cloud Service Agreement with Google with respect to access to compute capacity. The customer has agreed to pay us $920 million per month from October 2026 through June 2029, with capacity ramping up through September at a reduced fee. The compute capacity provided includes approximately 110,000 NVIDIA GPUs, CPUs, memory, and other related components.

After December 31, 2026, the agreement may be terminated by either party upon 90 days' notice. The customer will retain ownership of, and intellectual property rights in, its content, Al models, and related data."

[Aurimas Griciūnas @Aurimas_Gr]

As an 𝗔𝗜 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿 you should also care about regular, non LLM-based ML models, productionising them comes with its own challenges. For example, 𝗖𝗜/𝗖𝗗 process is 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝗳𝗼𝗿 𝗠𝗮𝗰𝗵𝗶𝗻𝗲 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴 𝗣𝗿𝗼𝗷𝗲𝗰𝘁𝘀 compared to regular software.

The important difference that the Machine Learning aspect of the projects brings to the CI/CD process is the treatment of the Machine Learning Training pipeline as a first class citizen of the software world.

➡️ CI/CD pipeline is a separate entity from Machine Learning Training pipeline. There are frameworks and tools that provide capabilities specific to Machine Learning pipelining needs (e.g. KubeFlow Pipelines, Sagemaker Pipelines etc.).
➡️ ML Training pipeline is an artifact produced by Machine Learning project and should be treated in the CI/CD pipelines as such.

What does it mean? Let’s take a closer look:

Regular CI/CD pipelines will usually be composed of at-least three main steps. These are:

𝗦𝘁𝗲𝗽 𝟭: Unit Tests - you test your code so that the functions and methods produce desired results for a set of predefined inputs.

𝗦𝘁𝗲𝗽 𝟮: Integration Tests - you test specific pieces of the code for ability to integrate with systems outside the boundaries of your code (e.g. databases) and between the pieces of the code itself.

𝗦𝘁𝗲𝗽 𝟯: Delivery - you deliver the produced artifact to a pre-prod or prod environment depending on which stage of GitFlow you are in.

What does it look like when ML Training pipelines are involved?

𝗦𝘁𝗲𝗽 𝟭: Unit Tests - in mature MLOps setup the steps in ML Training pipeline should be contained in their own environments and Unit Testable separately as these are just pieces of code composed of methods and functions.

𝗦𝘁𝗲𝗽 𝟮: Integration Tests - you test if ML Training pipeline can successfully integrate with outside systems, this includes connecting to a Feature Store and extracting data from it, ability to hand over the ML Model artifact to the Model Registry, ability to log metadata to ML Metadata Store etc. This CI/CD step also includes testing the integration between each of the Machine Learning Training pipeline steps, e.g. does it succeed in passing validation data from training step to evaluation step.

𝗦𝘁𝗲𝗽 𝟯: Delivery - the pipeline is delivered to a pre-prod or prod environment depending on which stage of GitFlow you are in. If it is a production environment, the pipeline is ready to be used for Continuous Training. You can trigger the training or retraining of your ML Model ad-hoc, periodically or if the deployed model starts showing signs of Feature/Concept Drift.

Let me know your thoughts. 👇

[Xin Eric Wang @xwang_lk]

𝐓𝐡𝐞 𝐁𝐢𝐭𝐭𝐞𝐫 𝐋𝐞𝐬𝐬𝐨𝐧 𝐨𝐟 𝐀𝐠𝐞𝐧𝐭𝐢𝐜 𝐌𝐞𝐦𝐨𝐫𝐲: memory should be a derived capability that exists because it makes an agent better at acting over time.

𝐖𝐨𝐫𝐥𝐝𝐌𝐞𝐦𝐀𝐫𝐞𝐧𝐚 is designed around this principle. Rather than evaluating memory as a storage problem, WorldMemArena evaluates memory through 𝐚𝐜𝐭𝐢𝐨𝐧–𝐰𝐨𝐫𝐥𝐝 𝐢𝐧𝐭𝐞𝐫𝐚𝐜𝐭𝐢𝐨𝐧, instrumenting the full write → maintain → retrieve → use lifecycle across 400 multimodal, multi-session tasks.

And it exposes the findings that should mark the end of the storage-centric era:
→ Storage ≠ use. Better memory storage and retrieval do not necessarily produce better task performance. Optimizing the component we designed does not optimize the capability we actually care about.
→ Harness-based memory performs best where memory is hardest. Agents that can write files, reorganize context, create artifacts, and interact with persistent environments adapt most effectively in long-horizon settings. They are costly and unstable today, which is exactly what many Bitter Lesson transitions look like before scaling and learning take over.

The deeper move is in what gets measured. Memory shouldn't get a score; it should be inferred from capability: how much does remembering improve performance over time.

WorldMemArena drags evaluation off the static object and into the action–world loop, the only place you can tell whether an agent has developed memory or is just simulating it convincingly.

[Matt Dancho (Business Science) @mdancho84]

This is huge.

A group of 50 AI researchers (ByteDance, Alibaba, Tencent + universities) just dropped a 303 page field guide on code models + coding agents.

And the takeaways are not what most people assume.

Here are the highlights I’m thinking about (as someone who lives in Python + agents):

[aditya @adxtyahq]

for anyone asking where to learn this stuff:

• RAG → https://t.co/4bzbUIwV5g
• Agentic RAG → https://t.co/IotOiGmV1Y
• AI Agents → https://t.co/nEeMnVJQbk
• Multi-Agent Systems → https://t.co/pavDPVJEFj
• LangGraph → https://t.co/3miEqqFzF0
• LangGraph (code) → https://t.co/v7kxHZXqba
• MCP → https://t.co/lKawRb4etX
• Memory Systems → https://t.co/LSaT2UaPAS
• Evals → https://t.co/vxChxa1kqQ
• Context Engineering → search "Context Engineering Survey" on arXiv

and please skip the "build an ai agent in 10 minutes" videos
build something, watch it fail, then figure out why.

[Nainsi Dwivedi @NainsiDwiv50980]

Andrej Karpathy just explained the future of software engineering without directly saying it.

The best AI engineers are no longer “prompting.”

They’re building systems around the agents.

Karpathy’s biggest insight wasn’t:
“Claude can code.”

It was:
LLMs become dramatically better when you force them into disciplined workflows.

That’s why "CLAUDE.md" files are suddenly everywhere.

Not because they’re prompts.

Because they behave like an operating system for the agent.

Karpathy called out the exact problems with AI coding:

- models assume instead of asking
- they overengineer simple tasks
- they hide confusion
- they rewrite unrelated code
- they optimize for completion, not correctness

So developers started encoding rules directly into the workflow:

→ Think before coding
→ Simplicity first
→ Surgical edits only
→ Goal-driven execution

And the results are wild.

People are now running multiple Claude Code agents in parallel like engineering teams:

• one agent researching
• one debugging
• one writing tests
• one optimizing code
• one validating outputs

Not “AI assistance.”

Actual orchestration.

And this part from Karpathy changes everything:

“Don’t tell the model what to do. Give it success criteria and let it loop.”

That is the shift.

From:
“write this function”

To:
“here’s the goal, constraints, tests, and verification system — now iterate until correct.”

The craziest part?

This already feels like a phase shift in engineering.

A lot of developers quietly went from:
80% manual coding → to 80% agent-driven coding in just months.

Not because AI became perfect.

Because the leverage became impossible to ignore.

We’re entering an era where the highest leverage engineers won’t necessarily be the best coders.

They’ll be the people who build the best systems around AI agents.

[Tech with Mak @techNmak]

Someone just dropped a 9-layer production AI architecture and it's the most honest breakdown I've seen.

services/ - RAG pipeline, semantic cache, memory, query rewriter, router. Not one file. Five.

agents/ - document grader, decomposer, adaptive router. Self-correcting by design.

prompts/ - versioned, typed, registered. Never hardcoded.

security/ - input, content, output. Three guards not one.

evaluation/ - golden dataset, offline eval, online monitor. Most people skip this entire layer and ship blind.

observability/ - per-stage tracing, feedback linked to traces, cost per query.

.claude/ - agent context so your AI coding assistant knows the codebase before it touches a file.

The demo is one file. Production is this.

[himanshu @himanshustwts]

and here is the full architecture of the LLM Knowledge Base system covering every stage from ingest to future explorations.

[JUMPERZ @jumperz]

karpathy is showing one of the simplest AI architectures that actually works..

dump research into a folder, let the model organise it into a wiki, ask questions, then file the answers back in.

the real insight is the loop...every query makes the wiki better. it compounds.. now thats a second brain building itself.

i think this is so good for agents if applied right

instead of pulling from shared memory every session, they build a living knowledge base that stays.

your coordinator is not just coordinating tasks anymore.. it is maintaining institutional knowledge so every execution adds something back to the base.

the bigger implication is crazy tho.

agents that own their own knowledge layer do not need infinite context windows, they need good file organisation and the ability to read their own indexes.

way cheaper, way more scalable, and way more inspectable than stuffing everything into one giant prompt.

[Andrej Karpathy @karpathy]

LLM Knowledge Bases

Something I'm finding very useful recently: using LLMs to build personal knowledge bases for various topics of research interest. In this way, a large fraction of my recent token throughput is going less into manipulating code, and more into manipulating knowledge (stored as markdown and images). The latest LLMs are quite good at it. So:

Data ingest:
I index source documents (articles, papers, repos, datasets, images, etc.) into a raw/ directory, then I use an LLM to incrementally "compile" a wiki, which is just a collection of .md files in a directory structure. The wiki includes summaries of all the data in raw/, backlinks, and then it categorizes data into concepts, writes articles for them, and links them all. To convert web articles into .md files I like to use the Obsidian Web Clipper extension, and then I also use a hotkey to download all the related images to local so that my LLM can easily reference them.

IDE:
I use Obsidian as the IDE "frontend" where I can view the raw data, the the compiled wiki, and the derived visualizations. Important to note that the LLM writes and maintains all of the data of the wiki, I rarely touch it directly. I've played with a few Obsidian plugins to render and view data in other ways (e.g. Marp for slides).

Q&A:
Where things get interesting is that once your wiki is big enough (e.g. mine on some recent research is ~100 articles and ~400K words), you can ask your LLM agent all kinds of complex questions against the wiki, and it will go off, research the answers, etc. I thought I had to reach for fancy RAG, but the LLM has been pretty good about auto-maintaining index files and brief summaries of all the documents and it reads all the important related data fairly easily at this ~small scale.

Output:
Instead of getting answers in text/terminal, I like to have it render markdown files for me, or slide shows (Marp format), or matplotlib images, all of which I then view again in Obsidian. You can imagine many other visual output formats depending on the query. Often, I end up "filing" the outputs back into the wiki to enhance it for further queries. So my own explorations and queries always "add up" in the knowledge base.

Linting:
I've run some LLM "health checks" over the wiki to e.g. find inconsistent data, impute missing data (with web searchers), find interesting connections for new article candidates, etc., to incrementally clean up the wiki and enhance its overall data integrity. The LLMs are quite good at suggesting further questions to ask and look into.

Extra tools:
I find myself developing additional tools to process the data, e.g. I vibe coded a small and naive search engine over the wiki, which I both use directly (in a web ui), but more often I want to hand it off to an LLM via CLI as a tool for larger queries.

Further explorations:
As the repo grows, the natural desire is to also think about synthetic data generation + finetuning to have your LLM "know" the data in its weights instead of just context windows.

TLDR: raw data from a given number of sources is collected, then compiled by an LLM into a .md wiki, then operated on by various CLIs by the LLM to do Q&A and to incrementally enhance the wiki, and all of it viewable in Obsidian. You rarely ever write or edit the wiki manually, it's the domain of the LLM. I think there is room here for an incredible new product instead of a hacky collection of scripts.

[Nainsi Dwivedi @NainsiDwiv50980]

Holy shit.

Someone just leaked the Claude Code project template teams are quietly using.

This isn't prompting anymore.
This is AI engineering infrastructure. ⚡

The entire setup revolves around one file: CLAUDE.md

Every time Claude makes a mistake → you add a rule
Every time you repeat yourself → you add a workflow
Every time something breaks → you add a guardrail

Claude literally trains itself on your project.

And the structure is wild:

• CLAUDE.md → project memory & instructions
• skills/ → reusable AI workflows
• hooks/ → automated checks & guardrails
• docs/ → architecture decisions
• src/ → actual code modules
• tools/ → scripts + prompts

You're not chatting with AI anymore.
You're building an AI that knows your repo.

The craziest part?

You only configure this once.

After that Claude: – reviews code automatically
– refactors on command
– enforces architecture rules
– writes release notes
– runs workflows from skills
– remembers past mistakes

And it keeps getting smarter.

Most people:
open ChatGPT → write prompt → copy paste → repeat

This setup:
open terminal → run skill → code shipped

You're basically running AI teammates inside your repo.

This template is the difference between: • using Claude occasionally
• running Claude like infrastructure

Drop it in any project.
Your AI stops guessing — and starts operating.

[Srishti @srishticodes]

The 26 prompts running inside 𝗖𝗹𝗮𝘂𝗱𝗲 𝗖𝗼𝗱𝗲 just got open-sourced. This is literally the entire brain of a $200/month AI coding tool.

Someone reverse-engineered every prompt from the accidentally published npm source and you can now study all of them for free.
Claude Code uses 26 distinct prompts to function:

1 system prompt (identity, safety, tool routing)
11 tool prompts (shell, file ops, search, planning)
5 agent prompts (explorer, architect, verifier, docs)
4 memory prompts (summarization, session notes)
1 coordinator prompt (multi-agent orchestration)
4 utility prompts (titles, recaps, suggestions)

The patterns inside are wild:

A dedicated agent whose only job is to TRY TO BREAK the code before it ships
Anti-over-engineering rules baked in: "don't add features beyond what was asked"
9-section memory compression that preserves every user message
Tiered risk system: freely edits your files but asks permission before force-pushing

Every prompt has been rewritten from scratch for legal compliance. Same behavioral intent, no verbatim copying.
Even if you never build an agent, reading these teaches you how the best AI coding tool actually thinks. When it edits, when it asks, when it verifies, when it stops.
This is a free masterclass in prompt architecture.
MIT licensed. Fork it, copy it, learn from it.
https://t.co/2gwPNn7AvZ

[Shann³ @shannholmberg]

how to set up autoresearch with claude code 🧵